找回密码
 立即注册
GTA5修改器.风灵月影生化危机7修改器.风灵月影三国志13修改器.风灵月影讨鬼传2修改器.风灵月影猎天使魔女修改器.风灵月影
刺客信条修改器虐杀原形2修改器.风灵月影看门狗2修改器.风灵月影鬼泣5修改器.风灵月影上古卷轴5修改器
查看: 59|回复: 0

工作室辅助!剑灵辅助源码VS2012 +调用Lua 脚本 +调用控件CALL

[复制链接]

2604

主题

2627

帖子

8001

积分

论坛元老

Rank: 8Rank: 8

积分
8001
发表于 2017-7-1 23:53:34 | 显示全部楼层 |阅读模式
01.jpg
曾经的辉煌已停留在曾经。。。。此款辅助在2012年工作室内部流通,如今发布整套源代码。包括VMP,钩子库,lua库,一个都不少。。。非常强大的商业辅助源代码。
开发工具:VS2012  

能用的技术基本都用上了,各种牛逼。。。。
//Lua 捡起物品
static int Pickup(lua_State* L)
{
    int iRange = lua_tointeger(L, 1);
    GamecallEx::GetInstance()->Pickup(iRange);
    return 0;
}
//Lua  吃药
static int ChiYao(lua_State* L)
{
    const char* pszText = lua_tostring(L, 1);
    GamecallEx::GetInstance()->ChiYao((wchar_t*)pszText);
    return 0;
}

//调用控件CALL
void Gamecall::DaKaiJiNengMianBan(DWORD adress, DWORD adress1) //打开技能面板
{

    KONGJ kj;
    kj.canshu1 = QUDINGYAOJIANG_JIEGOUTOU;
    kj.canshu2 = 0x0;
    kj.canshu3 = 0x544D0EA8;
    kj.canshu4 = 0x0;
    kj.canshu5 = adress1;      //[[控件的首地址+0x4C]+0x7D4]
    kj.canshu6 = 0x1;
    kj.canshu7 = 0x2;
    kj.canshu8 = 0x0;
    kj.canshu9 = 0x0;
    kj.canshu10 = 0x0;
    kj.canshu11 = 0x0;
    kj.canshu12 = 0x4EFE0016;

    __try
    {
        _asm
        {
            mov ecx, adress; //这个是控件的首地址  "SystemMenuPanel"
            mov edx, [ecx];
            mov eax, [edx+0x4];

            lea ebx, kj;
            push ebx;
            call eax
        }
    }
    __except(1)
    {
        TRACE(_T("打开技能面板CALL错误"));
    }
}



//复活CALL
void Gamecall::Fuhuo(DWORD uiAddr)
{

    __try
    {
        TRACE(_T("进入复活call uiAddr:%d"), uiAddr);
        __asm
        {
            mov eax, uiAddr;
            push eax;
            mov ecx, 0x3;
            mov eax, fuhuo_call;
            call eax;
        }
    }
    __except(1)
    {
        TRACE(_T("复活失败"));
    }
}

//走路CALL;
void Gamecall::Step(float x, float y, float z)
{

    __try
    {
        __asm
        {
            mov  edi, Offset_Game_Base
            mov  edi, [edi]
            mov  edi, [edi+ Offset_Game_Offset]
            mov  edi, [edi+ Offset_Role_Offset]
            mov  ecx, [edi+ Offset_Role_Attr]

            fld  z
            sub  esp, 0xC
            fstp [esp+ 0x8]
            fld  y
            fstp [esp+ 0x4]
            fld  x
            fstp [esp]
            mov eax, FUNC_WALK
            call eax;
        }
    }
    __except(1)
    {
        TRACE(FUNCNAME);
    }

}



//攻击
//参数1: 技能id
int Gamecall::_Attack(int id)  //技能攻击  传入的是技能ID
{
    _ASSERTE(id != 0);


    char bRet;
    __try
    {
        __asm
        {
            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax + attack_offset1];
            mov eax, [eax + attack_offset2];
            mov esi, [eax + attack_offset3];
            push id;
            push esi;
            mov eax, attack_call;
            call eax;
            mov bRet, al;
        }
    }
    __except(1)
    {
        TRACE(FUNCNAME);
    }
    return bRet;
}


//开盒子 参数是盒子在背包中的格子数
void Gamecall::KaiHeZi(_BAGSTU& bag)
{

    int value = bag.m_Info;
    value <<= 16;
    value += package;


    __try
    {
        __asm
        {
            push 0;
            push 0;
            push 0;
            push 0;
            push 1;
            push 0;
            mov ebx, value;
            push ebx;
            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax+kaihezi_offset1];
            mov eax, [eax+kaihezi_offset2];
            mov eax, [eax+kaihezi_offset3];
            push eax;
            mov ecx, 0xFF;
            mov eax, kaihezi_call;
            call eax;

        }
    }
    __except(1)
    {
        TRACE(_T("开盒子出错"));
    }
}



BOOL Gamecall::FillGoods(_BAGSTU& BagBuff)
{

    _try
    {
        BagBuff.m_ID      =   GetGoodsID(BagBuff.m_Base);                //获取物品的ID
        if(BagBuff.m_ID == UINT_MAX)
            return FALSE;

        BagBuff.m_NameID  =   GetGoodsNameID(BagBuff.m_Base);            //获取物品的名字ID


        BagBuff.name   =    GetObjectNameByIndex(BagBuff.m_NameID);
        if(BagBuff.name == NULL) return FALSE;


        BagBuff.m_Type    =   GetGoodsType(BagBuff.m_Base);              //获取物品的类型
        BagBuff.m_Info    =   GetGoodsPos(BagBuff.m_Base);              //获取物品的所在格子数
        BagBuff.m_Num     =   GetGoodsNum(BagBuff.m_Base);               //获取物品的数量
        BagBuff.CurDur =   GetGoodsDur(BagBuff.m_Base);           //获取物品的持久
        BagBuff.m_LV      =   GetGoodsLV(BagBuff.m_Base);               //获取物品的等级



        BagBuff.m_BagLeiXing = GetGoodsBagInfo(BagBuff.m_Base);  //获取物品的背包类型
        //BagBuff.m_CaoZuoType  = GetGoodsYouJianType(BagBuff.m_BagLeiXing, BagBuff.m_Info); //获取背包物品右键操作类型


        BagBuff.m_YanSe      =   GetGoodsColor(BagBuff.m_Base);  //获取物品的颜色
        BagBuff.m_IsFengYin  =   0;//GetGoodsIsFengYin(BagBuff.m_Base);  //获取物品是否封印
        if(BagBuff.m_YanSe == 5)
        {
            //TRACE("此物品是紫色   %X",BagBuff.m_CaoZuoType);
        }
        if(BagBuff.m_YanSe == 4)
        {
            //TRACE("此物品是蓝色   %X",BagBuff.m_CaoZuoType);
        }
        if(BagBuff.m_YanSe == 3)
        {
            //TRACE("此物品是绿色   %X",BagBuff.m_CaoZuoType);
        }
        if(BagBuff.m_YanSe == 2)
        {
            //TRACE("此物品是白色   %X",BagBuff.m_CaoZuoType);
        }
        //if(BagBuff.m_CaoZuoType == 0x0E)
        //{
        //    //TRACE("此物品是未解封的装备  总各数 %X,首地址 %X 物品右键操作类型  %X",GridNum,BagBuff.m_Base,BagBuff.m_CaoZuoType);
        //}
        //else if(BagBuff.m_CaoZuoType == 0x0F)
        //{
        //    //TRACE("此物品是未解封的盒子  总各数 %X,首地址 %X 物品右键操作类型  %X",GridNum,BagBuff.m_Base,BagBuff.m_CaoZuoType);
        //}
        else
        {
            //TRACE("总各数 %X,首地址 %X 物品右键操作类型  %X",GridNum,BagBuff.m_Base,BagBuff.m_CaoZuoType);
        }


        /*
        改个地方,需要强化时再取信息.
        if(BagBuff.m_Type == 1 || BagBuff.m_Type == 5)
        {
            if(BagBuff.m_YanSe == 4 || BagBuff.m_YanSe == 5)
            {
                BagBuff.m_BiDui1 =  GetGoodsBiDui(BagBuff.m_Base);  //获取物品的比对
                BagBuff.m_BiDui2 =  GetGoodsBiDui_A(BagBuff.m_Base);  //获取物品的比对1
                if(BagBuff.m_BiDui1 < BagBuff.m_BiDui2)
                {
                    BagBuff.m_DangQianJingYanZongZhi = GetMuQianJingYanZongZhi(BagBuff.m_Base); // 获取当前武器经验总值
                }
                if(BagBuff.m_BiDui1 >= BagBuff.m_BiDui2)
                {
                    BagBuff.m_DangQianJingYanZongZhi = GetMuQianJingYanZongZhi_A(BagBuff.m_Base); // 获取当前武器经验总值
                }

                BagBuff.m_DangQianJingYanZhi  = GetGoodsWuQiDangQianJingYan(BagBuff.m_Base);  //获取武器当前的经验
                BagBuff.m_PingJi = GetGoodsWuQiPingJi(BagBuff.m_Base);  //获取武器的评级

            }
        }*/


        if(BagBuff.m_Type == 4)
        {
            BagBuff.m_BaGuaGeZiShu = GetBaGuaGeZiShu(BagBuff.m_Base);  //获取八卦格子数
        }
    }
    _except(1)
    {
        TRACE(FUNCNAME);
        return FALSE;
    }

    return TRUE;
}

void Gamecall::_GetAllGoodsToVector(BagVector& RangeObject)
{
    DWORD BagbodyAdress = 0;
    DWORD BagAdress = 0;
    int GridNum = 0;
    BAGSTU aGoods;

    BagbodyAdress = GetBagbodyInfoBase();                                 //获取背包身上装备仓库遍历Base
    BagAdress = GetBagInfoBase(BagbodyAdress);                        //获取背包遍历Base
    GridNum = GetBagGridNumber();                        //当前背包的总的格子数

    for(int i = 0; i < GridNum; i++)
    {
        ZeroMemory(&aGoods, sizeof(aGoods));
        __try
        {
            aGoods.m_Base = GetGoodsBase(BagAdress, i);                 //获取物品的首地址
            if(aGoods.m_Base != 0)
            {
                if(FillGoods(aGoods))
                {
                    //游戏里本来是0
                    aGoods.m_Num = (aGoods.m_Num == 0 ? 1 : aGoods.m_Num);

                    RangeObject.push_back(aGoods);
                }
            }

        }
        __except(1)
        {
            TRACE(FUNCNAME);
        }
    }
}


//遍历背包数据到容器
void Gamecall::GetAllGoodsToVector(BagVector& RangeObject)
{
    _GetAllGoodsToVector(RangeObject);
}


void Gamecall::_GetAllBodyEquipToVector(BagVector& RangeObject)
{
    DWORD BagbodyAdress = 0;
    DWORD BagAdress = 0;
    int Gridnum = 0;
    _BAGSTU aGoods;

    BagbodyAdress = GetBagbodyInfoBase();
    BagAdress = GetBodyInfoBase(BagbodyAdress);
    Gridnum = GetBagGridNumber();//0x10;//
    //当前背包的总的格子数
    for(int i = 0; i < Gridnum; i++)
    {
        ZeroMemory(&aGoods, sizeof(_BAGSTU));
        __try
        {
            aGoods.m_Base = GetGoodsBase(BagAdress, i);

            if(aGoods.m_Base != 0)
            {
                //TRACE1("base:%x",)
                if(FillGoods(aGoods))
                    RangeObject.push_back(aGoods);
            }
        }
        __except(1)
        {
            TRACE(FUNCNAME);
        }
    }
}

//遍历装备数据到容器
void Gamecall::GetAllBodyEquipToVector(BagVector& RangeObject)
{
    sendcall(id_msg_GetAllBodyEquipToVector, &RangeObject);
}

void Gamecall::GetStrikeToVector(StrikeVector& RangeObject)
{

    DWORD PPTR = ReadDWORD(Offset_Game_Base);
    PPTR = ReadDWORD(PPTR + Offset_Skill_Offset1);
    PPTR = ReadDWORD(PPTR + Offset_Skill_Offset2);

    //{技能指针}
    PPTR = ReadDWORD(PPTR + Offset_Skill_Offset3 - Offset_Skill_Offset4 + Offset_Skill_Offset5 + Offset_Skill_Skill);
    _ASSERTE(PPTR != 0);


    //{技能首地址}
    DWORD PSkillBegin = ReadDWORD(PPTR + Offset_Skill_PBSkill);
    _ASSERTE(PSkillBegin != 0);


    //{技能尾地址}
    DWORD PSkillEnd = ReadDWORD(PPTR + Offset_Skill_PESkill);
    _ASSERTE(PSkillEnd != 0);

    DWORD dwCount = (PSkillEnd - PSkillBegin) / 4;

    if(dwCount < 0 || dwCount > 20)
    {
        return;
    }


    STRIKEINFO stJn;

        int i;
    for(i = 0; i < dwCount; i++)
    {

        //{信息指针}
        DWORD PInfo = ReadDWORD(PSkillBegin + i * 4);
        _ASSERTE(PInfo > 0);

        stJn.id = ReadDWORD(PInfo + Offset_Skill_Id);
        if(stJn.id > 0)
        {
            stJn.iType = ReadByte(PInfo + Offset_Skill_Type);

            if(ReadDWORD(PInfo + Offset_Skill_NameLen) >= 0xf)
            {
                stJn.name = (wchar_t*)ReadDWORD(PInfo + Offset_Skill_Name);
                _ASSERTE(stJn.name != NULL);
            }
            else
            {
                stJn.name = (wchar_t*)(PInfo + Offset_Skill_Name);
                _ASSERTE(stJn.name != NULL);
            }

            stJn.bCD = (ReadDWORD(PInfo + Offset_Skill_CD) == 0);

            stJn.bAviable = (ReadDWORD(PInfo + Offset_Skill_AState) == 0);


            stJn.iIndex = i;
            stJn.iKeyCode = 0xff; //暂时没用
            RangeObject.push_back(stJn);
        }

    }



    PPTR = ReadDWORD(Offset_Game_Base);
    PPTR = ReadDWORD(PPTR + Offset_Skill_Offset1);
    PPTR = ReadDWORD(PPTR + Offset_Skill_Offset2);

    //{技能指针}
    PPTR = ReadDWORD(PPTR + Offset_Skill_Offset3 - Offset_Skill_Offset4 + Offset_Skill_Offset5 + Offset_Skill_ASkill);
    _ASSERTE(PPTR != 0);


    //{技能首地址}
    PSkillBegin = ReadDWORD(PPTR + Offset_Skill_PBASkill);
    _ASSERTE(PSkillBegin != 0);


    //{技能尾地址}
    PSkillEnd = ReadDWORD(PPTR + Offset_Skill_PEASkill);
    _ASSERTE(PSkillEnd != 0);

    dwCount = (PSkillEnd - PSkillBegin) / 4;

    if(dwCount < 0 || dwCount > 20)
    {
        return;
    }


    for(int i = 0; i < dwCount; i++)
    {

        //{信息指针}
        DWORD PInfo = ReadDWORD(PSkillBegin + i * 4);
        _ASSERTE(PInfo > 0);

        stJn.id = ReadDWORD(PInfo + Offset_Skill_Id);
        if(stJn.id > 0)
        {
            stJn.iType = ReadByte(PInfo + Offset_Skill_Type);

            if(ReadDWORD(PInfo + Offset_Skill_NameLen) >= 0xf)
            {
                stJn.name = (wchar_t*)ReadDWORD(PInfo + Offset_Skill_Name);
                _ASSERTE(stJn.name != NULL);
            }
            else
            {
                stJn.name = (wchar_t*)(PInfo + Offset_Skill_Name);
                _ASSERTE(stJn.name != NULL);
            }

            stJn.bCD = (ReadDWORD(PInfo + Offset_Skill_CD) == 0);

            stJn.bAviable = (ReadDWORD(PInfo + Offset_Skill_AState) == 0);

            stJn.iIndex = i;
            stJn.iKeyCode = 0xff; //暂时没用
            RangeObject.push_back(stJn);
        }

    }


}


//判断是否进入角色选择界面
BOOL Gamecall::isLoginInSelectPlayer()
{
    DWORD dwUIAddr = 0;
    DWORD value = UINT_MAX;
    __try
    {
        GetUIAddrByName(L"SelectCharacterPanel", &dwUIAddr);
        __asm
        {
            mov eax, dwUIAddr;
            mov eax, [eax + select_character_offset];
            mov value, eax;
        }

    }
    __except(1)
    {
        TRACE(FUNCNAME);
    }

    return (value != 0xff);
}


//卸宝石
void Gamecall::XieBaoShi(DWORD canshu1, DWORD canshu2, DWORD canshu3)
{
    __try
    {
        __asm
        {
            mov ebx, canshu1;
            push ebx;
            mov ebx, canshu2;
            push ebx;
            mov ebx, canshu3;
            push ebx;

            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax + xiebaoshi_offset1];
            mov eax, [eax + xiebaoshi_offset2];
            mov ecx, [eax + xiebaoshi_offset3];
            push ecx;

            mov ebx, xiebaoshi_call;
            call ebx;
        }
    }
    __except(1)
    {
        TRACE(FUNCNAME);
    }
}


//加宝石
void Gamecall::JiaBaoShi(DWORD canshu1, DWORD canshu2, DWORD canshu3, DWORD canshu4, DWORD canshu5)
{
    __try
    {
        __asm
        {
            mov ebx, canshu1;
            push ebx;
            mov ebx, canshu2;
            push ebx;
            mov ebx, canshu3;
            push ebx;
            mov ecx, canshu4;
            push ecx;
            mov edx, canshu5;
            push edx;

            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax +  jiabaoshi_offset1];
            mov eax, [eax +  jiabaoshi_offset2];
            mov eax, [eax +  jiabaoshi_offset3];
            push eax;

            mov ebx,  jiabaoshi_call;
            call ebx;
        }
    }
    __except(1)
    {
        TRACE(FUNCNAME);
    }
}


DWORD Gamecall::sendcall(DWORD id, LPVOID pParam)
{
    return SendMessage(theApp.m_hGameWnd, WM_CUSTOM_GCALL, id, (LPARAM)pParam);
}


void Gamecall::Stepto3x()
{

    DWORD Adress = (DWORD)m_hModuleBsEngine + SHENXINGBAIBIANCHAZHI;

    __try
    {
        __asm
        {
            mov eax, Adress;
            mov eax, [eax];
            mov eax, [eax + x3step_offset1];
            mov eax, [eax + 0x0];
            mov eax, [eax + x3step_offset3];
            mov eax, [eax + x3step_offset4];
            mov ebx, 0x44610000;

            mov dword ptr [eax + x3step_offset5], ebx;
        }


    }
    __except(1)
    {
        TRACE(FUNCNAME);
    }
}

//打开对话框, 参数 npcid, npcid2
void Gamecall::DaKaiDuiHuaKuang(DWORD ID, DWORD ID2)
{
    __try
    {
        __asm
        {
            push 0;
            push 0;
            mov eax, ID2;
            push eax;
            mov eax, ID;
            push eax;
            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax + open_npc_offset1];
            mov eax, [eax + open_npc_offset2];
            mov ecx, [eax + open_npc_offset3];
            push ecx;

            mov eax, open_npc_call;
            call eax;
        }
    }
    __except(1)
    {
        TRACE(FUNCNAME);
    }
}


//购买
//参数1: 数量
//参数2: 索引
//参数3: 地址 ItemStorePanel ui
void Gamecall::GouMaiWuPing(DWORD Num, DWORD Ind, DWORD Adress)
{
    __try
    {
        __asm
        {
            push 0;
            push 0;
            mov eax, Num;
            push eax;
            mov eax, Ind;
            push eax;
            mov ecx, Adress;
            mov eax, buy_call;
            call eax;
        }
    }
    __except(1)
    {
        TRACE(FUNCNAME);
    }
}


//药品CD_CALL
// 1 == 没有cd
// 0 == cd中
DWORD Gamecall::isYaoPingCD(_BAGSTU& goods)
{
    BYTE m_Adress = 0;
    YaoPingCD_JG CD;

    int value = goods.m_Info;
    value <<= 16;
    value += package;

    int adress = goods.m_Base;


    _try
    {
        __asm
        {
            mov ecx, yao_cd_base;
            mov ecx, [ecx];
            mov ecx, [ecx+ yao_cd_offset1];
            mov edx, [ecx];
            mov edx, [edx+yao_cd_offset2];

            mov eax, adress;
            mov eax, [eax+yao_cd_offset3];
            mov ebx, [eax+yao_cd_offset4];
            push ebx;
            mov ebx, [eax+ yao_cd_offset5];
            push ebx;
            call edx;
            mov CD.canshu1, eax;
            mov CD.canshu2, -1;

            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax+ yao_cd_offset6];
            mov eax, [eax+ yao_cd_offset7];
            mov eax, [eax+ yao_cd_offset8];
            mov CD.canshu3, eax;

            lea eax, CD;
            push eax;
            push 0;
            mov ecx, value;
            push ecx;

            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax+yao_cd_offset9];
            mov ebx, [eax+yao_cd_offset10];

            mov esi, ebx;
            mov eax, yao_cd_call ;
            call eax;


            mov m_Adress, al;
        }
    }
    _except(1)
    {
        TRACE(_T("药品CD_CALL出错"));
        return -1;
    }

    return (DWORD)m_Adress;
}




//转向
void Gamecall::TurnTo(fPosition& pos)
{
    fPosition mypos;
    GetPlayerPos(&mypos);

    //重叠的情况
    if(mypos.x == pos.x && mypos.y == pos.y)
    {
        TRACE(_T("转视角时, 目标和我是重叠的"));
        //这里不解决重叠, 重叠让走路解决
        RandomStep(60);
        //直接退
        //return;
    }

    //TRACE(_T("当前怪物坐标,%d,%d,%d"),(int)pos.y,(int)pos.x,(int)pos.z);


    double value1;
    double value2;

    value1 = mypos.y - pos.y;
    value2 = mypos.x - pos.x;

    double angle = atan2(abs(value1), abs(value2)) * 180 / M_PI;

    //算成游戏内角度
    double gameangle = angle * 182;
    //logdv(_T("gameangle = %d"), (int)gameangle);

    //取当前角色角度
    int playerangle = (int)GetPlayerViewPoint();
    playerangle = playerangle % 65536;
    //logdv(_T("角色面向: %d"), playerangle);

    //判断当前角色的视角在第几象限
    if((pos.x > mypos.x) &&
            (pos.y > mypos.y))
    {
        //logdv(_T("目标当前东北"));
    }
    else if((pos.x > mypos.x) &&
            (pos.y < mypos.y))
    {
        //logdv(_T("目标在当前西北"));
        gameangle = 65536 - gameangle;
    }
    else if((pos.x < mypos.x) &&
            (pos.y < mypos.y))
    {
        //logdv(_T("目标当前西南"));
        gameangle += SOUTH;
    }
    else if((pos.x < mypos.x) &&
            (pos.y > mypos.y))
    {
        gameangle = SOUTH - gameangle;
        //gameangle += EAST;
    }
    else if((pos.x == mypos.x) &&
            (pos.y > mypos.y))  //x轴相同
    {
        //正东
        gameangle = EAST;
    }
    else if((pos.x == mypos.x) &&
            (pos.y < mypos.y))  //x轴相同
    {
        //正西面
        gameangle = WEST;
    }
    else if((pos.x > mypos.x) &&
            (pos.y = mypos.y))  //y轴相同
    {
        //正北
        gameangle = NORTH;
    }
    else if((pos.x < mypos.x) &&
            (pos.y = mypos.y))  //y轴相同
    {
        //正南
        gameangle = SOUTH;
    }

    //TRACE(_T("计算出角度:%d"),(int)gameangle);

    Turn((int)gameangle);
}


//捡起尸体
//范围默认500
BOOL Gamecall::PickupDeadbody(DWORD range)
{
    ObjectVector RangeObject;
    GetRangeObjectToVector(GetObjectBinTreeBaseAddr(), range, RangeObject);


    ObjectNode* pMaxNode = NULL;


    for(DWORD i = 0; i < RangeObject.size(); i++)
    {

        ObjectNode* pNode = RangeObject;


        //判断对象是否是可举起的尸体
        if(isDeadBody(pNode->ObjAddress))
        {
            pMaxNode = pNode;

            if(pNode->id > pMaxNode->id)
                pMaxNode = pNode;

        }
    }

    if(pMaxNode == NULL)
    {
        TRACE(_T("没有遍历到尸体"));
        return false;
    }

    PARAM_2 temp;
    temp.argv1 = pMaxNode->id;
    temp.argv2 = pMaxNode->id2;
    sendcall(id_msg_PickupDeadbody, &temp);

    return TRUE;
}







void Gamecall::DeleteItem(_BAGSTU& bag)
{
    int pos = bag.m_Info;
    int value = pos;
    value <<= 16;
    value += package;

    int nums = bag.m_Num;

    __try
    {
        __asm
        {
            mov eax, nums;
            push eax;
            mov eax, value;
            push eax;
            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax + bag_delete_offset1];
            mov eax, [eax + bag_delete_offset2];
            mov eax, [eax + bag_delete_offset3];
            push eax;

            mov eax, bag_delete_call;
            call eax;
        }

    }
    __except(1)
    {
        TRACE(_T("销毁物品时发生错误"));
    }


}
//随机方向走
void Gamecall::RandomStep(DWORD range)
{
    fPosition fmypos;
    GetPlayerPos(&fmypos);

    if((rand() % 2) == 1)
    {
        fmypos.x += range;
        fmypos.y += range;
    }
    else
    {
        fmypos.x -= range;
        fmypos.y -= range;
    }

    Stepto(fmypos, 5, 10, 1000, TRUE);
}


void Gamecall::QuChuJiNengDian(DWORD ID) //去除技能点
{
    sendcall(id_msg_QuChuJiNengDian, (LPVOID)ID);
}


void Gamecall::_QuChuJiNengDian(DWORD ID) //去除技能点
{
    __try
    {
        _asm
        {
            push 0;
            mov eax, ID;
            push eax;
            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax+delete_strike_call_offset1];       //去除技能点一级偏移
            mov eax, [eax+delete_strike_call_offset2];       //去除技能点二级偏移
            mov eax, [eax+delete_strike_call_offset3];      //去除技能点三级偏移
            push eax;
            mov ebx, delete_strike_call;
            call ebx;
        }
    }
    __except(1)
    {
        TRACE(_T("去除技能点"));
    }

}



void Gamecall::DaKaiQingChuQuanBuJiNengJieMian(DWORD adress, DWORD adress1) //打开清除全部技能界面
{


    KONGJ kj;
    kj.canshu1 = QUDINGYAOJIANG_JIEGOUTOU;
    kj.canshu2 = 0x0;
    kj.canshu3 = 0x544D0EA8;
    kj.canshu4 = 0x0;
    kj.canshu5 = adress1;
    kj.canshu6 = 0x1;
    kj.canshu7 = 0x2;
    kj.canshu8 = 0x0;
    kj.canshu9 = 0x0;
    kj.canshu10 = 0x0;
    kj.canshu11 = 0x0;
    kj.canshu12 = 0x4EFE0016;

    __try
    {
        _asm
        {
            mov ecx, adress; //这个是控件的首地址  "SkillTrainPanel"
            mov edx, [ecx];
            mov eax, [edx+0x4];

            lea ebx, kj;
            push ebx;
            call eax
        }
    }
    __except(1)
    {
        TRACE(_T("打开清除全部技能界面CALL错误"));
    }
}

//打开清空技能点的ui
void Gamecall::OpenDeleteTalentPanel()
{
    sendcall(id_msg_OpenDeleteTalentPanel, 0);
}
//打开清空技能点的ui
void Gamecall::_OpenDeleteTalentPanel()
{
    DWORD dwUIAddr = 0;
    //PARAM_GETUIADDRBYNAME temp;
    //temp.argv1 = (DWORD)GetUIBinTreeBaseAddr();
    //temp.argv2 = (DWORD);
    //temp.argv3 = (DWORD);
    GetUIAddrByName(L"SkillTrainPanel", &dwUIAddr);
    DWORD canshu2 = 0;
    canshu2 =  ReadDWORD(dwUIAddr + clearstrike_isopen);

    if(canshu2 > 0)
    {
        DaKaiQingChuQuanBuJiNengJieMian(dwUIAddr, canshu2); //打开清除全部技能界面
    }
}

//确认清除全部技能界面
void Gamecall::QueRenQingChuQuanBuJiNengJieMian(DWORD adress, DWORD adress1)
{


    KONGJ kj;
    kj.canshu1 = QUDINGYAOJIANG_JIEGOUTOU;
    kj.canshu2 = 0x0;
    kj.canshu3 = 0x544D0EA8;
    kj.canshu4 = 0x0;
    kj.canshu5 = adress1;      //控件的首地址+0x70
    kj.canshu6 = 0x1;
    kj.canshu7 = 0x2;
    kj.canshu8 = 0x0;
    kj.canshu9 = 0x0;
    kj.canshu10 = 0x0;
    kj.canshu11 = 0x0;
    kj.canshu12 = 0x4EFE0016;

    __try
    {
        __asm
        {
            mov ecx, adress; //这个是控件的首地址  "SkillTrainInitConfirmPanel"
            mov edx, [ecx];
            mov eax, [edx+0x4];

            lea ebx, kj;
            push ebx;
            call eax
        }
    }
    __except(1)
    {
        TRACE(_T("确认清除全部技能界面CALL错误"));
    }
}

//确认删除天赋的ui
void Gamecall::ConfirmDeletePalentPanelShowOk()
{
    sendcall(id_msg_ConfirmDeletePalentPanelShowOk, 0);
}

//确认删除天赋的ui
void Gamecall::_ConfirmDeletePalentPanelShowOk()
{
    DWORD dwUIAddr = 0;
    GetUIAddrByName(L"SkillTrainInitConfirmPanel", &dwUIAddr);
    if(dwUIAddr)
    {
        DWORD canshu2 = 0;
        canshu2 =  ReadDWORD(dwUIAddr + 0x70);

        if(canshu2 > 0)
        {
            QueRenQingChuQuanBuJiNengJieMian(dwUIAddr, canshu2); //确认清除全部技能界面
        }
    }

}

//确认清除天赋的ui有没有显示
BOOL Gamecall::isConfirmDeleteTalnetPanelShow()
{
    DWORD dwUIAddr = 0;
    GetUIAddrByName(L"SkillTrainInitConfirmPanel", &dwUIAddr);
    if(dwUIAddr != 0)
    {
        DWORD canshu2 = 0;
        canshu2 =  ReadDWORD(dwUIAddr + clearstrike_isopen);
        if(canshu2)
            return TRUE;
        if(canshu2 == 0)
            TRACE(_T("清除技能界面没有打开"));
    }

    return FALSE;

}

void Gamecall::QueRenJiNengDian() //确认技能点
{
    sendcall(id_msg_QueRenJiNengDian, 0);
}

void Gamecall::_QueRenJiNengDian() //确认技能点
{
    __try
    {
        _asm
        {
            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax+confrim_add_strike_offset1];   //确认技能点一级偏移
            mov eax, [eax+confrim_add_strike_offset2];   //确认技能点二级偏移
            mov eax, [eax+confrim_add_strike_offset3];  //确认技能点三级偏移
            push eax;
            mov eax, confrim_call;
            call eax;


        }
    }
    __except(1)
    {
        TRACE(_T("确认技能点错误"));
    }

}

void Gamecall::JiaJiNengDian(DWORD ID) //加技能点
{
    sendcall(id_msg_JiaJiNengDian, (LPVOID)ID);
}
void Gamecall::_JiaJiNengDian(DWORD ID) //加技能点
{
    __try
    {
        _asm
        {


            push 0;
            mov eax, ID;
            push eax;
            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax+add_strike_offset1];  //加技能点一级偏移
            mov eax, [eax+add_strike_offset2];  //加技能点二级偏移
            mov eax, [eax+add_strike_offset3]; //加技能点三级偏移
            push eax;
            mov ebx, add_strike_call;
            call ebx;
        }
    }
    __except(1)
    {
        TRACE(_T("加技能点错误"));
    }

}

//天赋面板是否显示
BOOL Gamecall::isTalentPanelShow()
{

    DWORD dwUIAddr = 0;
    GetUIAddrByName(L"SkillTrainPanel", &dwUIAddr);

    DWORD canshu2 = 0;
    canshu2 =  ReadDWORD(dwUIAddr + skillpanel_isshow);

    if(canshu2 == 1)
        return TRUE;
    if(canshu2 == 2)
        TRACE(_T("技能面板没有打开"));

    return FALSE;
}

//经典模式CALL
void Gamecall::JingDianMoShi(DWORD adress, DWORD c5)
{
    KONGJ kj;
    kj.canshu1 = JINGDIANMOSHICALL_JIEGOUTOU;
    kj.canshu2 = 0x0;
    kj.canshu3 = 0x544D0EA8;
    kj.canshu4 = 0x0;
    kj.canshu5 = c5;      //控件的首地址+0x36FB0
    kj.canshu6 = 0x1;
    kj.canshu7 = 0x2;
    kj.canshu8 = 0x0;
    kj.canshu9 = 0x0;
    kj.canshu10 = 0x0;
    kj.canshu11 = 0x0;
    kj.canshu12 = 0x4EFE0016;

    __try
    {
        __asm
        {
            mov ebx, adress;  //这个是控件的首地址  "OptionPanel"
            mov ebx, [ebx + mouse_mode_class_offset1 + mouse_mode_class_offset11];
            mov eax, 0x1;
            mov dword ptr ds : [ebx + mouse_mode_class_offset2], eax;

            mov ecx, adress; //这个是控件的首地址  "OptionPanel"
            mov edx, [ecx];
            mov eax, [edx + 0x4];

            lea ebx, kj;
            push ebx;

            call eax
        }
    }

    __except(1)
    {
        TRACE(FUNCNAME);
    }
}


//技能攻击
//参数1: 技能名字
void Gamecall::Attack(const wchar_t* name)
{
    _ASSERTE(FALSE);
}

void Gamecall::Attack(int id)
{
    int cs = 0;
    int flag = 0;
    while(flag == 0)
    {
        if(cs > 10)
        {
            break;
        }
        flag = sendcall(id_msg_attack, (LPVOID)id);
        if(flag)
        {
            //TRACE(_T("技能ID:%d,技能执行返回%d"), id, flag);
            break;
        }
        //TRACE(_T("技能ID:%d,技能执行返回%d"), id, flag);
        cs++;
        Sleep(100);
    }
}


//走向某个对象
BOOL Gamecall::Step(ObjectNode* pNode)
{
    _ASSERTE(pNode != NULL);
    fPosition fpos;
    if(GetObjectPos(pNode, &fpos))
    {
        Step(fpos.x, fpos.y, fpos.z);
        return TRUE;
    }
    else
    {
        TRACE(_T("Gamecall::Step(ObjectNode* pNode)--error"));
    }

    return FALSE;
}


//获取地图id
DWORD Gamecall::GetCityID()
{
    DWORD PlayerInfo = GetPlayerDataAddr();
    DWORD cityid = UINT_MAX;

    __try
    {
        __asm
        {
            mov eax, PlayerInfo;
            mov eax, [eax + player_mapid];
            mov cityid, eax;
        }
    }
    __except(1)
    {
        TRACE(FUNCNAME);
    }

    return cityid;
}

//一层封装, 加入等待, 读条后才返回
BOOL Gamecall::PickupTask(ObjectNode* pNode)
{
    _ASSERTE(pNode != NULL);
    sendcall(id_msg_PickupTask, pNode);

    Sleep(1000);
    //判断读条
    //两个出口, 一个超时, 一个读条完成
    if(isPlayerChanneling() == FALSE)
        return FALSE;


    for(;;)
    {
        if(isPlayerChanneling() == FALSE)
            break;
        Sleep(10);
    }


    if(isPlayerHasPickupQuestItemUI())
    {
        sendcall(id_msg_Pickup2, pNode);
        return TRUE;
    }


    return FALSE;

}


//是否能看到
BOOL Gamecall::isCanLook(DWORD pAddr)
{
    //BYTE temp;
    wchar_t* name = (wchar_t*)ReadDWORD(ReadDWORD(pAddr + obj_type4_name_offset1) + 0x10);

    __try
    {
        if(wcsstr(name, L"Dummy") != NULL)
        {
            return FALSE;
        }
    }
    __except(1)
    {

    }
    return TRUE;
}

BOOL Gamecall::isPlayerDaodi()
{
    DWORD m_Adress = GetPlayerDataAddr();
    DWORD Adress = 0;
    bool State = FALSE;
    __try
    {
        if(m_Adress)
            Adress = ReadDWORD(ReadDWORD(m_Adress + 0x14) + 0x180);
        if(Adress == 0x400 || Adress == 4 || Adress == 0x22 || Adress == 0x1 || Adress == 0xD)
            State = TRUE;
        else
            State = FALSE;
        /*
        $1:Result.nUnusual:='眩晕';
        $4:Result.nUnusual:='倒地';
        $6:Result.nUnusual:='频死';
        $B:Result.nUnusual:='眩晕';
        $D:Result.nUnusual:='倒地';
        $21:Result.nUnusual:='疗伤';
        $22:Result.nUnusual:='格挡';
        $400:Result.nUnusual:='倒地';
        */
    }
    __except(1)
    {
        TRACE(_T("获取角色倒地状态错误"));
    }

    return State;
}

void Gamecall::_NewSpend(float x)
{
    //DWORD dwThreadId;
    GameSpend* pSpender = GameSpend::GetInstance();

    if(pSpender->m_pfnInitSpeed != NULL)
    {
        pSpender->m_pfnInitSpeed(x);
    }
}

wchar_t* Gamecall::GetExperienceName(DWORD ID)
{
    wchar_t* name = NULL;
    DWORD rs;
    __try
    {
        __asm
        {
            mov eax, obj_name_call_base;
            mov eax, [eax];
            mov ecx, [eax+obj_name_call_offset1]
            mov edx, [ecx]
            mov edx, [edx+obj_name_call_offset2]
            push 0;
            mov ebx, ID;
            push ebx;
            call edx;
            mov rs, eax;
        }
        if(rs>0)
        {
            rs = ReadDWORD(rs + 0x18);
            if(rs > 0)
            {
                name = ReadStr(rs);
            }
        }
    }
    __except(1)
    {
        TRACE(_T("获取经验名字错误"));
    }


    return name;
}


DWORD Gamecall::GetExperienceNameID(DWORD ID)
{
    DWORD ID1 = 0;
    DWORD rs = 0;
    __try
    {
        __asm
        {
            mov eax, obj_name_call_base;
            mov eax, [eax];
            mov ecx, [eax+Experience_status_offset2] //经验效果的二级偏移
            mov edx, [ecx]
            mov edx, [edx+obj_name_call_offset2]
            push 0;
            mov ebx, ID;
            push ebx;
            call edx;
            mov rs, eax;
        }
        if(rs > 0)
        {
            ID1 = ReadDWORD(rs + 0x14);
        }
    }
    __except(1)
    {
        TRACE(_T("获取经验名字ID错误"));
        return NULL;
    }
    return ID1;
}

DWORD Gamecall::GetExperienceNameID_SY(int i, DWORD m_adress)
{
    DWORD Adress = 0;
    __try
    {
        if(m_adress != 0)
        {
            Adress = ReadDWORD(m_adress + i * Experience_status_offset3 + Experience_status_offset4) ;   //C0是三级偏移   1C是四级偏移
        }
    }
    __except(1)
    {
        TRACE(_T("获取名字ID结构的索引错误"));
        return -1;
    }
    return Adress;
}

BOOL Gamecall::GetPlayExperienceStatusName(DWORD m_adressA, wchar_t* ExperienceName)
{
    wchar_t* name = {0};
    DWORD pos = 0;
    DWORD pos1 = 0;
    DWORD SY = 0;
    DWORD ID = 0;
    pos = ReadDWORD(m_adressA + Experience_status_offset1 + 0x4);

// TRACE1("pos===%d",pos);

    pos1 = ReadDWORD(m_adressA + Experience_status_offset1); //经验效果的一级偏移

// TRACE1("pos1===%d",pos1);

    if(pos > 0)
    {
        for(int i = 0; i < 10; i++)
        {
            SY = GetExperienceNameID_SY(i, pos1);  //获取名字ID结构的索引
            if(SY == 0)
            {
                return false;
            }
            ID = GetExperienceNameID(SY); //获取经验名字ID
            if(ID != 0)
            {
                name =  GetExperienceName(ID); //获取经验名字
                if(wcscmp(name, ExperienceName) == 0)
                {
//                  TRACE(_T("返回true"));
                    return true;
                }
            }
        }
    }
//  TRACE(_T("返回FALSE"));
    return FALSE;
}


BOOL Gamecall::GetPlayExperienceStatus()
{
    //KONGJIAN_JIEGOU JIEGOU = {NULL};
    //DWORD *pUiAddr = 0;
    //wchar_t *str = L"";  //ItemGrowth2Panel
    //GetUIAddrByName(L"", pUiAddr);
    //if(*pUiAddr == 0)
    //  return FALSE;
    KONGJIAN_JIEGOU jiegou;
    ZeroMemory(&jiegou, sizeof(KONGJIAN_JIEGOU));
    jiegou.adress = (DWORD)GetUIBinTreeBaseAddr();
    jiegou.name = L"00008130.UI.Normal_10";
    jiegou.ID = 0;
    GetUiAddrByName(jiegou);

    //TRACE1("ui:%x",jiegou.adress);

    wchar_t* ExperienceName = L"???";  //这个名字就是经验药品在左边的名字

    KONGJIAN_JIEGOU jiegou2;
    ZeroMemory(&jiegou2, sizeof(KONGJIAN_JIEGOU));
    jiegou2.adress = jiegou.ID;
    jiegou2.name = ExperienceName;
    BOOL pos = FALSE;
    pos = (BOOL)sendcall(id_msg_GetPlayExperienceStatusName, &jiegou2);
    //pos =  GetPlayExperienceStatusName(jiegou.adress,str1);  //获取经验名字  参数1是UI地址  参数2 是药品的名字
    if(pos == TRUE)
    {
        TRACE(_T("经验药已经吃了"));
        return TRUE;
    }
    else
    {
        TRACE(_T("没有吃经验药"));
        return FALSE;
    }

    /* DWORD pos = -1;
     pos = ReadDWORD(ReadDWORD(jiegou.ID + 0x83F8) + 0x1C);
     TRACE1("经验效果的ID %X", pos);
     if(pos != 0)
     {
         TRACE(_T("经验药物已经吃了,不需要再吃了"));
         return TRUE;
     }
     if(pos == 0)
         TRACE(_T("没有吃经验药物,请吃经验药物"));
     return FALSE;*/
}

void Gamecall::GetUiAddrByName(KONGJIAN_JIEGOU& jiegou)
{
    TRACE(_T("add:%x,name:%s,fanhui:%x"), jiegou.adress, jiegou.name, jiegou.ID);
    sendcall(id_msg__GetUiAddrByName, &jiegou);
}

void Gamecall::_GetUiAddrByName(Tree* Addr, wchar_t* name, DWORD& reAddr)
{
    if(Addr->p2 == 1)
    {
        //TRACE(_T("推出了"));
        return ;
    }
    if(reAddr > 0)   //
    {
        //TRACE(_T("返回了"));
        return;
    }
    wchar_t* uiname  = {0};

    if(!IsBadReadPtr((void*)GetUiNewName(Addr->Adress), sizeof(DWORD)))
    {
        uiname = GetUiNewName(Addr->Adress);//获取技能面板名字
        if(wcsstr(uiname, name) != NULL)
        {
            //TRACE(_T("找到需要的控件了"));
            TRACE(_T("找到UI名:%s,找到控件地址:%d"), uiname, Addr->Adress);
            reAddr = Addr->Adress;
            return ;
        }
    }
    _GetUiAddrByName(Addr->Right, name, reAddr);
    _GetUiAddrByName(Addr->Left, name, reAddr);
}

wchar_t* Gamecall::GetUiNewName(DWORD pBarAddr)
{
    wchar_t* name = {0};
    __try
    {
        name = (wchar_t*)ReadDWORD(pBarAddr + 0x94);
    }
    __except(1)
    {
        TRACE(L"获取技能面板名字错误");
    }
    return name;

}

void Gamecall::_LinQuJiangLi()
{
    DWORD uiAddr = 0;

    GetUIAddrByName(L"SurveyRewardPanel", &uiAddr);
    if(uiAddr == 0)
        return;

    __try
    {
        __asm
        {

            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax + get_jiangli_offset1];
            mov eax, [eax + get_jiangli_offset2];
            mov ecx, [eax + get_jiangli_offset3];
            mov edi, uiAddr;
            mov edx, [edi + get_jiangli_offset4];
            push edx;
            mov eax, get_jiangli_call;
            call eax;
        }
    }
    __except(1)
    {
        TRACE(FUNCNAME);
    }
}

void Gamecall::_NPCJieRenWu(DWORD canshu1, DWORD canshu2, DWORD canshu3, DWORD canshu4, DWORD canshu5)
{
    __try
    {
        __asm
        {
            mov ebx, canshu5;
            push ebx;
            mov ebx, canshu4;
            push ebx;
            mov ebx, canshu3;
            push ebx;
            mov ebx, canshu2;
            push ebx;
            mov ebx, canshu1;
            push ebx;

            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax + npc_quest_offset1];
            mov eax, [eax + npc_quest_offset2];
            mov ecx, [eax + npc_quest_offset3];
            mov edx, [eax + npc_quest_offset4];
            push edx;
            mov eax, [eax + npc_quest_offset5];
            push eax;

            mov ebx, npc_quest_call;
            call ebx;
        }
    }
    __except(1)
    {
        TRACE(FUNCNAME);
    }
}

void Gamecall::ChangeZ_Status(BOOL flag)
{
    HMODULE hBsengine = ::GetModuleHandle(_T("bsengine_Shipping"));
    unsigned addr = (unsigned)hBsengine;
    unsigned addr1 = (unsigned)hBsengine;
    unsigned addr2 = (unsigned)hBsengine;
    addr = addr + 0x592D8A;
    addr1 = addr1 + 0xA412B3;//0x0A410FC--
    //addr2 = addr2 + 0xA412B3;
    //A410BB
    //A410D3
    //A410C3
    DWORD pi = 0;
    DWORD pi1 = 0;
    //DWORD pi2 = 0;

    //VirtualProtect((void*)addr,4,PAGE_EXECUTE_READWRITE ,&pi);
    //*(WORD*)(addr) = 0x0EEB;
    //VirtualProtect((void*)addr,4,pi ,&pi);
    if(flag)
    {
        if(ReadByte(addr) == 0xF3)
        {
            VirtualProtect((void*)addr, 4, PAGE_EXECUTE_READWRITE , &pi);
            *(WORD*)(addr) = 0x0EEB;//0x05EB
            VirtualProtect((void*)addr, 4, pi , &pi);
        }
        if(ReadByte(addr1) == 0xD9)
        {
            VirtualProtect((void*)addr1, 4, PAGE_EXECUTE_READWRITE , &pi1);
            *(WORD*)(addr1) = 0x01EB;
            VirtualProtect((void*)addr1, 4, pi1 , &pi1);
        }
        /*if(ReadByte(addr2) == 0xD9)
        {
            VirtualProtect((void*)addr2, 4, PAGE_EXECUTE_READWRITE , &pi2);
            *(WORD*)(addr2) = 0x01EB;
            VirtualProtect((void*)addr2, 4, pi2 , &pi2);
        }*/
    }
    else
    {
        if(ReadByte(addr1) == 0xEB)
        {
            VirtualProtect((void*)addr1, 4, PAGE_EXECUTE_READWRITE , &pi1);
            *(WORD*)(addr1) = 0x5ED9;
            VirtualProtect((void*)addr1, 4, pi1 , &pi1);
        }
        if(ReadByte(addr) == 0xEB)
        {
            VirtualProtect((void*)addr, 4, PAGE_EXECUTE_READWRITE , &pi);
            *(WORD*)(addr) = 0x0FF3;
            VirtualProtect((void*)addr, 4, pi , &pi);
        }

        /*if(ReadByte(addr2) == 0xEB)
        {
            VirtualProtect((void*)addr1, 4, PAGE_EXECUTE_READWRITE , &pi2);
            *(WORD*)(addr2) = 0x5ED9;
            VirtualProtect((void*)addr2, 4, pi2 , &pi2);
        }*/
    }

}

void Gamecall::ChangeHeight(float how)
{
    HMODULE hBsengine = ::GetModuleHandle(_T("bsengine_Shipping"));
    unsigned addr = (unsigned)hBsengine;
    addr = addr + SHENXINGBAIBIANCHAZHI;

    //TRACE1("addr:%x",addr);
    //int gg = 43480000;
    __try
    {
        __asm
        {
            mov eax, addr;
            mov eax, [eax];
            mov eax, [eax + 0x3bc];
            mov eax, [eax];
            mov eax, [eax + 0x40];
            mov eax, [eax + 0x214];
            //add eax, 0x5C;
            mov ebx, how;
            mov dword ptr ds:[eax+0x5C], ebx;
        }
    }
    __except(1)
    {
        TRACE(_T("飞起错误"));
    }
}

int Gamecall::GetObjectSy_90(DWORD pObjAddress)
{
    if(pObjAddress < 0x3000000)
    {
        return 0;
    }
    DWORD result;
    result = 0;
    __try
    {
        result = ReadDWORD(ReadDWORD(pObjAddress + 0x3c) + 0x194);
    }
    __except(1)
    {
        TRACE(FUNCNAME);
    }
    return result;
}

DWORD Gamecall::GetPlayerQuestUIStatusts()
{
    DWORD pAddr = GetPlayerDataAddr();
    int value = 0;


    __try
    {
        value = ReadDWORD(ReadDWORD(pAddr + 0x14) + 0x218);
        /*__asm
        {
        mov eax, pAddr;
        mov eax, [eax + player_status_openblock];
        movzx eax, al;
        mov value, eax;
        }*/
    }
    __except(1)
    {
        TRACE(_T("%s"), FUNCNAME);
    }

    return value;
}

BOOL Gamecall::PickupTaskts(ObjectNode* pNode)
{
    TRACE(_T("执行ts"));
    sendcall(id_msg_PickupTask, pNode);

    DWORD uiaddr;
    uiaddr = 0;
    DWORD ui_status;
    ui_status = 0;

    for(int i = 0; i < 10; i++)
    {
        GetUIAddrByName(L"PickupItemPanel", &uiaddr);
        TRACE1("ui地址:%x", uiaddr);
        if(uiaddr != NULL)
            ui_status = ReadDWORD(uiaddr + 0x38);

        TRACE1("ui_status:%d", ui_status);
        if(ui_status == 1)
        {
            if(isPlayPickupUiStatus())
            {
                TRACE(_T("执行upckup2"));
                sendcall(id_msg_Pickup2ts, (LPVOID)0);
                return TRUE;
            }
        }
        Sleep(1000);
    }
    TRACE(_T("未找到UI,跳出"));

    return FALSE;
}

BOOL Gamecall::isPlayPickupUiStatus()
{
    DWORD pAddr = GetPlayerDataAddr();
    int value = 0;


    __try
    {
        value = ReadDWORD(ReadDWORD(pAddr + 0x704) + 0x8);
        if(value != NULL)
            return TRUE;

        /*__asm
        {
        mov eax, pAddr;
        mov eax, [eax + player_status_openblock];
        movzx eax, al;
        mov value, eax;
        }*/
    }
    __except(1)
    {
        TRACE(_T("%s"), FUNCNAME);
    }

    return FALSE;
}

void Gamecall::Pickup2ts()
{
    DWORD addr = GetPlayerDataAddr();
    __try
    {
        _asm
        {
            mov eax, addr;
            mov ecx, [eax+pickup2_offset3]; //二次捡物三级偏移
            push ecx;

            mov eax, Pickup2_call_ts;
            call eax;
        }
    }
    __except(1)
    {
        TRACE(_T("特殊二次捡物出错"));
    }

}


void Gamecall::CloseXiaoDongHua()
{
    DWORD dtzt;
    dtzt = (DWORD)ReadByte(ReadDWORD(ReadDWORD(ReadDWORD(move_status_base) + move_status_offset1) + move_status_offset2) + move_status_offset3 + move_status_offset31); //是否有小动画 0是有 1是没有
    //TRACE("小动画状态:%d",dtzt);
    if(dtzt == 1)
    {
        //TRACE(_T("动画状态中"));
        //KeyPress(VK_ESCAPE);
        Sleep(500);
        KeyPress(27);
        Sleep(500);
    }

}

DWORD Gamecall::GetKaiShiAdress()  //获取开始地址
{
    DWORD Adress;
    Adress = 0;
    __try
    {
        Adress = ReadDWORD(ReadDWORD(ReadDWORD(obj_name_call_base) + Wuqi_po10_offset1) + Wuqi_po10_offset2);
    }
    __except(1)
    {
        TRACE(_T("获取开始地址错误"));
    }
    return Adress;
}

DWORD Gamecall::GetBiJiaoShu(int i, DWORD m_adress) //获取比较数值
{

    DWORD Adress = 0;
    __try
    {
        if(m_adress != 0)
            Adress = (DWORD)ReadByte(ReadDWORD(m_adress + i * 4) + 0x30);
    }
    __except(1)
    {
        TRACE(_T("获取比较数值错误"));
    }
    return Adress;
}

DWORD Gamecall::_IsCanShu(DWORD adress, DWORD adress1) //是否是这个参数
{
    BYTE is = 0;
    if(adress == 0 || adress1 == 0)
        return -1;
    __try
    {
        _asm
        {
            mov ecx, adress;
            push ecx;
            mov eax, adress1;
            movzx eax, byte ptr ds:[eax+Iscs_po10_cmp_offset1];
            push eax;
            mov eax, adress1;
            mov eax, dword ptr ds:[eax+Iscs_po10_cmp_offset2];
            push eax;
            mov eax, Iscs_po10_cmp_Call;
            call eax;
            add esp, 0xC;
            mov is, al;
        }
    }
    __except(1)
    {
        TRACE(_T("是否是这个参数出错"));
        return -1;
    }
    return (DWORD)is;
}

DWORD Gamecall::IsCanShu(DWORD adress, DWORD adress1) //是否是这个参数
{
    PARAM_2 temp;
    temp.argv1 = adress;
    temp.argv2 = adress1;
    return (DWORD)sendcall(id_msg_IsCanShu, &temp);
}


DWORD Gamecall::GetBiJiaoShu1(int i, DWORD m_adress) //获取比较数值1
{

    DWORD Adress = 0;
    __try
    {
        if(m_adress != 0)
            Adress = (DWORD)ReadByte(ReadDWORD(m_adress + i * 4) + 0x8);
    }
    __except(1)
    {
        TRACE(_T("获取比较数值1错误"));
        return -1;
    }
    return Adress;
}

DWORD Gamecall::GetBiJiaoShu2(int i, DWORD m_adress) //获取比较数值2
{

    DWORD Adress = 0;
    __try
    {
        if(m_adress != 0)
            Adress = (DWORD)ReadByte(ReadDWORD(m_adress + i * 4) + Wuqi_po10_cmp2_offset);
    }
    __except(1)
    {
        TRACE(_T("获取比较数值2错误"));
        return -1;
    }
    return Adress;
}


DWORD Gamecall::GetBiJiaoShu3(DWORD m_adress)  //获取比较数值3 这里用到的2个地址都是随便弄的,还没有固定的特征码。
{

    DWORD Adress = 0;
    __try
    {
        if(m_adress != 0)
            Adress = ReadDWORD(ReadDWORD(m_adress + obj_type4_id2_offset) + obj_type4_view_offset1);
    }
    __except(1)
    {
        TRACE(_T("获取比较数值3错误"));
    }
    return Adress;
}

DWORD Gamecall::GetBiJiaoShu4(int i, DWORD m_adress) //获取比较数值4
{

    DWORD Adress = 0;
    __try
    {
        if(m_adress != 0)
            Adress = ReadDWORD(ReadDWORD(m_adress + i * 4) + Wuqi_po10_cmp4_offset);
    }
    __except(1)
    {
        TRACE(_T("获取比较数值4错误"));
        return -1;
    }
    return Adress;
}

//卸装备
//参数是身上的格子数
//TODO:
void Gamecall::_XieZhuangBei(DWORD pos)
{
    __try
    {
        __asm
        {
            mov eax, pos;
            push eax;
            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax+xiezhuangbei_offset1];
            mov eax, [eax+xiezhuangbei_offset2];
            mov eax, [eax+xiezhuangbei_offset3];
            push eax;
            mov eax, xiezhuangbei_call;
            call eax;
        }
    }
    __except(1)
    {
        TRACE(_T("卸装备出错"));
    }
}

BOOL Gamecall::GetPlayerFightingStatus()
{
    DWORD pAddr = GetPlayerDataAddr();
    int value = 0;


    __try
    {
        value = ReadDWORD(pAddr + Play_fighting_status_offset3);
        //TRACE1("战斗状态:%d",value);
    }
    __except(1)
    {
        TRACE(_T("获得战斗状态出错"));
    }

    return (value == 1);
}


DWORD Gamecall::DuiWu_EndAdress() //遍历队伍的结束地址
{
    DWORD Adress;
    __try
    {
        _asm
        {
            mov eax, obj_enum_base;
            mov eax, [eax+0];
            mov eax, [eax+enum_party_startaddr_offset1];
            mov eax, [eax+enum_party_startaddr_offset2];
            mov eax, [eax+enum_party_startaddr_offset3];
            mov eax, [eax+enum_party_startaddr_offset5 + 4];  //遍历队伍的结束地址四级偏移
            mov Adress, eax;
        }
    }
    __except(1)
    {
        TRACE(_T("遍历队伍的结束地址出错"));
        return 0;
    }
    return Adress;
}

void Gamecall::TuiChuDuiWu() //退出队伍
{
    __try
    {
        __asm
        {
            mov eax, leave_party_call;
            call eax;
        }
    }
    __except(1)
    {
        TRACE(_T("退出队伍出错"));
    }
}

void Gamecall::YaoQingZuDui(DWORD ID, DWORD Info) //邀请组队 参数1是对象ID  参数2 就是10000数值
{
    __try
    {
        __asm
        {
            push 0;
            push 0;
            mov eax, Info;
            push eax;
            mov eax, ID;
            push eax;
            mov eax, obj_enum_base;
            mov eax, [eax];
            mov eax, [eax+invite_party_call_offset1];   // 邀请组队一级偏移
            mov eax, [eax+invite_party_call_offset2];   // 邀请组队二级偏移
            mov eax, [eax+invite_party_call_offset3];  // 邀请组队三级偏移
            push eax;
            mov eax, invite_party_call;
            call eax;

        }
    }
    __except(1)
    {
        TRACE(_T("邀请组队出错"));
    }
}

int Gamecall::GetObjectView(DWORD pObjAddress)
{
    if(pObjAddress < 0x3000000)
    {
        return 0;
    }
    WORD jd = 0;
    __try
    {
        _asm
        {
            mov eax, pObjAddress;
            mov eax, [eax+0x9a];
            mov jd, ax
        }
    }
    __except(1)
    {
        TRACE(_T("对象的角度出错"));
        return 0;
    }


    return (DWORD)jd;
}

BOOL Gamecall::GetPlayerSkillStatus()
{
    DWORD pAddr = GetPlayerDataAddr();
    WORD value = 0;


    __try
    {
        value = ReadWORD(ReadDWORD(pAddr + 0x14) + 0x80);
    }
    __except(1)
    {
        TRACE(_T("获得释放技能状态出错"));
    }

    return (value != 0xFFFF);
}

BOOL Gamecall::GetPlayerBusy()
{
    DWORD pAddr = GetPlayerDataAddr();
    DWORD value_1 = 0;
    DWORD value_2 = 0;


    __try
    {
        value_1 = ReadDWORD(ReadDWORD(pAddr + 0x14) + 0x28);
        value_2 = ReadDWORD(pAddr + 0xF8);
        if(value_1 > 0 || value_2 == 5)
        {
            return TRUE;
        }
    }
    __except(1)
    {
        TRACE(_T("获得忙碌状态出错"));
    }

    return FALSE;
}

DWORD Gamecall::DuiWu_StartAdress()
{
    DWORD Adress;
    __try
    {
        _asm
        {
            mov eax, obj_enum_base;
            mov eax, [eax+0];
            mov eax, [eax+enum_party_startaddr_offset1];
            mov eax, [eax+enum_party_startaddr_offset2];
            mov eax, [eax+enum_party_startaddr_offset3];
            mov eax, [eax+enum_party_startaddr_offset4];  //遍历队伍的结束地址四级偏移
            mov Adress, eax;
        }
    }
    __except(1)
    {
        TRACE(_T("遍历队伍的结束地址出错"));
        return 0;
    }
    return Adress;
}

BOOL Gamecall::GetPartyInfo(TeamVector& TeamInfo)
{
    DWORD StartAdress  = DuiWu_StartAdress(); //遍历队伍的开始地址
    DWORD EndAdress  = DuiWu_EndAdress(); //遍历队伍的结束地址
    DWORD count;
    DWORD C_Address;
    fPosition fmypos;
    Team team;
    //ZeroMemory(&team, sizeof(Team));
    //ZeroMemory(&fmypos, sizeof(fPosition));
    C_Address = 0;

    count = (EndAdress - StartAdress) / 4;
    if(count > 0 && count <= 6)
    {
        GetPlayerPos(&fmypos);
        for(int i = 0; i < count; i++)
        {
            C_Address = GetPartyByAddress(StartAdress, i);
            team.PAddress = C_Address;
            team.name = GetPartyName(C_Address);
            team.Channel = GetPartyChannel(C_Address);
            team.CurrLife = GetPartyCurrlife(C_Address);
            team.MaxLife = GetPartyMaxlife(C_Address);
            team.ID = GetPartyId(C_Address);
            team.ID2 = GetPartyId2(C_Address);
            team.Pos = GetPartyPos(C_Address);
            team.Angle = GetPartyAngle(C_Address);
            team.Range = CalcC(team.Pos, fmypos);
            team.LV = GetPartyLv(C_Address);
            TeamInfo.push_back(team);
            //TRACE(_T("地址:%x,人名:%s,频道:%d,当前生命:%d,最大生命:%d,ID:%x,ID2%x,面向%d,距离:%d,坐标:%d,%d,%d"),team.PAddress,team.name,team.Channel,team.CurrLife,team.MaxLife,team.ID,team.ID2,team.Angle,team.Range,team.Pos.x,team.Pos.y,team.Pos.z);
        }
        return TRUE;
    }
    return FALSE;
}

wchar_t* Gamecall::GetPartyName(DWORD PartyAddress)
{
    wchar_t* name;
    name = NULL;
    __try
    {
        if(ReadDWORD(PartyAddress + 0x7c + 0x14) >= 0xF)
        {
            name = ReadStr(ReadDWORD(PartyAddress + 0x7C));
        }
        else
        {
            name = ReadStr(PartyAddress + 0x7C);
        }
    }
    __except(1)
    {
        TRACE(_T("获取角色名字出错"));
    }
    return name;
}

DWORD Gamecall::GetPartyChannel(DWORD PartyAddress)
{
    DWORD line;
    line = NULL;
    __try
    {
        line = ReadDWORD(PartyAddress + 0x44);
    }
    __except(1)
    {
        TRACE(_T("获取角色线路出错"));
        line = 0;
    }
    return line;
}

DWORD Gamecall::GetPartyCurrlife(DWORD PartyAddress)
{
    DWORD Currlife;
    Currlife = NULL;
    __try
    {
        Currlife = ReadDWORD(PartyAddress + 0x14);
    }
    __except(1)
    {
        TRACE(_T("获取角色当前血值出错"));
    }
    return Currlife;
}

DWORD Gamecall::GetPartyMaxlife(DWORD PartyAddress)
{
    DWORD Maxlife;
    Maxlife = NULL;
    __try
    {
        Maxlife = ReadDWORD(PartyAddress + 0x28);
        Maxlife = Maxlife + ReadDWORD(PartyAddress + 0x2C);
    }
    __except(1)
    {
        TRACE(_T("获取角色最大血值出错"));
    }
    return Maxlife;
}

DWORD Gamecall::GetPartyId(DWORD PartyAddress)
{
    DWORD id;
    id = NULL;
    __try
    {
        id = ReadDWORD(PartyAddress + 0x8);
    }
    __except(1)
    {
        TRACE(_T("获取角色ID出错"));
    }
    return id;
}

DWORD Gamecall::GetPartyId2(DWORD PartyAddress)
{
    DWORD id2;
    id2 = NULL;
    __try
    {
        id2 = ReadDWORD(PartyAddress + 0xC);
    }
    __except(1)
    {
        TRACE(_T("获取角色ID2出错"));
    }
    return id2;
}

fPosition Gamecall::GetPartyPos(DWORD PartyAddress)
{
    fPosition pos;
    ZeroMemory(&pos, sizeof(fPosition));
    __try
    {
        pos.x = (ReadWORD(PartyAddress + 0x1C) - 0x10000) * 4;
        pos.y = (ReadWORD(PartyAddress + 0x1E) - 0x10000) * 4;
        pos.z = (ReadWORD(PartyAddress + 0x20) - 0x10000) * 4;



        if(abs(pos.x) > 0x1FFFF)
        {
            pos.x = ReadWORD(PartyAddress + 0x1C) * 4;

        }
        if(abs(pos.y) > 0x1FFFF)
        {
            pos.y = ReadWORD(PartyAddress + 0x1E) * 4;

        }
        if(abs(pos.z) > 0x1FFFF)
        {
            pos.z = ReadWORD(PartyAddress + 0x20) * 4;
        }

        if(abs(pos.x) > 0x1FFFF)
        {
            pos.x = (0x1FFFF - ReadWORD(PartyAddress + 0x1C)) * 4 * -1;
        }
        if(abs(pos.y) > 0x1FFFF)
        {
            pos.y = (0x1FFFF - ReadWORD(PartyAddress + 0x1E)) * 4 * -1;
        }
        if(abs(pos.z) > 0x1FFFF)
        {
            pos.z = (0x1FFFF - ReadWORD(PartyAddress + 0x20)) * 4 * -1;
        }
    }
    __except(1)
    {
        TRACE(_T("获取角色坐标出错"));
    }
    return pos;
}

DWORD Gamecall::GetPartyAngle(DWORD PartyAddress)
{
    DWORD Angle;
    Angle = NULL;
    __try
    {
        Angle = ReadWORD(PartyAddress + 0x32);
    }
    __except(1)
    {
        TRACE(_T("获取面向出错"));
    }
    return Angle;
}

DWORD Gamecall::GetPartyLv(DWORD PartyAddress)
{
    DWORD Lv;
    Lv = NULL;
    __try
    {
        Lv = (DWORD)ReadByte(PartyAddress + 0x1A);
    }
    __except(1)
    {
        TRACE(_T("获取队伍等级出错"));
    }
    return Lv;
}

DWORD Gamecall::GetPartyByAddress(DWORD PartyAddress, int i)
{
    DWORD NewAddress;
    NewAddress = NULL;
    __try
    {
        NewAddress = ReadDWORD(PartyAddress + i * 0x4);
    }
    __except(1)
    {
        TRACE(_T("获取当前角色地址出错"));
    }
    return NewAddress;
}

int Gamecall::GetObjectTargetId(DWORD pObjAddress)
{
    if(pObjAddress < 0x3000000)
    {
        return 0;
    }
    DWORD TargetId;
    TargetId = NULL;
    __try
    {
        TargetId = ReadDWORD(pObjAddress + 0x108);
    }
    __except(1)
    {
        TRACE(_T("获取TargetId出错"));
    }
    return TargetId;
}


ObjectNode* Gamecall::GetObjectById(DWORD Id)
{
    ObjectVector ov;
    GetAllObjectToVector(GetObjectBinTreeBaseAddr(), ov);

    for(int i = 0 ; i < ov.size(); i++)
    {
        if(ov->id == Id)
        {
            return ov;
        }
    }
    return NULL;
}

BOOL Gamecall::IsObjectFightStatus(DWORD pObjAddress)
{
    if(pObjAddress < 0x3000000)
    {
        return 0;
    }
    BOOL value = FALSE;
    __try
    {
        value = ReadByte(pObjAddress + Play_fighting_status_offset3);
        //TRACE1("战斗状态:%d",value);
    }
    __except(1)
    {
        TRACE(_T("获得战斗状态出错"));
    }
    return value;
}

BOOL Gamecall::IsPlayerSkillStatus(DWORD pObjAddress)
{
    if(pObjAddress < 0x3000000)
    {
        return 0;
    }
    WORD value = 0;
    __try
    {
        value = ReadWORD(ReadDWORD(pObjAddress + 0x14) + 0x80);
    }
    __except(1)
    {
        TRACE(_T("获得释放技能状态出错"));
    }
    return (value != 0xFFFF);
}

DWORD Gamecall::GetPlarerRedHeart()
{
    DWORD pAddr = GetPlayerDataAddr();
    BYTE Rh = 0;
    __try
    {
        Rh = ReadByte(pAddr + 0x1AA);
    }
    __except(1)
    {
        TRACE(_T("获得角色红心出错"));
    }
    return Rh;
}

BOOL Gamecall::IsObjectControl(DWORD pObjAddress)
{
    if(pObjAddress < 0x3000000)
    {
        return 0;
    }
    BOOL value = FALSE;
    __try
    {
        value = ReadDWORD(ReadDWORD(pObjAddress + 708) + 0x5C);
        if(value == 2)
        {
            return TRUE;
        }
    }
    __except(1)
    {
        TRACE(_T("获得控制状态出错"));
    }
    return FALSE;
}

BOOL Gamecall::isStrikeCd(DWORD id)
{
    StrikeVector JnVec;
    GetStrikeToVector(JnVec);

    for(StrikeVector::iterator it = JnVec.begin(); it != JnVec.end(); it++)
    {
        if((*it).id == id)
        {
            if((*it).bAviable)
            {
                return (*it).bCD;
            }
        }
    }
    return FALSE;
}

void Gamecall::Pickup()
{
    PARAM_2 temp;
    temp.argv1 = 0x2;
    temp.argv2 = 0x13;
    sendcall(id_msg_Operation, &temp);
}

DWORD Gamecall::GetObjectCountByName(wchar_t* Name, fPosition& pos, DWORD Range)
{
    DWORD Rs_Count = 0;
    ObjectVector RangeObject;
    if(pos.x == 0)
    {
        if(Range == 0)
        {
            GetAllObjectToVector(GetObjectBinTreeBaseAddr(), RangeObject);
        }
        else
        {
            GetRangeObjectToVector(GetObjectBinTreeBaseAddr(), Range, RangeObject);
        }
    }
    else
    {
        //TRACE(_T("进来了GetRangeMonsterToVector"));
        //TRACE(_T("%d,%d,%d\n"),(int)pos.x,(int)pos.y,(int)pos.z);
        GetRangeMonsterToVector(GetObjectBinTreeBaseAddr(), Range, RangeObject, pos);
    }
    //TRACE(_T("进来了GetRangeMonsterToVector:%d"), RangeObject.size());
    //std::sort(RangeObject.begin(), RangeObject.end(), UDgreater);
    fPosition tarpos;
    for(DWORD i = 0; i < RangeObject.size(); i++)
    {
        //过滤掉没坐标的
        if(GetObjectPos(RangeObject, &tarpos) == FALSE)
            continue;


        //过滤掉坐标是0的
        if(tarpos.x == 0 || tarpos.y == 0 || tarpos.z == 0)
            continue;


        //过滤掉没名字的
        wchar_t* name = GetObjectName(RangeObject->ObjAddress);
        if(name == NULL) continue;

        if(wcscmp(name, Name) == 0)
        {
            Rs_Count++;
        }
   /*     else
        {
            TRACE(_T("其他怪物的名字:%s"), name);
        }*/
    }

    return Rs_Count;
}

BOOL Gamecall::isStrikeCan(wchar_t* Name)
{
        StrikeVector JnVec;
        GetStrikeToVector(JnVec);

        for(StrikeVector::iterator it = JnVec.begin(); it != JnVec.end(); it++)
        {
                if(wcscmp((*it).name,Name )== 0)
                {
                        return TRUE;
                }
        }
        return FALSE;
}


//邀请组队
void Gamecall::Party_Invite(DWORD sn, DWORD id)
{
        BYTE* pBuf = (BYTE *)AllocGameMemory(0x30);
        *(WORD*)pBuf = CONST_PARTYINVITE;
        *(DWORD*)(pBuf + 0x4) = PHEAD_PARTYINVITE;
        *(DWORD*)(pBuf + 0x10) = sn;
        *(DWORD*)(pBuf + 0x14) = id;

        *(pBuf + 0x25) = 4;
        *(pBuf + 0x26) = 0x1c;
        *(pBuf + 0x27) = 00;
        *(pBuf + 0x28) = 5;

        Packet_Send(pBuf);
}

//{明文发包}
void Gamecall::Packet_Send(BYTE *PBuffer, DWORD PType)
{

        EnterCriticalSection(&F_SendPacket_CS);

        if(PBuffer > 0)
        {
                __asm
                {
                        push PType;
                        mov  esi,PBuffer;
                        mov eax, FUNC_SENDPACKET;
                        call eax;
                        add  esp,4;
                }
        }

         LeaveCriticalSection(&F_SendPacket_CS);
}

//{根据名字取控件Id}
DWORD Gamecall::GetUIId(wchar_t *UIName)
{

        DWORD Result = 0;
        if(UIName == NULL) return 0;
        if(*UIName == L' ') return 0;

        __asm
        {

                call dword ptr ds:[CONST_GETUIID];
                mov  esi,eax;
                test esi,esi;
                Je   fun_exit;

                mov  edx,dword ptr ds:[esi];
                push UIName;
                mov  eax,dword ptr ds:[edx+ OFFSET_GETUIID];
                mov  ecx,esi;
                call eax;
                mov  Result,eax;
fun_exit:
        }

        return Result;
}

//{取控件指针}
bool Gamecall::GetUI(wchar_t *UIName, UI *ui, DWORD nType)
{
        bool bRet = false;


        PVOID PTMP;
        DWORD  UIId;
        DWORD PInfo;
        DWORD vCode;
        DWORD pName;

        ZeroMemory(ui,sizeof(UI));
        if (UIName == NULL) return false;
        if(*UIName == L' ') return false;

        //{取控件Id}
        UIId = GetUIId(UIName);
        if (UIId == 0) return false;

        PTMP = new char[0x10];
        __asm
        {
                mov  eax,Offset_Game_Base;
                mov  eax,dword ptr ds:[eax];
                mov  eax,dword ptr ds:[eax+ Offset_UI_Offset0];
                mov  ecx,dword ptr ds:[eax+ Offset_UI_Offset1+ Offset_UI_Offset2];
                lea  edi,dword ptr ds:[ecx+ Offset_UI_Offset3];
                lea  ecx,dword ptr ss:[UIId];
                mov  eax,PTMP;

                mov eax, FUNC_GETPUI;
                call eax;
        }

        switch(nType)
        {
        case 1:
                {
                        PInfo = *(DWORD *)(DWORD(*(DWORD *)(DWORD(PTMP)+ 4)) +  0x10);
                        break;
                }
        case 2:
                {
                        PInfo=*(DWORD *)(DWORD(PTMP)+ 0x4);
                        break;
                }          

        default:
                {
                        PInfo = *(DWORD *)(DWORD(*(DWORD *)(DWORD(PTMP)+ 4)) +  0x10);
                        break;
                }
        }

        if (PInfo>0)
        {

                vCode= ReadDWORD(PInfo+ Offset_UI_Code);

                if (vCode<3)
                {

                        //{信息指针}
                        ui->PInfo = PInfo;
                       
                        //{Id}
                        ui->Id=ReadDWORD(PInfo + 0x4);

                        //{控件名}
                        pName = ReadDWORD(PInfo + Offset_UI_PName);
                        ui->szName= (wchar_t *)ReadDWORD(pName);
                       
                        //{vCode}
                        ui->vCode=vCode;

                        //{是否可见}
                        ui->bVisable=vCode=1;
                }


                bRet = true;
        }

        delete PTMP;
        return bRet;
}



void Gamecall::GetInvite(TInvite *pstInvite)
{

        ZeroMemory(pstInvite,sizeof(TInvite));

        UI ui;
        //'窗口_接受组队
        if(!GetUI(L"InvitedPartyConfirmPanel", &ui)) return;


        if (ui.PInfo>0)
        {
                pstInvite->PInfo = ui.PInfo;
                pstInvite->PartySn = ReadDWORD(ui.PInfo+ Offset_UI_PartySn);
                pstInvite->PartyTId = ReadDWORD(ui.PInfo+ Offset_UI_PartyTId);
                pstInvite->CaptainSn = ReadDWORD(ui.PInfo+ Offset_UI_CaptainSn);
                pstInvite->CaptainTId = ReadDWORD(ui.PInfo+ Offset_UI_CaptainTId);
        }
}

剑灵辅助工作室版VS2012.rar (1.26 MB, 下载次数: 0, 售价: 1000 金钱)
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

快速回复 返回顶部 返回列表