Team BlueWater Game Online Tutorial's
Bine ati venit la Team-BlueWater!!Tutorial's 4 all Games!

3rd Wings ChaosMix Source

View previous topic View next topic Go down

3rd Wings ChaosMix Source

Post  m4s4cru on Tue Aug 02, 2011 11:34 am

ChaosMachine.cpp

Code:


#define WIN32_LEAN_AND_MEAN    //
//#define _WIN32_WINNT    0x0500  // 0x0410=Win98, 0x0500=Win2000/Me, 0x0501=WinXP, 0x0502=Win2003, 0x0600=Vista
//#define _WIN32_IE      0x0600
#include "../stdafx.h"
#include "../Offsets.h"
#include <stdio.h>
#include <Time.h>
#include "../Headers/GsFunc.h"
#include "../Headers/TypeDefs.h"
#include "../Headers/Extra.h"
#include "../Headers/ChaosMachine.h"
#include "../Headers/Season3.h"

void ChaosSendMixFail ( DWORD gObjID )
{
   ChaosBoxInit ( gObjBaseAddr + ( gObjSize * gObjID ) );
   ChaosBoxSend ( gObjBaseAddr + ( gObjSize * gObjID ) , 0 );

   char buff[11] = { 0xC1 , 0x0B , 0x86 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
   GsDataSendFuncEx(gObjID,(PBYTE)buff,buff[1]);
}

BYTE GetChaosItemLevel ( DWORD gObjId , WORD ItemID)
{
   DWORD * inv = (DWORD*) ( gObjBaseAddr  + ( gObjSize * gObjId) + gObj_CBOX );

   for ( BYTE i = 0 ; i < 32 ; i ++ )
   {
      WORD * pitemId = (WORD*) ( ( i * GS_ITEMSIZE ) + *inv + 6 );
      
      if ( *pitemId == ItemID )
      {
         WORD * pitembyte = (WORD*) ( ( i * GS_ITEMSIZE ) + *inv + 8 );
         return *pitembyte;
      }
   }
   return 0xFF;
}

int CheckChaosItem ( DWORD gObjId , WORD ItemID)
{
   DWORD * inv = (DWORD*) ( gObjBaseAddr  + ( gObjSize * gObjId) + gObj_CBOX );

   for ( BYTE i = 0 ; i < 32 ; i ++ )
   {
      WORD * pitemId = (WORD*) ( ( i * GS_ITEMSIZE ) + *inv + 6 );
      if ( *pitemId == ItemID )
      {
         return 1;
      }
   }
   return 0;
}

int CheckChaosItemRange ( DWORD gObjId , WORD ItemIDStart, WORD ItemIDEnd)
{
   DWORD * inv = (DWORD*) ( gObjBaseAddr  + ( gObjSize * gObjId) + gObj_CBOX );

   for ( BYTE i = 0 ; i < 32 ; i ++ )
   {
      WORD * pitemId = (WORD*) ( ( i * GS_ITEMSIZE ) + *inv + 6 );
      if ( (*pitemId >= ItemIDStart) && (*pitemId <= ItemIDEnd) )
      {
         return 1;
      }
   }
   return 0;
}

WORD GetChaosItemRange ( DWORD gObjId , WORD ItemIDStart, WORD ItemIDEnd)
{
   DWORD * inv = (DWORD*) ( gObjBaseAddr  + ( gObjSize * gObjId) + gObj_CBOX );

   for ( BYTE i = 0 ; i < 32 ; i ++ )
   {
      WORD * pitemId = (WORD*) ( ( i * GS_ITEMSIZE ) + *inv + 6 );
      if ( (*pitemId >= ItemIDStart) && (*pitemId <= ItemIDEnd) )
      {
         return *pitemId;
      }
   }
   return -1;
}

//Condor Feather Mix
      case 0x26:
      {
         //Checking Jewel Presence [All Conditions Must Be 1]
         int CheckChaosJewel = CheckChaosItem(gObjID, 0x180F);         //Chaos Jewel [12][15]
         int CreationJewel = CheckChaosItem(gObjID, 0x1C16);            //Creation Jewel [14][22]
         int CheckSoulPack = CheckChaosItem(gObjID, 0x181F);            //Soul Pack

         //Checking Wings Presence [Only ONE Condition Must Be 1]
         int CapeOfLord = CheckChaosItem(gObjID, 0x1A1E);            //Cape of Lord [13][30]
         int DespairWings = CheckChaosItem(gObjID, 0x182A);            //Wings of Despair [12][42]
         int WingsRange = CheckChaosItemRange(gObjID, 0x1803, 0x1806);   //2nd Level Wings Range [12][3,4,5,6]   
         int WingsSummoner = CheckChaosItem(gObjID,0x182A);            //2nd Level Summoner Wings

         //Checking Presence of Ancient Item
         int ItemRange = CheckChaosItemRange(gObjID, 0x0000, 0x17FF);   //Items Range [0][12]   

         //Making Sure that all item elements are present
         int CombinationCheckSum = CheckChaosJewel + CreationJewel + CheckSoulPack + CapeOfLord + DespairWings + WingsRange + WingsSummoner;

         if(CombinationCheckSum>=4)
         {
            srand(static_cast<int>(time(NULL)));
            int Success = (rand() % 100);

            //To Fix: % Calculation of Success

            if(Success <= 60)
            {
               SetZen(gObjID, GetZen(gObjID)-200000);   
               InvItemCreate ( gObjID , 0xFF , 0 , 0 , 0x1A35 , 0 , 0 ,0 , 0 , 0 , -1 , 0 , 0 );

               wsprintf(sBuf, "[Chaos Mix][%s] Condor Feather Mix Success at %d%",GetName(gObjID),Success);
               LogLine("%s\n", sBuf);
            }
            else
            {
               SetZen(gObjID, GetZen(gObjID)-200000);   
               ChaosSendMixFail(gObjID);

               wsprintf(sBuf, "[Chaos Mix][%s] Condor Feather Mix Fail at %d%",GetName(gObjID),Success);
               LogLine("%s\n", sBuf);
            }
         } else {
            Gs_GCServerMsgStringSend("[Anti-Hack] Condor Feather Mix Hack",gObjID, 0x01);

            wsprintf(sBuf, "[Anti-Hack][%s] Condor Feather Mix Hack Attempt",GetName(gObjID));
            AntiHackLog("%s\n", sBuf);

            SetZen(gObjID, GetZen(gObjID));
            ChaosSendMixFail(gObjID);
         }
      }break;
      //3rd Class Wings Mix
      case 0x27:
      {
         //Checking Jewel Presence [All Conditions Must Be 1]
         int CheckChaosJewel = CheckChaosItem(gObjID, 0x180F);         //Chaos Jewel [12][15]
         int CheckCreationJewel = CheckChaosItem(gObjID, 0x1C16);      //Creation Jewel [14][22]
         int CheckSoulPack = CheckChaosItem(gObjID, 0x181F);            //Soul Pack
         int CheckBlessPack = CheckChaosItem(gObjID, 0x181E);         //Bless Pack

         //Checking Feather & Flame Presence [All Condition Must Be 1]
         int FlameOfCondor = CheckChaosItem(gObjID, 0x1A34);            //Flame Of Condor
         int FeatherOfCondor = CheckChaosItem(gObjID, 0x1A35);         //Feather Of Condor

         //Checking Presence of Excellent Item
         int ItemRange = CheckChaosItemRange(gObjID, 0x0000, 0x17FF);   //Items Range [0][12]   

         //Making Sure that all item elements are present
         int CombinationCheckSum = CheckChaosJewel + CheckCreationJewel + CheckSoulPack + CheckBlessPack + FlameOfCondor + FeatherOfCondor;

         if(CombinationCheckSum>=6)
         {
            srand(static_cast<int>(time(NULL)));
            int Success = (rand() % 100);

            //To Fix: % Calculation of Success

            if(Success <= S3Config.nWingspercent)
            {
               srand(static_cast<int>(time(NULL)));
               WORD WingsId = 0x1824 + (rand() % 6);

               if(WingsId==0x1829)
                  WingsId=0x182B;
            
               int Luck=0;
               int ExcOption=0;
               int ZOption=0;

               srand(static_cast<int>(time(NULL)));
               if(S3Config.nWingsLuckpercent >= rand()%100)
               {
                  //Luck Setting Combination
                  Luck=1;
               }

               if (S3Config.nWingsExcOptpercent!=0)
               {
                  //Option Setting Combination
                  srand(static_cast<int>(time(NULL)));
                  ExcOption = rand()%S3Config.nWingsExcOptpercent+1;
               }
            
               int totalZen=GetZen(gObjID);
               SetZen(gObjID, totalZen-2000000);
               InvItemCreate ( gObjID , 0xFF , 0 , 0 , WingsId , 0 , 255 ,0 , Luck , ZOption , -1 , ExcOption , 0 );

               wsprintf(sBuf, "[Chaos Mix][%s] 3rd Wings Mix Success at %d%",GetName(gObjID),Success);
               LogLine("%s\n", sBuf);
            }
            else
            {
               int totalZen=GetZen(gObjID);
               SetZen(gObjID, totalZen-2000000);
               ChaosSendMixFail(gObjID);

               wsprintf(sBuf, "[Chaos Mix][%s] 3rd Wings Mix Fail at %d%",GetName(gObjID),Success);
               LogLine("%s\n", sBuf);
            }
         } else {
            Gs_GCServerMsgStringSend("[Anti-Hack] Wings Mix Hack",gObjID, 0x01);

            wsprintf(sBuf, "[Anti-Hack][%s] Wings Mix Hack Attempt",GetName(gObjID));
            AntiHackLog("%s\n", sBuf);

            SetZen(gObjID, GetZen(gObjID));
            ChaosSendMixFail(gObjID);
         }
      }break;
   }

   //Inventory Save after combination [ALT-F4]
   LPGOBJSTRUCT pOBJ = (LPGOBJSTRUCT)(gObjID*gObjSize + gObjBaseAddr);
   int result=j_GDUserItemSave(pOBJ);
}

void __declspec(naked) ChaosBoxCheckNewItems() {
   __asm {
      // Original
      cmp eax, 0x180F;
      je ItemAllowed;

      // Flame Of Condor
      cmp eax, 0x1A34;
      je ItemAllowed;

      // Feather of Condor
      cmp eax, 0x1A35;
      je ItemAllowed;

      // Package of 10 Blesses
      cmp eax, 0x181E;
      je ItemAllowed;

      // Package of 10 Souls
      cmp eax, 0x181F;
      je ItemAllowed;

      // Scroll Illusion
      cmp eax, 0x1A31;
      je ItemAllowed;

      // Potion Illusion
      cmp eax, 0x1A32;
      je ItemAllowed;

      // 1st Level Wings of Summoner
      cmp eax, 0x1829;
      je ItemAllowed;

      // 2nd Level Wings of Summoner
      cmp eax, 0x182A;
      je ItemAllowed;

      mov edi, ChaosBoxCheckNewItems_Exit;
      jmp edi;

      ItemAllowed:
         mov edi, ChaosBoxCheckNewItems_ItemAllowed;
         jmp edi;
   }
}



Season3.h

Code:

#ifndef __SEASON3_H__
#define __SEASON3_H__
   void Season3_Init();

   __declspec() void CMapServerManager__CheckMoveMapSvr();
   
//=======================================================================================================
   // [ChaosMachine] ChaosMachine.cpp
   //=======================================================================================================
   __declspec() void ChaosBoxCheckNewItems();



ChaosMachine.h


Code:

#ifndef __CHAOSMACHINE_H__
#define __CHAOSMACHINE_H__
   void ChaosSendMixFail ( DWORD gObjID );
   void ChaosBoxHook(DWORD gObjID , DWORD MixID);
   BYTE GetChaosItemLevel ( DWORD gObjId , WORD ItemID);

   int CheckChaosItem ( DWORD gObjId , WORD ItemID);
   int CheckChaosItemRange ( DWORD gObjId , WORD ItemIDStart, WORD ItemIDEnd);
   WORD GetChaosItemRange ( DWORD gObjId , WORD ItemIDStart, WORD ItemIDEnd);
#endif __CHAOSMACHINE_H__

GsFunc.h

Code:

#ifndef __GSFUNC_H__
   #define __GSFUNC_H__

   typedef struct tagDLL_VAR
   {
      DWORD   dwGgPayMoney ;
      DWORD   dwIsOpenGg  ;
      int      nGgColour;
      WORD   wCfgLv ;
      WORD   wMaxPoint ;
   
      DWORD   dwCryWolfBoundedElf_Bless ;
      DWORD   dwCryWolfBoundedElf_Soul ;
      DWORD   dwCryWolfBoundedElf_Chaos ;
      DWORD   dwCryWolfBoundedElf_Life ;
      DWORD   dwCryWolfBoundedElf_Creation;
      DWORD   dwCryWolfBoundedElf_Guardian   ;
      DWORD   dwCryWolfHero_Bless ;
      DWORD   dwCryWolfHero_Soul ;
      DWORD   dwCryWolfHero_Chaos ;
      DWORD   dwCryWolfHero_Life ;
      DWORD   dwCryWolfHero_Creation ;
      DWORD   dwCryWolfHero_Guardian;
      DWORD   dwCryBossDropItemNumber ;
      DWORD   dwWinElf[5] ;
      int      iBoundedCount ;
      bool   isCryWolfWin ;
      
      DWORD   dwItemTradeLimit ;
      DWORD  dwItemSellLimit ;
      DWORD  dwItemMixLimit ;
      DWORD   dwItemPshopLimit ;
      DWORD   dwItemPlusLimit ;
      DWORD   dwExItemPlusLimit ;
      DWORD  dwExItemOpLimit ;
      DWORD   dwSetItemPlusLimit ;
      DWORD   dwIsOpenErrorItemUpgrade ;
      DWORD  dwErrorItemLevelCheck ;
      DWORD  dwItemJinhuaLimit ;

      int      dwZSDelCharLimit ;
      int      iIsOpenZsCharDel ;

      char   cZSUser[32]   ;
      char   cZSPass[32]   ;
      char   cZSHost[32]   ;
      char   cZSDB[32]   ;  //db control
      char   cZSDBMe[32]   ;
      char   cZSTable[32]  ;
      char   cZSCountCol[32]  ;
      char   cZSCharNameCol[32] ;
      char   cZSCharResetsCol[32] ;

      char   cGamePointDB[32]   ;  //db control
      char   cGamePointTable[32]  ;
      char   cGamePointCol[32]  ;
      char   cGamePointAccount[32] ;
   
      BOOL   DCFix;
      int      iIsOpenOnlineAddPoint  ;
      int      iOnlineAddPointMaxNumber;
      int      iGsReadPath  ;

      int iStop_CObjUseSkill_SpeedHackCheck  ;
      int iBC_Mission_Recive_Time  ;
   
      int iIsMultiWarehouse ;
      int iMaxWarehouseNum  ;
      //int   SCFDSPORT ;
      int GMCtlCode  ;
      int IsItem  ;
      int IsBanAcc  ;
      int IsBanChar  ;
      int IsUnBanAcc  ;
      int IsUnBanChar  ;

      UINT nExItemDropRate;
      UINT nExItemDropSkillRate;
      UINT nExItemDropLuckRate;
      UINT nNormalItemDropSkillRate;
      UINT nNormalItemDropLuckRate;

      int MaxLevel;
      int ExpLimit;

      BYTE byMGNormal;
      BYTE byMGCW;
      BYTE byMGBlood;
      BYTE byMGChaos;
      BYTE byDLNormal;
      BYTE byDLCW;
      BYTE byDLBlood;
      BYTE byDLChaos;
      BYTE byGeneralNormal;
      BYTE byGeneralCW;
      BYTE byGeneralBlood;
      BYTE byGeneralChaos;
      BYTE byLUP_2ndNormal;
      BYTE byLUP_2ndCW;
      BYTE byLUP_2ndBlood;
      BYTE byLUP_2ndChaos;
   
      int byLUP_3rdNormal;
      int byLUP_3rdBlood;
      int byLUP_3rdChaos;
      int byLUP_3rdCW;

      BOOL bLoadSkillTree;
      int SkillTreeMaxLevel;
      int SkillTreePointsPerLevel;

      BYTE cMapData[51][0x51068] ;
      BOOL   bSkinItsOnlyForGM ;
      int      SkinPayMoney ;
      int      SkinLevelReq ;
   
      int NewLogGen;
   }WZAG_VAR ;

   typedef struct Extra_Data
   {
      int   bCanSellQuestItem;
      int   bCanDropQuestItem;
      int FixTwistingSlash;
   }EXTRA;
   extern EXTRA Extra;


   bool ItemDropRateInit (UINT ExItemDropRate, UINT ExItemDropSkillRate, UINT ExItemDropLuckRate, UINT NormalItemDropSkillRate, UINT NormalItemDropLuckRate);
   void LvlUpPoint(BYTE MG1,BYTE MG2,BYTE MG3,BYTE MG4, BYTE DL1, BYTE DL2, BYTE DL3, BYTE DL4, BYTE Gral1, BYTE Gral2, BYTE Gral3, BYTE Gral4);
   
   DWORD gObjByNick(char * nick);
   DWORD gObjByInventory( int rinv );
   DWORD gObjByWarehouse( int rinv );
   DWORD gObjByAccountID ( char * nick );
   char * gObjAccountNameByNick ( LPCSTR nick );
   short gObjWarehousePWByNick ( LPCSTR nick );
   
   void SetDrop(DWORD Drop);
   int GetDrop();
   int GetExp();
   int CheckPlayerMoney(DWORD PlayerID);
   void GetGgMoney(DWORD PlayerID );
   DWORD GetConnectCount();
   WORD GetGsPort();
   WORD GetSrvCode();
   DWORD GetIsgojAllDissconnect();
   DWORD GetTotalPlayer();
   DWORD  GetNumberOfMaxUser();
   DWORD JobNPC(DWORD PlayerID);
   BYTE GetQuest(DWORD PlayerID, int NumHook);
   PBYTE GetCompleteQuest(DWORD PlayerID);
   void SetQuest(DWORD PlayerID, BYTE HookByte, int NumHook);
   void SetAllQuest(DWORD PlayerID, BYTE HookByte, int FromNumHook);
   
   WORD GetNpcLevel(DWORD NpcID);
   int GetNpcID(DWORD NpcDataAddr);
   
   int GetZen(DWORD PlayerID);
   
   void SetCtlCode(DWORD PlayerID,int CtlCode);
   void SetBlockCode(DWORD PlayerID,int BlocCode);

   void AddSkill(DWORD PlayerID,int Skill,int Type);
   void AddSkillOld(DWORD PlayerID,int Skill, int Type);
   int RemoveSummonerBadSkills ( DWORD PlayerID );
   void RemoveAllSkills ( DWORD PlayerID );
   void FixPlayerSkill ( DWORD PlayerID);
   int CheckPlayerSkill ( DWORD PlayerID, BYTE SkillId );
   DWORD AddLevelUpPoint(DWORD PlayerID, DWORD Valor);
   DWORD AddPlusLevelUpPoint(DWORD PlayerID, DWORD Valor);
   void MassLimitMove(int MapC, int MaxPosX, int MinPosX, int MaxPosY, int MinPosY);
   void MassGMove(int Map, int X, int Y);

   UINT GetKind(DWORD MobID);
   int GetGuildNumber(DWORD PlayerID);
   int GetGuildStruct(DWORD PlayerID);
   LPSTR GetGuildName(DWORD PlayerID);
   int j_CItem__GetSize(WORD ItemID, int x, int y);
   BOOL Check_ItemInInventory(DWORD PlayerID, WORD ItemByte);
   PBYTE GetCompleteInventory(DWORD PlayerID);
   void Drinks(DWORD PlayerID, BYTE Byte1);
   int Check_ItemInPosition(DWORD PlayerID, WORD ItemByte,int i);
   short GetStrenght(DWORD PlayerID);
   short GetDexterity(DWORD PlayerID);
   short GetVitality(DWORD PlayerID);
   short GetEnergy(DWORD PlayerID);
   short GetCarisma(DWORD PlayerID);
   
   int GetMagicSpeed(DWORD PlayerID);
   void SetMagicSpeed(DWORD PlayerID,int MagicSpeed);

   int GetExcelentDmg(DWORD PlayerID);
   void SetExcelentDmg(DWORD PlayerID,int ExcDmg);

   void SetSuccessBlock(DWORD PlayerID,int SuccessBlock);
   int GetSuccessBlock(DWORD PlayerID);
   int MapPlayerCount(BYTE Map);

   int GetDefense(DWORD PlayerID);
   void SetDefense(DWORD PlayerID,int Defense);
   
   int GetLevel(DWORD PlayerID);
   short GetLevelUpPoints(DWORD PlayerID);
   int GetExperience(DWORD PlayerID);
   int GetExperienceMax(DWORD PlayerID);
   LPSTR GetUser(DWORD PlayerID);
   int GetDir(DWORD PlayerID);
   int GetClass(DWORD PlayerID);
   int GetGSClass(DWORD PlayerID);
   int PkCount(DWORD PlayerID);
   int PkLevel(DWORD PlayerID);
   int PkTime(DWORD PlayerID);
   void SetClass(DWORD PlayerID,int Class);
   void SetExp(DWORD PlayerID,int Exp);

   void SetAttackRating(DWORD PlayerID,int AttackRating);
   int GetAttackRating(DWORD PlayerID);
   int GetReflect(DWORD PlayerID);
   int GetLife(DWORD PlayerID);
   void SetReflect(DWORD PlayerID,int Reflex);

   int GetMagicDefense(DWORD PlayerID);
   void SetMagicDefense(DWORD PlayerID,int MagicDefense);

   void SetZen(DWORD PlayerID, int Zen);
   bool TiraZen(DWORD PlayerID, int Zen);

   void MovePlayer(DWORD PlayerID, int PosX, int PosY, int nMap);
   int GetNpcNum(int aIndex);
   BOOL IsOnGame(int aIndex);
   void SetPkLevelASM(DWORD PlayerID, int pk);
   LPSTR GetName(DWORD PlayerID);
   int CtlCode(DWORD PlayerID);
   void SendZen(DWORD PlayerID, int Zen);
   void DebugInfo(char LogText[], DWORD Type);
   void SendNoticeToAll(char *  Notice, BYTE Type);
   void SendNoticeToAllGS(char * Notice);
   void SendNoticeToNoIllusion(char * Notice, BYTE Type);
   void SendNoticeToIllusion(char * Notice, BYTE Type);
   void SendNoticeToMap(char * Notice, int Map);
   void SkinOpt(DWORD PlayerID,int Mob);
   void SetAddStats(DWORD PlayerID,int Puntos,BYTE Stat);
   void CloseRandomPlayer(void * lpParam);

#endif __GSFUNC_H__

TypeDefs.h

Code:

#ifndef __TYPEDEFS_H__
#define __TYPEDEFS_H__

bool __cdecl  MyDataSend(DWORD PlayerID,PBYTE tpProtocol ,DWORD ProtocolLen);
void __cdecl  MyDataRecv(BYTE ProtocolID,PBYTE tpProtocol,DWORD ProtocolLen,DWORD PlayerID,DWORD bEncrypt,int EncryptSerial ); //DWORD bEncrypt=1
//int __stdcall MyMultiByteToWideChar(
//                           UINT CodePage,        // code page
//                           DWORD dwFlags,        // character-type options
//                           LPCSTR lpMultiByteStr, // string to map
//                           int cbMultiByte,      // number of bytes in string
//                           LPWSTR lpWideCharStr,  // wide-character buffer
//                           int cchWideChar        // size of buffer
//                           );
//
//int __stdcall MyWideCharToMultiByte(
//                           UINT CodePage,            // code page
//                           DWORD dwFlags,            // performance and mapping flags
//                           LPCWSTR lpWideCharStr,    // wide-character string
//                           int cchWideChar,          // number of chars in string
//                           LPSTR lpMultiByteStr,    // buffer for new string
//                           int cbMultiByte,          // size of buffer
//                           LPCSTR lpDefaultChar,    // default for unmappable chars
//                           LPBOOL lpUsedDefaultChar  // set when default char used
//                           );


//DWORD *  a_gObjAddr ) ; //retrun Value: 0 δ´¦Àí  / 1 ´¦Àí¹ý
//void  __cdecl MygObjMonsterDieGiveItem( DWORD * b_MonsterDataAddr ,DWORD *  a_gObjAddr ) ;
void __stdcall MyGetHtBoundedElf(DWORD *) ;
void  __stdcall MySendJewelToCryWolfHero(DWORD * dwHeroDataAddr) ;

void __cdecl MygObjSkillUseProc (DWORD * pdwPcDataAddr ) ;

int __cdecl MyNpcAngelKing(DWORD * pdwMonsterIdx,DWORD *  pdwUserIdx);



/////////////////////////// TYPEDEF start///////////////////////////



typedef void FAR (*SocketSendProc)(DWORD,PBYTE,DWORD);//ÈËÎïID,ЭÒ黺³åÇøÊ×Ö·,ЭÒ鳤¶È???
typedef void FAR (*ClientProtocolProc)(BYTE,PBYTE ,DWORD ,DWORD ,DWORD ,int);


//DWORD *  ) ;
//typedef int FAR (__cdecl *GsgObjMonsterDieGiveItemProc)(DWORD  *,DWORD *  ) ;
typedef DWORD FAR (*GsItemGetNumberMakeProc)(DWORD  ,DWORD    ) ;
typedef DWORD FAR (*GsgObjMonsterTopHitDmgUserProc)(DWORD *) ;

typedef int FAR  (*GsgObjGetRandomItemDropLocationProc)(BYTE  ,DWORD,DWORD,DWORD,DWORD,DWORD    ) ; //return 0 /1
typedef void FAR (*GsMakeRewardSetItemProc)(DWORD ,DWORD,DWORD,DWORD,BYTE  ) ;
typedef void FAR (*GsCrywolfBossMonsterItemBagOpenProc)(DWORD * ,BYTE ,DWORD,DWORD  ) ;

//1014 added
typedef int FAR (*gObjSetCharacterProc)(DWORD * ,DWORD ) ;
typedef int FAR (*gObjMagicAddProc)(DWORD * ,DWORD,int ) ;

//1015
typedef void FAR (*GCMagicAttackNumberSendProc)(DWORD *  ,DWORD ,DWORD ,int);
typedef int  FAR (__stdcall *CObjBaseAttack_DecreaseArrowProc)  (DWORD *  ) ;
typedef void FAR (*gObjCharZeroSetProc)(DWORD  ) ;
typedef int FAR (__stdcall *CObjUseSkill__RemoveAllCharacterInvalidMagicAndSkillStateProc)(DWORD *  ) ;
typedef void FAR (*gObjSkillUseProc)(DWORD * ) ;

//1019 for trade limit
typedef void FAR (__cdecl * GCItemMoveResultSendProc)(DWORD  ,BYTE ,BYTE  ,PBYTE  ) ;
typedef void FAR (__cdecl  *  CGInventoryItemMoveProc ) (PBYTE pRecvBuff,DWORD dwPcIdx) ;

typedef void FAR (__cdecl  *  CGUseItemRecvProc ) (PBYTE pRecvBuff,DWORD dwPcIdx) ;
typedef void FAR (__cdecl  *  CGPCharDelProc ) (PBYTE pRecvBuff,DWORD dwPcIdx) ;
typedef void FAR ( __cdecl  *  CGLevelUpPointAddProc ) (PBYTE pRecvBuff,DWORD dwPcIdx) ;

typedef int FAR (* CItem_IsItem_Proc)(void ) ;
typedef char * FAR (__stdcall * GetMsg_Proc )( int ) ;
typedef void FAR (__cdecl * GCServerMsgStringSend_Proc )(char *, DWORD,int ) ;

typedef void FAR (__cdecl * gObjInventoryItemSet_Proc )(DWORD, int,BYTE ) ;
typedef void FAR (__cdecl * CItem_Clear_Proc )(void ) ;
typedef void FAR (__cdecl * GCItemListSend_Proc )(DWORD  ) ;
typedef void FAR (__cdecl * GCMoneySend_Proc )(DWORD,int  ) ;

typedef int FAR (__stdcall * CObjUseSkill_SpeedHackCheck_Proc )(DWORD  ) ;
typedef int FAR (__cdecl * NpcAngelKing_Proc )(DWORD *,DWORD * ) ;
typedef void FAR (__cdecl * GCLevelUpMsgSend_Proc )(DWORD,DWORD ) ;

typedef void FAR (__stdcall * CryWolfWinBoundElf_Proc )(DWORD  ) ;
typedef void FAR (__stdcall * CryWolfWinTopHero5_Proc )(DWORD  ) ;

extern GCServerMsgStringSend_Proc Gs_GCServerMsgStringSend;
extern bool GsDataSendFuncEx  (DWORD PlayerID,PBYTE pProtocol ,DWORD ProtocolLen);
extern GCLevelUpMsgSend_Proc Gs_GCLevelUpMsgSend;
extern CGLevelUpPointAddProc  GsCGLevelUpPointAddFunc;

extern void DataSendToMap ( int PlayerID , PBYTE Protocol , DWORD ProtocolLen);
extern void DataSendAllNear ( int PlayerID , PBYTE Protocol , DWORD ProtocolLen, int dist);
extern void DataSendNear (int Map,int X,int Y, PBYTE Protocol , DWORD ProtocolLen, int dist);
extern void DataSendAll (PBYTE Protocol , DWORD ProtocolLen);

#endif __TYPEDEFS_H__



Sper Sa Va Ajute
avatar
m4s4cru
Admin
Admin

Mesaje : 172
Data de inscriere : 2011-07-29
Varsta : 26

View user profile

Back to top Go down

View previous topic View next topic Back to top

- Similar topics

 
Permissions in this forum:
You cannot reply to topics in this forum