Sending Packets

Quote:

Originally Posted by Interest07 C# code I use for packet sending as follows PacketSender class:  Spoiler PHP Code: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Diagnostics; namespace PerfectWorld {     class PacketSender : PWIoffsets     {         private IntPtr pr_processHandle;         //======================//         //  Packet structures   //         //======================//         //Log out         private int logOutAddress;         private byte[] logOutAddressRev;         private byte[] logOutPkt = new byte[]          {              0x01, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00      //toAccount         };         public void logOut(int toAccount)         {             //Get size of the packet             int packetSize = logOutPkt.Length;             if (logOutAddress == 0)             {                 //load packet in memory                 loadPacket(logOutPkt, ref logOutAddress, ref logOutAddressRev);             }             byte[] toAccountRev = BitConverter.GetBytes(toAccount);             toAccountRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, logOutAddress + 2, toAccountRev);             sendPacket(logOutAddressRev, packetSize);         }         //Select Target         private int selectAddress;         private byte[] selectAddressRev;         private byte[] selectPkt = new byte[]          {              0x02, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00      //objectId         };         public void select(int objectId)         {             //Get size of the packet             int packetSize = selectPkt.Length;             if (logOutAddress == 0)             {                 //load packet in memory                 loadPacket(selectPkt, ref selectAddress, ref selectAddressRev);             }             byte[] objectIdRev = BitConverter.GetBytes(objectId);             objectIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, selectAddress + 2, objectIdRev);             sendPacket(selectAddressRev, packetSize);         }         //Regular Attack         private int regularAttackAddress;         private byte[] regularAttackAddressRev;                  private byte[] regularAttackPkt = new byte[]          {              0x03, 0x00,                 //Header             0x00                        //afterSkill         };         public void regularAttack(byte afterSkill)         {             //Get size of the packet             int packetSize = regularAttackPkt.Length;             if (regularAttackAddress == 0)             {                 //load packet in memory                 loadPacket(regularAttackPkt, ref regularAttackAddress, ref regularAttackAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, regularAttackAddress + 2, afterSkill);             sendPacket(regularAttackAddressRev, packetSize);         }         //Resurrect to town         private int resurrectToTownAddress;         private byte[] resurrectToTownAddressRev;             private byte[] resurrectToTownPkt = new byte[]          {              0x04, 0x00,                 //Header         };         public void resurrectToTown()         {             //Get size of the packet             int packetSize = resurrectToTownPkt.Length;             if (resurrectToTownAddress == 0)             {                 //load packet in memory                 loadPacket(resurrectToTownPkt, ref resurrectToTownAddress, ref resurrectToTownAddressRev);             }             sendPacket(resurrectToTownAddressRev, packetSize);         }         //Resurrect with scroll         private int resurrectWithScrollAddress;         private byte[] resurrectWithScrollAddressRev;             private byte[] resurrectWithScrollPkt = new byte[]          {              0x05, 0x00,                 //Header         };         public void resurrectWithScroll()         {             //Get size of the packet             int packetSize = resurrectWithScrollPkt.Length;             if (resurrectWithScrollAddress == 0)             {                 //load packet in memory                 loadPacket(resurrectWithScrollPkt, ref resurrectWithScrollAddress, ref resurrectWithScrollAddressRev);             }             sendPacket(resurrectWithScrollAddressRev, packetSize);         }         //Pick up item         private int pickUpItemAddress;         private byte[] pickUpItemAddressRev;             private byte[] pickUpItemPkt = new byte[]          {              0x06, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //uniqueId             0x00, 0x00, 0x00, 0x00      //typeId         };         public void pickUpItem(int uniqueId, int typeId)         {             //Get size of the packet             int packetSize = pickUpItemPkt.Length;             if (pickUpItemAddress == 0)             {                 //load packet in memory                 loadPacket(pickUpItemPkt, ref pickUpItemAddress, ref pickUpItemAddressRev);             }             byte[] uniqueIdRev = BitConverter.GetBytes(uniqueId);             uniqueIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, selectAddress + 2, uniqueIdRev);             byte[] typeIdRev = BitConverter.GetBytes(typeId);             typeIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, selectAddress + 6, typeIdRev);             sendPacket(pickUpItemAddressRev, packetSize);         }         //Update inventory position         private int updateInvPositionAddress;         private byte[] updateInvPositionAddressRev;             private byte[] updateInvPositionPkt = new byte[]          {              0x09, 0x00,                 //Header             0x00                        //itemPosition         };         public void updateInvPosition(byte invIndex)         {             //Get size of the packet             int packetSize = updateInvPositionPkt.Length;             if (updateInvPositionAddress == 0)             {                 //load packet in memory                 loadPacket(updateInvPositionPkt, ref updateInvPositionAddress, ref updateInvPositionAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, updateInvPositionAddress + 2, invIndex);             sendPacket(updateInvPositionAddressRev, packetSize);         }         //Swap item in inventory         private int swapItemInInvAddress;         private byte[] swapItemInInvAddressRev;             private byte[] swapItemInInvPkt = new byte[]          {              0x0C, 0x00,                 //Header             0x00,                       //itemInvIndex 1             0x00                        //itemInvIndex 2         };         public void swapItemInInv(byte invIndex1, byte invIndex2)         {             //Get size of the packet             int packetSize = swapItemInInvPkt.Length;             if (swapItemInInvAddress == 0)             {                 //load packet in memory                 loadPacket(swapItemInInvPkt, ref swapItemInInvAddress, ref swapItemInInvAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, swapItemInInvAddress + 2, invIndex1);             MemFunctions.MemWriteByte(pr_processHandle, swapItemInInvAddress + 3, invIndex2);             sendPacket(swapItemInInvAddressRev, packetSize);         }         //Split stack in inventory         private int splitStackItemInInvAddress;         private byte[] splitStackItemInInvAddressRev;             private byte[] splitStackItemInInvPkt = new byte[]          {              0x0D, 0x00,                 //Header             0x00,                       //itemInvIndexSource             0x00,                       //itemInvIndexDestination             0x00, 0x00                  //Amount         };         public void splitStackInInventory(byte invIndexSource, byte invIndexDestination, short amount)         {             //Get size of the packet             int packetSize = splitStackItemInInvPkt.Length;             if (splitStackItemInInvAddress == 0)             {                 //load packet in memory                 loadPacket(splitStackItemInInvPkt, ref splitStackItemInInvAddress, ref splitStackItemInInvAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, splitStackItemInInvAddress + 2, invIndexSource);             MemFunctions.MemWriteByte(pr_processHandle, splitStackItemInInvAddress + 3, invIndexDestination);             byte[] amountRev = BitConverter.GetBytes(amount);             amountRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, splitStackItemInInvAddress + 4, amountRev);             sendPacket(splitStackItemInInvAddressRev, packetSize);         }         //Drop item         private int dropItemAddress;         private byte[] dropItemAddressRev;             private byte[] dropItemPkt = new byte[]          {              0x0E, 0x00,                 //Header             0x00,                       //itemInvIndexSource             0x00, 0x00                  //Amount         };         public void dropItem(byte invIndex, short amount)         {             //Get size of the packet             int packetSize = dropItemPkt.Length;             if (dropItemAddress == 0)             {                 //load packet in memory                 loadPacket(dropItemPkt, ref dropItemAddress, ref dropItemAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, dropItemAddress + 2, invIndex);             byte[] amountRev = BitConverter.GetBytes(amount);             amountRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, dropItemAddress + 3, amountRev);             sendPacket(dropItemAddressRev, packetSize);         }         //Swap item in equip         private int swapItemInEquipAddress;         private byte[] swapItemInEquipAddressRev;             private byte[] swapItemInEquipPkt = new byte[]          {              0x10, 0x00,                 //Header             0x00,                       //itemEquipIndex 1             0x00                        //itemEquipIndex 2         };         public void swapItemInEquip(byte equipIndex1, byte equipIndex2)         {             //Get size of the packet             int packetSize = swapItemInEquipPkt.Length;             if (swapItemInEquipAddress == 0)             {                 //load packet in memory                 loadPacket(swapItemInEquipPkt, ref swapItemInEquipAddress, ref swapItemInEquipAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, swapItemInEquipAddress + 2, equipIndex1);             MemFunctions.MemWriteByte(pr_processHandle, swapItemInEquipAddress + 3, equipIndex2);             sendPacket(swapItemInEquipAddressRev, packetSize);         }         //Swap equipment with inventory         private int swapEquipWithInvAddress;         private byte[] swapEquipWithInvAddressRev;             private byte[] swapEquipWithInvPkt = new byte[]          {              0x11, 0x00,                 //Header             0x00,                       //invIndex              0x00                        //equipIndex         };         public void swapEquipWithInv(byte invIndex, byte equipIndex)         {             //Get size of the packet             int packetSize = swapEquipWithInvPkt.Length;             if (swapEquipWithInvAddress == 0)             {                 //load packet in memory                 loadPacket(swapEquipWithInvPkt, ref swapEquipWithInvAddress, ref swapEquipWithInvAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, swapEquipWithInvAddress + 2, invIndex);             MemFunctions.MemWriteByte(pr_processHandle, swapEquipWithInvAddress + 3, equipIndex);             sendPacket(swapEquipWithInvAddressRev, packetSize);         }         //Drop gold         private int dropGoldAddress;         private byte[] dropGoldAddressRev;             private byte[] dropGoldPkt = new byte[]          {              0x14, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00     //amount         };         public void dropGold(int amount)         {             //Get size of the packet             int packetSize = dropGoldPkt.Length;             if (dropGoldAddress == 0)             {                 //load packet in memory                 loadPacket(dropGoldPkt, ref dropGoldAddress, ref dropGoldAddressRev);             }             byte[] amountRev = BitConverter.GetBytes(amount);             amountRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, dropGoldAddress + 2, amountRev);             sendPacket(dropGoldAddressRev, packetSize);         }         //Update stats         private int updateStatsAddress;         private byte[] updateStatsAddressRev;             private byte[] updateStatsPkt = new byte[]          {              0x15, 0x00                 //Header         };         public void updateStats()         {             //Get size of the packet             int packetSize = updateStatsPkt.Length;             if (updateStatsAddress == 0)             {                 //load packet in memory                 loadPacket(updateStatsPkt, ref updateStatsAddress, ref updateStatsAddressRev);             }             sendPacket(updateStatsAddressRev, packetSize);         }         //Increase stats         private int increaseStatsByAddress;         private byte[] increaseStatsByAddressRev;             private byte[] increaseStatsByPkt = new byte[]          {              0x16, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //con             0x00, 0x00, 0x00, 0x00,     //int             0x00, 0x00, 0x00, 0x00,     //str             0x00, 0x00, 0x00, 0x00      //agi         };         public void increaseStatsBy(int constitution, int intelligence, int strength, int agility)         {             //Get size of the packet             int packetSize = increaseStatsByPkt.Length;             if (increaseStatsByAddress == 0)             {                 //load packet in memory                 loadPacket(increaseStatsByPkt, ref increaseStatsByAddress, ref increaseStatsByAddressRev);             }             byte[] constitutionRev = BitConverter.GetBytes(constitution);             constitutionRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, increaseStatsByAddress + 2, constitutionRev);             byte[] intelligenceRev = BitConverter.GetBytes(intelligence);             intelligenceRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, increaseStatsByAddress + 6, intelligenceRev);             byte[] strengthRev = BitConverter.GetBytes(strength);             strengthRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, increaseStatsByAddress + 10, strengthRev);             byte[] agilityRev = BitConverter.GetBytes(agility);             agilityRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, increaseStatsByAddress + 14, agilityRev);             sendPacket(increaseStatsByAddressRev, packetSize);         }         //Invite to party         private int invitePartyAddress;         private byte[] invitePartyAddressRev;             private byte[] invitePartyPkt = new byte[]          {              0x1B, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00     //playerId         };         public void inviteParty(int playerId)         {             //Get size of the packet             int packetSize = invitePartyPkt.Length;             if (invitePartyAddress == 0)             {                 //load packet in memory                 loadPacket(invitePartyPkt, ref invitePartyAddress, ref invitePartyAddressRev);             }             byte[] playerIdRev = BitConverter.GetBytes(playerId);             playerIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, invitePartyAddress + 2, playerIdRev);             sendPacket(invitePartyAddressRev, packetSize);         }         //Accept party invite         private int acceptPartyInviteAddress;         private byte[] acceptPartyInviteAddressRev;             private byte[] acceptPartyInvitePkt = new byte[]          {              0x1C, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //playerId             0x00, 0x00, 0x00, 0x00      //partyInviteCounter         };         public void acceptPartyInvite(int playerId, int partyInviteCounter)         {             //Get size of the packet             int packetSize = acceptPartyInvitePkt.Length;             if (acceptPartyInviteAddress == 0)             {                 //load packet in memory                 loadPacket(acceptPartyInvitePkt, ref acceptPartyInviteAddress, ref acceptPartyInviteAddressRev);             }                          byte[] playerIdRev = BitConverter.GetBytes(playerId);             playerIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, acceptPartyInviteAddress + 2, playerIdRev);             byte[] partyInviteCounterRev = BitConverter.GetBytes(partyInviteCounter);             partyInviteCounterRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, acceptPartyInviteAddress + 6, partyInviteCounterRev);                      sendPacket(acceptPartyInviteAddressRev, packetSize);         }         //Refuse party invite         private int refusePartyInviteAddress;         private byte[] refusePartyInviteAddressRev;             private byte[] refusePartyInvitePkt = new byte[]          {              0x1D, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00     //playerId         };         public void refusePartyInvite(int playerId)         {             //Get size of the packet             int packetSize = refusePartyInvitePkt.Length;             if (refusePartyInviteAddress == 0)             {                 //load packet in memory                 loadPacket(refusePartyInvitePkt, ref refusePartyInviteAddress, ref refusePartyInviteAddressRev);             }                          byte[] playerIdRev = BitConverter.GetBytes(playerId);             playerIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, refusePartyInviteAddress + 2, playerIdRev);                          sendPacket(refusePartyInviteAddressRev, packetSize);         }         //Leave party         private int leavePartyAddress;         private byte[] leavePartyAddressRev;             private byte[] leavePartyPkt = new byte[]          {              0x1E, 0x00                 //Header         };         public void leaveParty()         {             //Get size of the packet             int packetSize = leavePartyPkt.Length;             if (leavePartyAddress == 0)             {                 //load packet in memory                 loadPacket(leavePartyPkt, ref leavePartyAddress, ref leavePartyAddressRev);             }             sendPacket(leavePartyAddressRev, packetSize);         }         //Evict from party         private int evictFromPartyAddress;         private byte[] evictFromPartyAddressRev;             private byte[] evictFromPartyPkt = new byte[]          {              0x1F, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00     //playerId         };         public void evictFromParty(int playerId)         {             //Get size of the packet             int packetSize = evictFromPartyPkt.Length;             if (evictFromPartyAddress == 0)             {                 //load packet in memory                 loadPacket(evictFromPartyPkt, ref evictFromPartyAddress, ref evictFromPartyAddressRev);             }             byte[] playerIdRev = BitConverter.GetBytes(playerId);             playerIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, evictFromPartyAddress + 2, playerIdRev);             sendPacket(evictFromPartyAddressRev, packetSize);         }         //Start NPC dialogue         private int startNpcDialogueAddress;         private byte[] startNpcDialogueAddressRev;             private byte[] startNpcDialoguePkt = new byte[]          {              0x23, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00     //npcId         };         public void startNpcDialogue(int npcId)         {             //Get size of the packet             int packetSize = startNpcDialoguePkt.Length;             if (startNpcDialogueAddress == 0)             {                 //load packet in memory                 loadPacket(startNpcDialoguePkt, ref startNpcDialogueAddress, ref startNpcDialogueAddressRev);             }             byte[] npcIdRev = BitConverter.GetBytes(npcId);             npcIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, startNpcDialogueAddress + 2, npcIdRev);             sendPacket(startNpcDialogueAddressRev, packetSize);         }         //Use item         private int useItemAddress;         private byte[] useItemAddressRev;             private byte[] useItemPkt = new byte[]          {              0x28, 0x00,                 //Header             0x00,                       //isEquip             0x01,                                    0x00,                       //itemIndex             0x00,             0x00, 0x00, 0x00, 0x00      //typeId         };         public void useItem(byte isEquip, byte itemIndex, int typeId)         {             //Get size of the packet             int packetSize = useItemPkt.Length;             if (useItemAddress == 0)             {                 //load packet in memory                 loadPacket(useItemPkt, ref useItemAddress, ref useItemAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, useItemAddress + 2, isEquip);             MemFunctions.MemWriteByte(pr_processHandle, useItemAddress + 4, itemIndex);                          byte[] typeIdRev = BitConverter.GetBytes(typeId);             typeIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, useItemAddress + 6, typeIdRev);             sendPacket(useItemAddressRev, packetSize);         }         //Use skill         private int useSkillddress;         private byte[] useSkillAddressRev;             private byte[] useSkillPkt = new byte[]          {              0x29, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //skillId             0x00, 0x01,             0x00, 0x00, 0x00, 0x00      //targetId         };         public void useSkill(int skillId, int targetId)         {             //Get size of the packet             int packetSize = useSkillPkt.Length;             if (useSkillddress == 0)             {                 //load packet in memory                 loadPacket(useSkillPkt, ref useSkillddress, ref useSkillAddressRev);             }             byte[] skillIdRev = BitConverter.GetBytes(skillId);             skillIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, useSkillddress + 2, skillIdRev);                          byte[] targetIdRev = BitConverter.GetBytes(targetId);             targetIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, useSkillddress + 8, targetIdRev);             sendPacket(useSkillAddressRev, packetSize);         }         //Cancel action         private int cancelActionAddress;         private byte[] cancelActionAddressRev;             private byte[] cancelActionPkt = new byte[]          {              0x2A, 0x00                 //Header         };         public void cancelAction()         {             //Get size of the packet             int packetSize = cancelActionPkt.Length;             if (cancelActionAddress == 0)             {                 //load packet in memory                 loadPacket(cancelActionPkt, ref cancelActionAddress, ref cancelActionAddressRev);             }             sendPacket(cancelActionAddressRev, packetSize);         }         //Start meditating         private int startMeditatingAddress;         private byte[] startMeditatingAddressRev;             private byte[] startMeditatingPkt = new byte[]          {              0x2E, 0x00,                 //Header         };         public void startMeditating()         {             //Get size of the packet             int packetSize = startMeditatingPkt.Length;             if (startMeditatingAddress == 0)             {                 //load packet in memory                 loadPacket(startMeditatingPkt, ref startMeditatingAddress, ref startMeditatingAddressRev);             }             sendPacket(startMeditatingAddressRev, packetSize);         }         //Stop meditating         private int stopMeditatingAddress;         private byte[] stopMeditatingAddressRev;             private byte[] stopMeditatingPkt = new byte[]          {              0x2F, 0x00,                 //Header         };         public void stopMeditating()         {             //Get size of the packet             int packetSize = stopMeditatingPkt.Length;             if (stopMeditatingAddress == 0)             {                 //load packet in memory                 loadPacket(stopMeditatingPkt, ref stopMeditatingAddress, ref stopMeditatingAddressRev);             }             sendPacket(stopMeditatingAddressRev, packetSize);         }         //Use emotion         private int useEmotionAddress;         private byte[] useEmotionAddressRev;             private byte[] useEmotionPkt = new byte[]          {              0x30, 0x00,                 //Header             0x00, 0x00                  //EmoteId         };         public void useEmotion(short emoteId)         {             //Get size of the packet             int packetSize = useEmotionPkt.Length;             if (useEmotionAddress == 0)             {                 //load packet in memory                 loadPacket(useEmotionPkt, ref useEmotionAddress, ref useEmotionAddressRev);             }             byte[] emoteIdRev = BitConverter.GetBytes(emoteId);             emoteIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, useEmotionAddress, emoteIdRev);             sendPacket(useEmotionAddressRev, packetSize);         }         //Be intimate         private int beIntimateAddress;         private byte[] beIntimateAddressRev;             private byte[] beIntimatePkt = new byte[]          {              0x30, 0x00,                 //Header             0x1D, 0x00                  //intimateId         };         public void beIntimate()         {             //Get size of the packet             int packetSize = beIntimatePkt.Length;             if (beIntimateAddress == 0)             {                 //load packet in memory                 loadPacket(beIntimatePkt, ref beIntimateAddress, ref beIntimateAddressRev);             }             sendPacket(beIntimateAddressRev, packetSize);         }         //Harvest resource         private int harvestResourceAddress;         private byte[] harvestResourceAddressRev;             private byte[] harvestResourcePkt = new byte[]          {              0x36, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //uniqueId             0x00, 0x00, 0x1E, 0x00,                  0x01, 0x0C, 0x00, 0x00,                  0x00, 0x00, 0x00, 0x00             };         public void harvestResource(int uniqueId)         {             //Get size of the packet             int packetSize = harvestResourcePkt.Length;             if (harvestResourceAddress == 0)             {                 //load packet in memory                 loadPacket(harvestResourcePkt, ref harvestResourceAddress, ref harvestResourceAddressRev);             }             byte[] uniqueIdRev = BitConverter.GetBytes(uniqueId);             uniqueIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, harvestResourceAddress + 2, uniqueIdRev);             sendPacket(harvestResourceAddressRev, packetSize);         }         //Swap item in bank         private int swapItemInBankAddress;         private byte[] swapItemInBankAddressRev;         private byte[] swapItemInBankPkt = new byte[]          {              0x38, 0x00,                 //Header             0x03,              0x00,                       //bankIndex1             0x00                        //bankIndex2         };         public void swapItemInBank(byte bankIndex1, byte bankIndex2)         {             //Get size of the packet             int packetSize = swapItemInBankPkt.Length;             if (swapItemInBankAddress == 0)             {                 //load packet in memory                 loadPacket(swapItemInBankPkt, ref swapItemInBankAddress, ref swapItemInBankAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, swapEquipWithInvAddress + 3, bankIndex1);             MemFunctions.MemWriteByte(pr_processHandle, swapEquipWithInvAddress + 4, bankIndex2);             sendPacket(swapItemInBankAddressRev, packetSize);         }         //Split item in bank         private int splitStackItemInBankAddress;         private byte[] splitStackItemInBankAddressRev;         private byte[] splitStackItemInBankPkt = new byte[]          {              0x39, 0x00,                 //Header             0x03,             0x00,                       //bankIndexSource             0x00,                       //bankIndexDestination             0x00, 0x00                  //amount         };         public void splitStackItemInBank(byte bankIndexSource, byte bankIndexDestination, short amount)         {             //Get size of the packet             int packetSize = splitStackItemInBankPkt.Length;             if (splitStackItemInBankAddress == 0)             {                 //load packet in memory                 loadPacket(splitStackItemInBankPkt, ref splitStackItemInBankAddress, ref splitStackItemInBankAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, splitStackItemInBankAddress + 3, bankIndexSource);             MemFunctions.MemWriteByte(pr_processHandle, splitStackItemInBankAddress + 4, bankIndexSource);             byte[] amountRev = BitConverter.GetBytes(amount);             amountRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, splitStackItemInBankAddress + 5, amountRev);             sendPacket(splitStackItemInBankAddressRev, packetSize);         }         //Swap item between bank and inv         private int swapItemBankAndInvAddress;         private byte[] swapItemBankAndInvAddressRev;         private byte[] swapItemBankAndInvPkt = new byte[]          {              0x3A, 0x00,                 //Header             0x03,              0x00,                       //bankIndex             0x00,                       //invIndex         };         public void swapItemBankAndInv(byte bankIndex, byte invIndex)         {             //Get size of the packet             int packetSize = swapItemBankAndInvPkt.Length;             if (swapItemBankAndInvAddress == 0)             {                 //load packet in memory                 loadPacket(swapItemBankAndInvPkt, ref swapItemBankAndInvAddress, ref swapItemBankAndInvAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, swapItemBankAndInvAddress + 3, bankIndex);             MemFunctions.MemWriteByte(pr_processHandle, swapItemBankAndInvAddress + 4, invIndex);             sendPacket(swapItemBankAndInvAddressRev, packetSize);         }         //Split stack from bank to inventory         private int splitStackItemInBankToInvAddress;         private byte[] splitStackItemInBankToInvAddressRev;         private byte[] splitStackItemInBankToInvPkt = new byte[]          {              0x3B, 0x00,                 //Header             0x00,             0x00,                       //bankIndex             0x00,                       //invIndex             0x00, 0x00                  //amount         };         public void splitStackItemInBankToInv(byte bankIndex, byte invIndex, short amount)         {             //Get size of the packet             int packetSize = splitStackItemInBankToInvPkt.Length;             if (splitStackItemInBankToInvAddress == 0)             {                 //load packet in memory                 loadPacket(splitStackItemInBankToInvPkt, ref splitStackItemInBankToInvAddress, ref splitStackItemInBankToInvAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, splitStackItemInBankToInvAddress + 3, bankIndex);             MemFunctions.MemWriteByte(pr_processHandle, splitStackItemInBankToInvAddress + 4, invIndex);             byte[] amountRev = BitConverter.GetBytes(amount);             amountRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, splitStackItemInBankToInvAddress + 5, amountRev);             sendPacket(splitStackItemInBankToInvAddressRev, packetSize);         }                //Split stack from bank to inventory         private int splitStackItemInInvToBankAddress;         private byte[] splitStackItemInInvToBankAddressRev;         private byte[] splitStackItemInInvToBankPkt = new byte[]          {              0x3C, 0x00,                 //Header             0x00,             0x00,                       //bankIndex             0x00,                       //invIndex             0x00, 0x00                  //amount         };         public void splitStackItemInInvToBank(byte invIndex, byte bankIndex, short amount)         {             //Get size of the packet             int packetSize = splitStackItemInInvToBankPkt.Length;             if (splitStackItemInInvToBankAddress == 0)             {                 //load packet in memory                 loadPacket(splitStackItemInInvToBankPkt, ref splitStackItemInInvToBankAddress, ref splitStackItemInInvToBankAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, splitStackItemInInvToBankAddress + 3, invIndex);             MemFunctions.MemWriteByte(pr_processHandle, splitStackItemInInvToBankAddress + 4, bankIndex);             byte[] amountRev = BitConverter.GetBytes(amount);             amountRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, splitStackItemInInvToBankAddress + 5, amountRev);             sendPacket(splitStackItemInInvToBankAddressRev, packetSize);         }         //Set party search settings         private int setPartySearchSettingsAddress;         private byte[] setPartySearchSettingsAddressRev;         private byte[] setPartySearchSettingsPkt = new byte[]          {              0x3F, 0x00,                 //Header             0x00,                       //jobId             0x00,                       //lvl             0x00,                       //recruit             0x00,                       //slogan             0x00, 0x00, 0x00, 0x00               };         public void setPartySearchSettings(byte jobId, byte lvl, byte recruit, byte slogan)         {             //Get size of the packet             int packetSize = setPartySearchSettingsPkt.Length;             if (setPartySearchSettingsAddress == 0)             {                 //load packet in memory                 loadPacket(setPartySearchSettingsPkt, ref setPartySearchSettingsAddress, ref setPartySearchSettingsAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, setPartySearchSettingsAddress + 2, jobId);             MemFunctions.MemWriteByte(pr_processHandle, setPartySearchSettingsAddress + 3, lvl);             MemFunctions.MemWriteByte(pr_processHandle, setPartySearchSettingsAddress + 4, recruit);             MemFunctions.MemWriteByte(pr_processHandle, setPartySearchSettingsAddress + 5, slogan);             sendPacket(setPartySearchSettingsAddressRev, packetSize);         }         //Change party captain         private int shiftPartyCaptainAddress;         private byte[] shiftPartyCaptainAddressRev;         private byte[] shiftPartyCaptainPkt = new byte[]          {              0x48, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00     //playerId         };         public void shiftPartyCaptain(int playerId)         {             //Get size of the packet             int packetSize = shiftPartyCaptainPkt.Length;             if (shiftPartyCaptainAddress == 0)             {                 //load packet in memory                 loadPacket(shiftPartyCaptainPkt, ref shiftPartyCaptainAddress, ref shiftPartyCaptainAddressRev);             }             byte[] playerIdRev = BitConverter.GetBytes(playerId);             playerIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, shiftPartyCaptainAddress + 2, playerIdRev);             sendPacket(shiftPartyCaptainAddressRev, packetSize);         }         //Use skill with no cast time         private int useSkillWithoutCastTimeAddress;         private byte[] useSkillWithoutCastTimeAddressRev;         private byte[] useSkillWithoutCastTimePkt = new byte[]          {              0x50, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //skillId             0x00, 0x01,             0x00, 0x00, 0x00, 0x00      //targetId         };         public void useSkillWithoutCastTime(int skillId, int targetId)         {             //Get size of the packet             int packetSize = useSkillWithoutCastTimePkt.Length;             if (useSkillWithoutCastTimeAddress == 0)             {                 //load packet in memory                 loadPacket(useSkillWithoutCastTimePkt, ref useSkillWithoutCastTimeAddress, ref useSkillWithoutCastTimeAddressRev);             }             byte[] skillIdRev = BitConverter.GetBytes(skillId);             skillIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, useSkillWithoutCastTimeAddress + 2, skillIdRev);             byte[] targetIdRev = BitConverter.GetBytes(targetId);             targetIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, useSkillWithoutCastTimeAddress + 8, targetIdRev);             sendPacket(useSkillWithoutCastTimeAddressRev, packetSize);         }         //Initiate setting up cat shop         private int initiateSettingUpCatShopAddress;         private byte[] initiateSettingUpCatShopAddressRev;         private byte[] initiateSettingUpCatShopPkt = new byte[]          {              0x54, 0x00,                 //Header         };         public void initiateSettingUpCatShop()         {             //Get size of the packet             int packetSize = initiateSettingUpCatShopPkt.Length;             if (initiateSettingUpCatShopAddress == 0)             {                 //load packet in memory                 loadPacket(initiateSettingUpCatShopPkt, ref initiateSettingUpCatShopAddress, ref initiateSettingUpCatShopAddressRev);             }             sendPacket(initiateSettingUpCatShopAddressRev, packetSize);         }         //Toggle fashion         private int toggleFashionDisplayAddress;         private byte[] toggleFashionDisplayAddressRev;         private byte[] toggleFashionDisplayPkt = new byte[]          {              0x55, 0x00,                 //Header         };         public void toggleFashionDisplay()         {             //Get size of the packet             int packetSize = toggleFashionDisplayPkt.Length;             if (toggleFashionDisplayAddress == 0)             {                 //load packet in memory                 loadPacket(toggleFashionDisplayPkt, ref toggleFashionDisplayAddress, ref toggleFashionDisplayAddressRev);             }             sendPacket(toggleFashionDisplayAddressRev, packetSize);         }         //acceptRessurectByCleric         private int acceptRessurectByClericAddress;         private byte[] acceptRessurectByClericAddressRev;         private byte[] acceptRessurectByClericPkt = new byte[]          {              0x57, 0x00,                 //Header         };         public void acceptRessurectByCleric()         {             //Get size of the packet             int packetSize = acceptRessurectByClericPkt.Length;             if (acceptRessurectByClericAddress == 0)             {                 //load packet in memory                 loadPacket(acceptRessurectByClericPkt, ref acceptRessurectByClericAddress, ref acceptRessurectByClericAddressRev);             }             sendPacket(acceptRessurectByClericAddressRev, packetSize);         }         //Increase fly speed         private int increaseFlySpeedAddress;         private byte[] increaseFlySpeedAddressRev;         private byte[] increaseFlySpeedPkt = new byte[]          {              0x5A, 0x00,                 //Header         };         public void increaseFlySpeed()         {             //Get size of the packet             int packetSize = increaseFlySpeedPkt.Length;             if (increaseFlySpeedAddress == 0)             {                 //load packet in memory                 loadPacket(increaseFlySpeedPkt, ref increaseFlySpeedAddress, ref increaseFlySpeedAddressRev);             }             sendPacket(increaseFlySpeedAddressRev, packetSize);         }         //Invite to duel         private int inviteToDuelAddress;         private byte[] inviteToDuelAddressRev;         private byte[] inviteToDuelPkt = new byte[]          {              0x5C, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //playerId         };         public void inviteToDuel(int playerId)         {             //Get size of the packet             int packetSize = inviteToDuelPkt.Length;             if (inviteToDuelAddress == 0)             {                 //load packet in memory                 loadPacket(inviteToDuelPkt, ref inviteToDuelAddress, ref inviteToDuelAddressRev);             }             byte[] playerIdRev = BitConverter.GetBytes(playerId);             playerIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, inviteToDuelAddress + 2, playerIdRev);             sendPacket(inviteToDuelAddressRev, packetSize);         }         //Regular Attack         private int acceptDuelAddress;         private byte[] acceptDuelAddressRev;         private byte[] acceptDuelPkt = new byte[]          {              0x5D, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //playerId         };         public void acceptDuel(int playerId)         {             //Get size of the packet             int packetSize = acceptDuelPkt.Length;             if (acceptDuelAddress == 0)             {                 //load packet in memory                 loadPacket(acceptDuelPkt, ref acceptDuelAddress, ref acceptDuelAddressRev);             }             byte[] playerIdRev = BitConverter.GetBytes(playerId);             playerIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, acceptDuelAddress + 2, playerIdRev);             sendPacket(acceptDuelAddressRev, packetSize);         }         //Ask male to carry you         private int askMaleToCarryAddress;         private byte[] askMaleToCarryAddressRev;         private byte[] askMaleToCarryPkt = new byte[]          {              0x5E, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //playerId         };         public void askMaleToCarry(int playerId)         {             //Get size of the packet             int packetSize = askMaleToCarryPkt.Length;             if (askMaleToCarryAddress == 0)             {                 //load packet in memory                 loadPacket(askMaleToCarryPkt, ref askMaleToCarryAddress, ref askMaleToCarryAddressRev);             }             byte[] playerIdRev = BitConverter.GetBytes(playerId);             playerIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, askMaleToCarryAddress + 2, playerIdRev);             sendPacket(askMaleToCarryAddressRev, packetSize);         }         //askFemaleToBeCarried         private int askFemaleToBeCarriedAddress;         private byte[] askFemaleToBeCarriedAddressRev;         private byte[] askFemaleToBeCarriedPkt = new byte[]          {              0x5F, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //playerId         };         public void askFemaleToBeCarried(int playerId)         {             //Get size of the packet             int packetSize = askFemaleToBeCarriedPkt.Length;             if (askFemaleToBeCarriedAddress == 0)             {                 //load packet in memory                 loadPacket(askFemaleToBeCarriedPkt, ref askFemaleToBeCarriedAddress, ref askFemaleToBeCarriedAddressRev);             }             byte[] playerIdRev = BitConverter.GetBytes(playerId);             playerIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, askFemaleToBeCarriedAddress + 2, playerIdRev);             sendPacket(askFemaleToBeCarriedAddressRev, packetSize);         }         //acceptRequestByFemaleToBeCarried         private int acceptRequestByFemaleToBeCarriedAddress;         private byte[] acceptRequestByFemaleToBeCarriedAddressRev;         private byte[] acceptRequestByFemaleToBeCarriedPkt = new byte[]          {              0x60, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //playerId             0x00, 0x00, 0x00, 0x00               };         public void acceptRequestByFemaleToBeCarried(int playerId)         {             //Get size of the packet             int packetSize = acceptRequestByFemaleToBeCarriedPkt.Length;             if (acceptRequestByFemaleToBeCarriedAddress == 0)             {                 //load packet in memory                 loadPacket(acceptRequestByFemaleToBeCarriedPkt, ref acceptRequestByFemaleToBeCarriedAddress, ref acceptRequestByFemaleToBeCarriedAddressRev);             }             byte[] playerIdRev = BitConverter.GetBytes(playerId);             playerIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, acceptRequestByFemaleToBeCarriedAddress + 2, playerIdRev);             sendPacket(acceptRequestByFemaleToBeCarriedAddressRev, packetSize);         }         //acceptRequestByMaleToCarryYou         private int acceptRequestByMaleToCarryYouAddress;         private byte[] acceptRequestByMaleToCarryYouAddressRev;         private byte[] acceptRequestByMaleToCarryYouPkt = new byte[]          {              0x61, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //uniqueId             0x00, 0x00, 0x00, 0x00      //typeId         };         public void acceptRequestByMaleToCarryYou(int playerId)         {             //Get size of the packet             int packetSize = acceptRequestByMaleToCarryYouPkt.Length;             if (acceptRequestByMaleToCarryYouAddress == 0)             {                 //load packet in memory                 loadPacket(acceptRequestByMaleToCarryYouPkt, ref acceptRequestByMaleToCarryYouAddress, ref acceptRequestByMaleToCarryYouAddressRev);             }             byte[] playerIdRev = BitConverter.GetBytes(playerId);             playerIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, acceptRequestByMaleToCarryYouAddress + 2, playerIdRev);             sendPacket(acceptRequestByMaleToCarryYouAddressRev, packetSize);         }         //Regular Attack         private int releaseCarryModeAddress;         private byte[] releaseCarryModeAddressRev;         private byte[] releaseCarryModePkt = new byte[]          {              0x62, 0x00,                 //Header         };         public void releaseCarryMode()         {             //Get size of the packet             int packetSize = releaseCarryModePkt.Length;             if (releaseCarryModeAddress == 0)             {                 //load packet in memory                 loadPacket(releaseCarryModePkt, ref releaseCarryModeAddress, ref releaseCarryModeAddressRev);             }             sendPacket(releaseCarryModeAddressRev, packetSize);         }         //viewPlayerEquip         private int viewPlayerEquipAddress;         private byte[] viewPlayerEquipAddressRev;         private byte[] viewPlayerEquipPkt = new byte[]          {              0x63, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //playerId         };         public void viewPlayerEquip(int playerId)         {             //Get size of the packet             int packetSize = viewPlayerEquipPkt.Length;             if (viewPlayerEquipAddress == 0)             {                 //load packet in memory                 loadPacket(viewPlayerEquipPkt, ref viewPlayerEquipAddress, ref viewPlayerEquipAddressRev);             }             byte[] playerIdRev = BitConverter.GetBytes(playerId);             playerIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, viewPlayerEquipAddress + 2, playerIdRev);             sendPacket(viewPlayerEquipAddressRev, packetSize);         }         //Regular Attack         private int summonPetAddress;         private byte[] summonPetAddressRev;         private byte[] summonPetPkt = new byte[]          {              0x64, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //petIndex         };         public void summonPet(int petIndex)         {             //Get size of the packet             int packetSize = summonPetPkt.Length;             if (summonPetAddress == 0)             {                 //load packet in memory                 loadPacket(summonPetPkt, ref summonPetAddress, ref summonPetAddressRev);             }             byte[] petIndexRev = BitConverter.GetBytes(petIndex);             petIndexRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, summonPetAddress + 2, petIndexRev);             sendPacket(summonPetAddressRev, packetSize);         }         //Regular Attack         private int recallPetAddress;         private byte[] recallPetAddressRev;         private byte[] recallPetPkt = new byte[]          {              0x65, 0x00,                 //Header         };         public void recallPet()         {             //Get size of the packet             int packetSize = recallPetPkt.Length;             if (recallPetAddress == 0)             {                 //load packet in memory                 loadPacket(recallPetPkt, ref recallPetAddress, ref recallPetAddressRev);             }             sendPacket(recallPetAddressRev, packetSize);         }           //Regular Attack         private int setPetModeAddress;         private byte[] setPetModeAddressRev;         private byte[] setPetModePkt = new byte[]          {              0x67, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,                 0x03, 0x00, 0x00, 0x00,             0x00, 0x00, 0x00, 0x00      //petMode         };         public void setPetMode(int petMode)         {             //Get size of the packet             int packetSize = setPetModePkt.Length;             if (setPetModeAddress == 0)             {                 //load packet in memory                 loadPacket(setPetModePkt, ref setPetModeAddress, ref setPetModeAddressRev);             }             byte[] petModeRev = BitConverter.GetBytes(petMode);             petModeRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, setPetModeAddress + 10, petModeRev);             sendPacket(setPetModeAddressRev, packetSize);         }         //Regular Attack         private int setPetFollowAddress;         private byte[] setPetFollowAddressRev;         private byte[] setPetFollowPkt = new byte[]          {              0x67, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,                  0x02, 0x00, 0x00, 0x00,                   0x00, 0x00, 0x00, 0x00         };         public void setPetFollow()         {             //Get size of the packet             int packetSize = setPetFollowPkt.Length;             if (setPetFollowAddress == 0)             {                 //load packet in memory                 loadPacket(setPetFollowPkt, ref setPetFollowAddress, ref setPetFollowAddressRev);             }             sendPacket(setPetFollowAddressRev, packetSize);         }                                        //Regular Attack         private int setPetStopAddress;         private byte[] setPetStopAddressRev;         private byte[] setPetStopPkt = new byte[]          {              0x67, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,                  0x02, 0x00, 0x00, 0x00,                   0x01, 0x00, 0x00, 0x00         };         public void setPetStop()         {             //Get size of the packet             int packetSize = setPetStopPkt.Length;             if (setPetStopAddress == 0)             {                 //load packet in memory                 loadPacket(setPetStopPkt, ref setPetStopAddress, ref setPetStopAddressRev);             }             sendPacket(setPetStopAddressRev, packetSize);         }         //Regular Attack         private int setPetAttackAddress;         private byte[] setPetAttackAddressRev;         private byte[] setPetAttackPkt = new byte[]          {              0x67, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //targetId             0x01,             0x00, 0x00, 0x00, 0x00               };         public void setPetAttack(int targetId)         {             //Get size of the packet             int packetSize = setPetAttackPkt.Length;             if (setPetAttackAddress == 0)             {                 //load packet in memory                 loadPacket(setPetAttackPkt, ref setPetAttackAddress, ref setPetAttackAddressRev);             }             byte[] targetIdRev = BitConverter.GetBytes(targetId);             targetIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, setPetAttackAddress + 2, targetIdRev);             sendPacket(setPetAttackAddressRev, packetSize);         }         //Regular Attack         private int setPetUseSkillAddress;         private byte[] setPetUseSkillAddressRev;         private byte[] setPetUseSkillPkt = new byte[]          {              0x67, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,     //targetId             0x04, 0x00, 0x00, 0x00,                  0x00, 0x00, 0x00, 0x00,     //skillId             0x00               };         public void setPetUseSkill(int targetId, int skillId)         {             //Get size of the packet             int packetSize = setPetUseSkillPkt.Length;             if (setPetUseSkillAddress == 0)             {                 //load packet in memory                 loadPacket(setPetUseSkillPkt, ref setPetUseSkillAddress, ref setPetUseSkillAddressRev);             }             byte[] targetIdRev = BitConverter.GetBytes(targetId);             targetIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, setPetUseSkillAddress + 2, targetIdRev);             byte[] skillIdRev = BitConverter.GetBytes(skillId);             skillIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, setPetUseSkillAddress + 10, skillIdRev);             sendPacket(setPetUseSkillAddressRev, packetSize);         }         //Regular Attack         private int setPetStandardSkillAddress;         private byte[] setPetStandardSkillAddressRev;         private byte[] setPetStandardSkillPkt = new byte[]          {              0x67, 0x00,                 //Header             0x00, 0x00, 0x00, 0x00,                  0x05, 0x00, 0x00, 0x00,             0x00, 0x00, 0x00, 0x00      //skillId         };         public void setPetStandardSkill(int skillId)         {             //Get size of the packet             int packetSize = setPetStandardSkillPkt.Length;             if (setPetStandardSkillAddress == 0)             {                 //load packet in memory                 loadPacket(setPetStandardSkillPkt, ref setPetStandardSkillAddress, ref setPetStandardSkillAddressRev);             }             byte[] skillIdRev = BitConverter.GetBytes(skillId);             skillIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, setPetStandardSkillAddress + 10, skillIdRev);             sendPacket(setPetStandardSkillAddressRev, packetSize);         }         //Regular Attack         private int useGenieSkillAddress;         private byte[] useGenieSkillAddressRev;         private byte[] useGenieSkillPkt = new byte[]          {              0x74, 0x00,                 //Header             0x00, 0x00,                 //skillId             0x00, 0x01,                  0x00, 0x00, 0x00, 0x00      //targetId         };         public void useGenieSkill(short skillId, int targetId)         {             //Get size of the packet             int packetSize = useGenieSkillPkt.Length;             if (useGenieSkillAddress == 0)             {                 //load packet in memory                 loadPacket(useGenieSkillPkt, ref useGenieSkillAddress, ref useGenieSkillAddressRev);             }             byte[] skillIdRev = BitConverter.GetBytes(skillId);             skillIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, useGenieSkillAddress + 2, skillIdRev);             byte[] targetIdRev = BitConverter.GetBytes(targetId);             targetIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, useGenieSkillAddress + 6, targetIdRev);             sendPacket(useGenieSkillAddressRev, packetSize);         }         //Regular Attack         private int feedEquippedGenieAddress;         private byte[] feedEquippedGenieAddressRev;         private byte[] feedEquippedGeniePkt = new byte[]          {              0x75, 0x00,                 //Header             0x00,                        //invIndex             0x00, 0x00, 0x00, 0x00      //amount         };         public void feedEquippedGenie(byte invIndex, int amount)         {             //Get size of the packet             int packetSize = feedEquippedGeniePkt.Length;             if (feedEquippedGenieAddress == 0)             {                 //load packet in memory                 loadPacket(feedEquippedGeniePkt, ref feedEquippedGenieAddress, ref feedEquippedGenieAddressRev);             }             MemFunctions.MemWriteByte(pr_processHandle, feedEquippedGenieAddress + 2, invIndex);             byte[] amountRev = BitConverter.GetBytes(amount);             amountRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, feedEquippedGenieAddress + 3, amountRev);             sendPacket(feedEquippedGenieAddressRev, packetSize);         }         //Regular Attack         private int acceptQuestAddress;         private byte[] acceptQuestAddressRev;         private byte[] acceptQuestPkt = new byte[]          {              0x25, 0x00,                 //Header             0x07, 0x00, 0x00, 0x00,     //npc interaction type             0x04, 0x00, 0x00, 0x00,     //nBytes following             0x00, 0x00, 0x00, 0x00      //questId         };         public void acceptQuest(int questId)         {             //Get size of the packet             int packetSize = acceptQuestPkt.Length;             if (acceptQuestAddress == 0)             {                 //load packet in memory                 loadPacket(acceptQuestPkt, ref acceptQuestAddress, ref acceptQuestAddressRev);             }             byte[] questIdRev = BitConverter.GetBytes(questId);             questIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, acceptQuestAddress + 10, questIdRev);             sendPacket(acceptQuestAddressRev, packetSize);         }         //Regular Attack         private int handInQuestAddress;         private byte[] handInQuestAddressRev;         private byte[] handInQuestPkt = new byte[]          {              0x25, 0x00,                 //Header             0x06, 0x00, 0x00, 0x00,     //npcInteractionType             0x08, 0x00, 0x00, 0x00,     //nBytes following             0x00, 0x00, 0x00, 0x00,      //questId             0x00, 0x00, 0x00, 0x00      //optionIndex         };         public void handInQuest(int questId, int optionIndex)         {             //Get size of the packet             int packetSize = handInQuestPkt.Length;             if (handInQuestAddress == 0)             {                 //load packet in memory                 loadPacket(handInQuestPkt, ref handInQuestAddress, ref handInQuestAddressRev);             }             byte[] questIdRev = BitConverter.GetBytes(questId);             questIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, handInQuestAddress + 10, questIdRev);             byte[] optionIndexRev = BitConverter.GetBytes(optionIndex);             optionIndexRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, handInQuestAddress + 14, optionIndexRev);             sendPacket(handInQuestAddressRev, packetSize);         }         //Regular Attack         private int sellSingleItemAddress;         private byte[] sellSingleItemAddressRev;         private byte[] sellSingleItemPkt = new byte[]          {              0x25, 0x00,                 //Header             0x02, 0x00, 0x00, 0x00,     //npcInteraction type             0x10, 0x00, 0x00, 0x00,      //nBytes following             0x01, 0x00, 0x00, 0x00,      //nItems Sold             0x00, 0x00, 0x00, 0x00,      //typeId             0x00, 0x00, 0x00, 0x00,      //invIndex             0x00, 0x00, 0x00, 0x00      //amount         };         public void sellSingleItem(int typeId, int invIndex, int amount)         {             //Get size of the packet             int packetSize = sellSingleItemPkt.Length;             if (sellSingleItemAddress == 0)             {                 //load packet in memory                 loadPacket(sellSingleItemPkt, ref sellSingleItemAddress, ref sellSingleItemAddressRev);             }             byte[] typeIdRev = BitConverter.GetBytes(typeId);             typeIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, sellSingleItemAddress + 14, typeIdRev);             byte[] invIndexRev = BitConverter.GetBytes(invIndex);             invIndexRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, sellSingleItemAddress + 18, invIndexRev);             byte[] amountRev = BitConverter.GetBytes(amount);             amountRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, sellSingleItemAddress + 22, amountRev);             sendPacket(sellSingleItemAddressRev, packetSize);         }         //Regular Attack         private int buySingleItemAddress;         private byte[] buySingleItemAddressRev;         private byte[] buySingleItemPkt = new byte[]          {              0x25, 0x00,                 //Header             0x01, 0x00, 0x00, 0x00,     //npcInteraction type             0x14, 0x00, 0x00, 0x00,      //nBytes following             0x00, 0x00, 0x00, 0x00,             0x01, 0x00, 0x00, 0x00,      //nItems Sold             0x00, 0x00, 0x00, 0x00,      //typeId             0x00, 0x00, 0x00, 0x00,      //shopIndex             0x00, 0x00, 0x00, 0x00      //amount         };         public void buySingleItem(int typeId, int shopIndex, int amount)         {             //Get size of the packet             int packetSize = buySingleItemPkt.Length;             if (buySingleItemAddress == 0)             {                 //load packet in memory                 loadPacket(buySingleItemPkt, ref buySingleItemAddress, ref buySingleItemAddressRev);             }             byte[] typeIdRev = BitConverter.GetBytes(typeId);             typeIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, buySingleItemAddress + 18, typeIdRev);             byte[] shopIndexRev = BitConverter.GetBytes(shopIndex);             shopIndexRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, buySingleItemAddress + 22, shopIndexRev);             byte[] amountRev = BitConverter.GetBytes(amount);             amountRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, buySingleItemAddress + 26, amountRev);             sendPacket(buySingleItemAddressRev, packetSize);         }         //Regular Attack         private int repairAllAddress;         private byte[] repairAllAddressRev;         private byte[] repairAllPkt = new byte[]          {              0x25, 0x00,                 //Header             0x03, 0x00, 0x00, 0x00,     //npc interaction type             0x06, 0x00, 0x00, 0x00,     //nBytes following             0xFF, 0xFF, 0xFF, 0xFF,      //typeId             0x00, 0x00         };         public void repairAll()         {             //Get size of the packet             int packetSize = repairAllPkt.Length;             if (repairAllAddress == 0)             {                 //load packet in memory                 loadPacket(repairAllPkt, ref repairAllAddress, ref repairAllAddressRev);             }             sendPacket(repairAllAddressRev, packetSize);         }         //Regular Attack         private int repairItemAddress;         private byte[] repairItemAddressRev;         private byte[] repairItemPkt = new byte[]          {              0x25, 0x00,                 //Header             0x03, 0x00, 0x00, 0x00,     //npc interaction type             0x06, 0x00, 0x00, 0x00,     //nBytes following             0xFF, 0xFF, 0xFF, 0xFF,      //typeId             0x00,                       //isEquipped             0x00                        //locationIndex         };         public void repairItem(int typeId, byte isEquipped, byte locationIndex)         {             //Get size of the packet             int packetSize = repairItemPkt.Length;             if (repairItemAddress == 0)             {                 //load packet in memory                 loadPacket(repairItemPkt, ref repairItemAddress, ref repairItemAddressRev);             }             byte[] typeIdRev = BitConverter.GetBytes(typeId);             typeIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, repairItemAddress + 10, typeIdRev);             MemFunctions.MemWriteByte(pr_processHandle, repairItemAddress + 14, isEquipped);             MemFunctions.MemWriteByte(pr_processHandle, repairItemAddress + 15, locationIndex);             sendPacket(repairItemAddressRev, packetSize);         }         //Regular Attack         private int upgradeSkillAddress;         private byte[] upgradeSkillAddressRev;         private byte[] upgradeSkillPkt = new byte[]          {              0x25, 0x00,                 //Header             0x09, 0x00, 0x00, 0x00,     //npc interaction type             0x04, 0x00, 0x00, 0x00,     //nBytes following             0x00, 0x00, 0x00, 0x00,      //skillId         };         public void upgradeSkill(int skillId)         {             //Get size of the packet             int packetSize = upgradeSkillPkt.Length;             if (upgradeSkillAddress == 0)             {                 //load packet in memory                 loadPacket(upgradeSkillPkt, ref upgradeSkillAddress, ref upgradeSkillAddressRev);             }             byte[] skillIdRev = BitConverter.GetBytes(skillId);             skillIdRev.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, upgradeSkillAddress + 10, skillIdRev);             sendPacket(upgradeSkillAddressRev, packetSize);         }         //opcode for sending a packet         private byte[] sendPacketOpcode = new byte[]          {              0x60,                                   //PUSHAD             0xB8, 0x00, 0x00, 0x00, 0x00,           //MOV EAX, SendPacketAddress             0x8B, 0x0D, 0x00, 0x00, 0x00, 0x00,     //MOV ECX, DWORD PTR [realBaseAddress]             0x8B, 0x49, 0x20,                       //MOV ECX, DWORD PTR [ECX+20]             0xBF, 0x00, 0x00, 0x00, 0x00,           //MOV EDI, packetAddress             0x6A, 0x00,                             //PUSH packetSize             0x57,                                   //PUSH EDI             0xFF, 0xD0,                             //CALL EAX             0x61,                                   //POPAD             0xC3                                    //RET         };         //======================//         //   Memory Addresses   //         //======================//         //Main addresses         private int packetAddressLocation;         private int packetSizeAddress;         private int sendPacketOpcodeAddress;         //Constructor         public PacketSender(IntPtr processHandle)         {             pr_processHandle = processHandle;         }         //Deselect Target         private int deselectTargetAddress;         private byte[] deselectTargetAddressRev;         private byte[] deselectTargetPkt = new byte[]          {              0x08, 0x00                  //Header         };         public void deselectTarget()         {             //Get size of the packet             int packetSize = deselectTargetPkt.Length;             if (deselectTargetAddress == 0)             {                 //load packet in memory                 loadPacket(deselectTargetPkt, ref deselectTargetAddress, ref deselectTargetAddressRev);             }             sendPacket(deselectTargetAddressRev, packetSize);         }         private void loadSendPacketOpcode()         {             //Allocate memory for the opcode to call the sendPacket function             sendPacketOpcodeAddress = MemFunctions.AllocateMemory(pr_processHandle, sendPacketOpcode.Length);             //Write the opcode to memory             MemFunctions.MemWriteBytes(pr_processHandle, sendPacketOpcodeAddress, sendPacketOpcode);             //Insert the reverse baseAddress and sendPacketFunctionAddress in opcode             byte[] functionAddress = BitConverter.GetBytes(SEND_PACKET_ADDRESS);             functionAddress.Reverse();             byte[] realBaseAddress = BitConverter.GetBytes(REAL_BASE_ADDRESS);             realBaseAddress.Reverse();             MemFunctions.MemWriteBytes(pr_processHandle, sendPacketOpcodeAddress + 2, functionAddress);             MemFunctions.MemWriteBytes(pr_processHandle, sendPacketOpcodeAddress + 8, realBaseAddress);             packetAddressLocation = sendPacketOpcodeAddress + 16;             packetSizeAddress = sendPacketOpcodeAddress + 21;         }         public void sendPacket(byte[] packetLocation, int packetSize)         {             if (sendPacketOpcodeAddress == 0)             {                 loadSendPacketOpcode();             }             MemFunctions.MemWriteBytes(pr_processHandle, packetAddressLocation, packetLocation);             MemFunctions.MemWriteByte(pr_processHandle, packetSizeAddress, (byte)packetSize);             //Run the opcode             IntPtr threadHandle = MemFunctions.CreateRemoteThread(pr_processHandle, sendPacketOpcodeAddress);             //Wait for opcode to be done             MemFunctions.WaitForSingleObject(threadHandle);             //Close the thread             MemFunctions.CloseProcess(threadHandle);         }         private void loadPacket(byte[] packet, ref int packetAddress, ref byte[] packetAddressRev)         {             //load packet in memory             //Allocate memory to store packet             packetAddress = MemFunctions.AllocateMemory(pr_processHandle, packet.Length);               //Write packet to allocated memory             MemFunctions.MemWriteBytes(pr_processHandle, packetAddress, packet);             packetAddressRev = BitConverter.GetBytes(packetAddress);                          packetAddressRev.Reverse();         }         ~PacketSender()         {             //Free memory for the packets stored in memory             if(packetAddressLocation != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, packetAddressLocation);             }             if(packetSizeAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, packetSizeAddress);             }             if(sendPacketOpcodeAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, sendPacketOpcodeAddress);             }             if (deselectTargetAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, deselectTargetAddress);             }             if (this.acceptDuelAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, acceptDuelAddress);             }             if (this.acceptPartyInviteAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, acceptPartyInviteAddress);             }             if (this.acceptQuestAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, acceptQuestAddress);             }             if (this.acceptRequestByFemaleToBeCarriedAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, acceptRequestByFemaleToBeCarriedAddress);             }             if (this.acceptRequestByMaleToCarryYouAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, acceptRequestByMaleToCarryYouAddress);             }             if (this.acceptRessurectByClericAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, acceptRessurectByClericAddress);             }             if (this.askFemaleToBeCarriedAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, askFemaleToBeCarriedAddress);             }             if (this.askMaleToCarryAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, askMaleToCarryAddress);             }             if (this.beIntimateAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, beIntimateAddress);             }             if (this.buySingleItemAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, buySingleItemAddress);             }             if (this.cancelActionAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, cancelActionAddress);             }             if (this.dropGoldAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, dropGoldAddress);             }             if (this.dropItemAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, dropItemAddress);             }             if (this.evictFromPartyAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, evictFromPartyAddress);             }             if (this.feedEquippedGenieAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, feedEquippedGenieAddress);             }             if (this.handInQuestAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, handInQuestAddress);             }             if (this.harvestResourceAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, harvestResourceAddress);             }             if (this.increaseFlySpeedAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, increaseFlySpeedAddress);             }             if (this.increaseStatsByAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, increaseStatsByAddress);             }             if (this.increaseStatsByAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, increaseStatsByAddress);             }             if (this.initiateSettingUpCatShopAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, initiateSettingUpCatShopAddress);             }             if (this.invitePartyAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, invitePartyAddress);             }             if (this.inviteToDuelAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, inviteToDuelAddress);             }             if (this.leavePartyAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, leavePartyAddress);             }             if (this.logOutAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, logOutAddress);             }             if (this.pickUpItemAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, pickUpItemAddress);             }             if (this.recallPetAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, recallPetAddress);             }             if (this.refusePartyInviteAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, refusePartyInviteAddress);             }             if (this.regularAttackAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, regularAttackAddress);             }             if (this.releaseCarryModeAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, releaseCarryModeAddress);             }             if (this.repairAllAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, repairAllAddress);             }             if (this.repairItemAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, repairItemAddress);             }             if (this.resurrectToTownAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, resurrectToTownAddress);             }             if (this.resurrectWithScrollAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, resurrectWithScrollAddress);             }             if (this.selectAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, selectAddress);             }             if (this.sellSingleItemAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, sellSingleItemAddress);             }             if (this.setPartySearchSettingsAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, setPartySearchSettingsAddress);             }             if (this.setPetAttackAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, setPetAttackAddress);             }             if (this.setPetFollowAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, setPetFollowAddress);             }             if (this.setPetModeAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, setPetModeAddress);             }             if (this.setPetStandardSkillAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, setPetStandardSkillAddress);             }             if (this.setPetStopAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, setPetStopAddress);             }             if (this.setPetUseSkillAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, setPetUseSkillAddress);             }             if (this.shiftPartyCaptainAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, shiftPartyCaptainAddress);             }             if (this.splitStackItemInBankAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, splitStackItemInBankAddress);             }             if (this.splitStackItemInBankToInvAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, splitStackItemInBankToInvAddress);             }             if (this.splitStackItemInInvAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, splitStackItemInInvAddress);             }             if (this.splitStackItemInInvToBankAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, splitStackItemInInvToBankAddress);             }             if (this.startMeditatingAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, startMeditatingAddress);             }             if (this.startNpcDialogueAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, startNpcDialogueAddress);             }             if (this.stopMeditatingAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, stopMeditatingAddress);             }             if (this.summonPetAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, summonPetAddress);             }             if (this.swapEquipWithInvAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, swapEquipWithInvAddress);             }             if (this.swapItemBankAndInvAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, swapItemBankAndInvAddress);             }             if (this.swapItemInBankAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, swapItemInBankAddress);             }             if (this.swapItemInEquipAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, swapItemInEquipAddress);             }             if (this.swapItemInInvAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, swapItemInInvAddress);             }             if (this.toggleFashionDisplayAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, toggleFashionDisplayAddress);             }             if (this.updateInvPositionAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, updateInvPositionAddress);             }             if (this.updateStatsAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, updateStatsAddress);             }             if (this.upgradeSkillAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, upgradeSkillAddress);             }             if (this.useEmotionAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, useEmotionAddress);             }             if (this.useGenieSkillAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, useGenieSkillAddress);             }             if (this.useItemAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, useItemAddress);             }             if (this.useSkillddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, useSkillddress);             }             if (this.useSkillWithoutCastTimeAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, useSkillWithoutCastTimeAddress);             }             if (this.viewPlayerEquipAddress != 0)             {                 MemFunctions.FreeMemory(pr_processHandle, viewPlayerEquipAddress);             }                      }     } }  use as follows: PHP Code: //open process IntPtr pr_processHandle = MemFunctions.OpenProcess(pid); //create new packetSender class for this process PacketSender sendPacket = new PacketSender(pr_processHandle); //send packet for toggling flymode for example: sendPacket.useItem(1, 0xC, player.values.flyMountId);  Memfunctions class:  Spoiler PHP Code: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Runtime.InteropServices; using System.Diagnostics; public class MemFunctions {     public delegate int ThreadProc(IntPtr param);     public enum EncodingType     {         ASCII,         Unicode,         UTF7,         UTF8     }     [Flags]     public enum FreeType     {         Decommit = 0x4000,         Release = 0x8000,     }     const UInt32 INFINITE = 0xFFFFFFFF;     const UInt32 WAIT_ABANDONED = 0x00000080;     const UInt32 WAIT_OBJECT_0 = 0x00000000;     const UInt32 WAIT_TIMEOUT = 0x00000102;     [DllImport("kernel32.dll")]     private static extern IntPtr OpenProcess(         UInt32 dwDesiredAccess,         Int32 bInheritHandle,         UInt32 dwProcessId         );     [DllImport("Kernel32.dll")]     private static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress,          byte[] lpBuffer, UInt32 nSize, ref UInt32 lpNumberOfBytesRead);     [DllImport("kernel32.dll")]     private static extern Int32 CloseHandle(         IntPtr hObject         );     [DllImport("kernel32.dll")]     private static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress,             byte[] lpBuffer, UInt32 nSize, ref UInt32 lpNumberOfBytesWritten);     [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]     private static extern bool VirtualFreeEx(IntPtr hProcess, IntPtr lpAddress,        int dwSize, FreeType dwFreeType);     [DllImport("kernel32.dll", SetLastError = true)]     private static extern UInt32 WaitForSingleObject(IntPtr hHandle, UInt32 dwMilliseconds);     [DllImport("kernel32.dll")]     private static extern IntPtr CreateRemoteThread(IntPtr hProcess,        IntPtr lpThreadAttributes, uint dwStackSize, IntPtr        lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);     [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]     private static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress,        uint dwSize, UInt32 flAllocationType, UInt32 flProtect);     public static int AllocateMemory(IntPtr processHandle, int memorySize)     {         return (int)VirtualAllocEx(processHandle, (IntPtr)0, (uint)memorySize, 0x1000, 0x40);     }     public static IntPtr CreateRemoteThread(IntPtr processHandle, int address)     {         return CreateRemoteThread(processHandle, (IntPtr)0, 0, (IntPtr)address, (IntPtr)0, 0, (IntPtr)0);     }     public static void WaitForSingleObject(IntPtr threadHandle)     {         if (WaitForSingleObject(threadHandle, INFINITE) != WAIT_OBJECT_0)         {             Debug.WriteLine("Failed waiting for single object");         }     }     public static void FreeMemory(IntPtr processHandle, int address)     {         bool result;         result = VirtualFreeEx(processHandle, (IntPtr)address, 0, FreeType.Release);     }     public static IntPtr OpenProcess(int pId)     {         return OpenProcess(2035711, 0, (UInt32)pId);     }     public static void CloseProcess(IntPtr handle)     {         Int32 result = CloseHandle(handle);     }     public static void MemWriteBytes(IntPtr processHandle, int address, byte[] value)     {         bool success;         UInt32 nBytesRead = 0;         success = WriteProcessMemory(processHandle, (IntPtr)address, value, (uint)value.Length, ref nBytesRead);     }     public static void MemWriteStruct(IntPtr processHandle, int address, object value)     {         bool success;         byte[] buffer = RawSerialize(value);         UInt32 nBytesRead = 0;         success = WriteProcessMemory(processHandle, (IntPtr)address, buffer, (uint)buffer.Length, ref nBytesRead);     }     public static void MemWriteInt(IntPtr processHandle, int address, int value)     {         bool success;         byte[] buffer = BitConverter.GetBytes(value);         UInt32 nBytesRead = 0;         success = WriteProcessMemory(processHandle, (IntPtr)address, buffer, 4, ref nBytesRead);     }     public static void MemWriteFloat(IntPtr processHandle, int address, float value)     {         bool success;         byte[] buffer = BitConverter.GetBytes(value);         UInt32 nBytesRead = 0;         success = WriteProcessMemory(processHandle, (IntPtr)address, buffer, 4, ref nBytesRead);     }     public static void MemWriteShort(IntPtr processHandle, int address, short value)     {         bool success;         byte[] buffer = BitConverter.GetBytes(value);         UInt32 nBytesRead = 0;         success = WriteProcessMemory(processHandle, (IntPtr)address, buffer, 2, ref nBytesRead);     }     public static void MemWriteByte(IntPtr processHandle, int address, byte value)     {         bool success;         byte[] buffer = BitConverter.GetBytes(value);         UInt32 nBytesRead = 0;         success = WriteProcessMemory(processHandle, (IntPtr)address, buffer, 1, ref nBytesRead);     }     public static byte[] MemReadBytes(IntPtr processHandle, int address, int size)     {         bool success;         byte[] buffer = new byte[size];         UInt32 nBytesRead = 0;         success = ReadProcessMemory(processHandle, (IntPtr)address, buffer, (uint)size, ref nBytesRead);         return buffer;     }     public static int MemReadInt(IntPtr processHandle, int address)     {         bool success;         byte[] buffer = new byte[4];         UInt32 nBytesRead = 0;         success = ReadProcessMemory(processHandle, (IntPtr)address, buffer, 4, ref nBytesRead);         return BitConverter.ToInt32(buffer, 0);     }     public static uint MemReadUInt(IntPtr processHandle, int address)     {         bool success;         byte[] buffer = new byte[4];         UInt32 nBytesRead = 0;         success = ReadProcessMemory(processHandle, (IntPtr)address, buffer, 4, ref nBytesRead);         return BitConverter.ToUInt32(buffer, 0);     }     public static float MemReadFloat(IntPtr processHandle, int address)     {         bool success;         byte[] buffer = new byte[4];         UInt32 nBytesRead = 0;         success = ReadProcessMemory(processHandle, (IntPtr)address, buffer, 4, ref nBytesRead);         return BitConverter.ToSingle(buffer, 0);     }     public static string MemReadUnicode(IntPtr processHandle, int address)     {         bool success;         byte[] buffer = new byte[400];         UInt32 nBytesRead = 0;         success = ReadProcessMemory(processHandle, (IntPtr)address, buffer, 400, ref nBytesRead);         return ByteArrayToString(buffer, EncodingType.Unicode);     }     public static object MemReadStruct(IntPtr processHandle, int address, Type anyType)     {         int rawsize = Marshal.SizeOf(anyType);         bool success;         byte[] buffer = new byte[rawsize];         UInt32 nBytesRead = 0;         success = ReadProcessMemory(processHandle, (IntPtr)address, buffer, (UInt32)rawsize, ref nBytesRead);         return RawDeserialize(buffer, 0, anyType);     }     private static object RawDeserialize(byte[] rawData, int position, Type anyType)     {         int rawsize = Marshal.SizeOf(anyType);         if (rawsize > rawData.Length)             return null;         IntPtr buffer = Marshal.AllocHGlobal(rawsize);         Marshal.Copy(rawData, position, buffer, rawsize);         object retobj = Marshal.PtrToStructure(buffer, anyType);         Marshal.FreeHGlobal(buffer);         return retobj;     }     private static byte[] RawSerialize(object anything)     {         int rawSize = Marshal.SizeOf(anything);         IntPtr buffer = Marshal.AllocHGlobal(rawSize);         Marshal.StructureToPtr(anything, buffer, false);         byte[] rawDatas = new byte[rawSize];         Marshal.Copy(buffer, rawDatas, 0, rawSize);         Marshal.FreeHGlobal(buffer);         return rawDatas;     }     private static string ByteArrayToString(byte[] bytes)     {         return ByteArrayToString(bytes, EncodingType.Unicode);     }     private static string ByteArrayToString(byte[] bytes, EncodingType encodingType)     {         System.Text.Encoding encoding = null;         string result = "";         switch (encodingType)         {             case EncodingType.ASCII:                 encoding = new System.Text.ASCIIEncoding();                 break;             case EncodingType.Unicode:                 encoding = new System.Text.UnicodeEncoding();                 break;             case EncodingType.UTF7:                 encoding = new System.Text.UTF7Encoding();                 break;             case EncodingType.UTF8:                 encoding = new System.Text.UTF8Encoding();                 break;         }         for (int i = 0; i < bytes.Length; i += 2)         {             if (bytes[i] == 0 && bytes[i + 1] == 0)             {                 result = encoding.GetString(bytes, 0, i);                 break;             }         }         return result;     }     private static byte[] StringToByteArray(string str, EncodingType encodingType)     {         System.Text.Encoding encoding = null;         switch (encodingType)         {             case EncodingType.ASCII:                 encoding = new System.Text.ASCIIEncoding();                 break;             case EncodingType.Unicode:                 encoding = new System.Text.UnicodeEncoding();                 break;             case EncodingType.UTF7:                 encoding = new System.Text.UTF7Encoding();                 break;             case EncodingType.UTF8:                 encoding = new System.Text.UTF8Encoding();                 break;         }         return encoding.GetBytes(str);     }  }

i used these classes for test and my pw got crash (not report bug, just terminate process) PS: i changed real base and send packet address.
can someone help me?
------------------------
i discovered the problem is in createremotethread. when the debugger execute the createremotethread line pw get crashes.
But i don't know what is the solution
------------------------
Sorry for noob quests. I think I found the problem. I use the pwbr and i think the problem is in opcode. i wanna know how to find de sendpacketopcodeaddress for my pw... can someone help me? :D
thanks in advance