hash/plugy
1
0
Fork 0
mirror of https://gitlab.com/hashborgir/plugy.git synced 2024-11-30 04:26:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

updated to v11.00 by Lautour http://d2mods.info/forum/viewtopic.php?f=133&t=62849

Browse Source
This commit is contained in:
ChaosMarc 2016-04-18 11:10:35 +02:00
parent 32b737d55e
commit 5a1eb33f03
56 changed files with 5670 additions and 960 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

326
Commons/D2Funcs.h
View File

@ -1,5 +1,6 @@
/*======================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Declares the type for a STDCALL or FASTCALL function pointer
called N with arguments list P, returning R, namedInDLL D and at @A
@ -148,68 +149,68 @@
//F7(STD, D2Common,00000,00000,00000,00000,10001,00000,00000, DWORD, D2GetActIDFromLevel, (DWORD levelID));
F7(STD, D2Common,00000,00000,00000,10188,11084,11109,10346, DWORD, D2Common11084, (Room* ptRoom, DWORD zero));
F7(STD, D2Common,10057,10057,10057,10332,11021,10511,10826, DWORD, D2GetLevelID, (Room* ptRoom));
F7(STD, D2Common,10138,10138,10138,10623,10491,11043,10654, Room*, D2GetDropRoom, (Room* ptRoom, Position*, Position*, DWORD, DWORD, DWORD, DWORD));
F7(STD, D2Common,00000,00000,00000,10188,11084,11109,10346,10907, DWORD, D2Common11084, (Room* ptRoom, DWORD zero));
F7(STD, D2Common,10057,10057,10057,10332,11021,10511,10826,10691, DWORD, D2GetLevelID, (Room* ptRoom));
F7(STD, D2Common,10138,10138,10138,10623,10491,11043,10654,10716, Room*, D2GetDropRoom, (Room* ptRoom, Position*, Position*, DWORD, DWORD, DWORD, DWORD));
//F7(STD, D2Common,10149,10149,10149,00000,00000,00000,00000, Inventory*, D2GetInventory, (Unit* ptUnit));
F7(STD, D2Common,10242,10242,10242,00000,00000,00000,00000, Unit*, D2Common10242, (Inventory* ptInventory, Unit* ptItem, DWORD bIsClient));
F7(STD, D2Common,10246,10246,10246,10855,10813,10289,10133, Unit*, D2CanPutItemInInv, (Inventory* ptInventory, Unit* ptItem, DWORD p3, DWORD zero, Unit* ptUnit, const char* file, DWORD line));
F7(STD, D2Common,10243,10243,10243,10461,10827,10936,10646, Unit*, D2InvRemoveItem, (Inventory* ptInventory, Unit* ptItem));
F7(STD, D2Common,10249,10249,10249,10880,11068,10436,11107, DWORD, D2InvAddItem, (Inventory* ptInventory, Unit* ptItem, DWORD posX, DWORD posY, DWORD vValueC, DWORD bIsClient, BYTE page));//result : boolean 0=echec ; vValueC = 0 for Game.dll, 1 for Clientdll
F7(STD, D2Common,10250,10250,10250,00000,00000,00000,00000, DWORD, D2Common10250, (const char* file, DWORD line, Inventory* ptInventory, DWORD posX, DWORD posY, DWORD vValueC, DWORD bIsClient, BYTE page));// result : boolean 0=echec ; vValueC = 0 for Game.dll, 1 for Clientdll
F7(STD, D2Common,10242,10242,10242,00000,00000,00000,00000,00000, Unit*, D2Common10242, (Inventory* ptInventory, Unit* ptItem, DWORD bIsClient));
F7(STD, D2Common,10246,10246,10246,10855,10813,10289,10133,10402, Unit*, D2CanPutItemInInv, (Inventory* ptInventory, Unit* ptItem, DWORD p3, DWORD zero, Unit* ptUnit, const char* file, DWORD line));
F7(STD, D2Common,10243,10243,10243,10461,10827,10936,10646,10490, Unit*, D2InvRemoveItem, (Inventory* ptInventory, Unit* ptItem));
F7(STD, D2Common,10249,10249,10249,10880,11068,10436,11107,10963, DWORD, D2InvAddItem, (Inventory* ptInventory, Unit* ptItem, DWORD posX, DWORD posY, DWORD vValueC, DWORD bIsClient, BYTE page));//result : boolean 0=echec ; vValueC = 0 for Game.dll, 1 for Clientdll
F7(STD, D2Common,10250,10250,10250,00000,00000,00000,00000,00000, DWORD, D2Common10250, (const char* file, DWORD line, Inventory* ptInventory, DWORD posX, DWORD posY, DWORD vValueC, DWORD bIsClient, BYTE page));// result : boolean 0=echec ; vValueC = 0 for Game.dll, 1 for Clientdll
//F7(STD, D2Common,10257,10257,10257,00000,00000,00000,00000, Unit*, D2GetItemFromBodyLoc, (Inventory* ptInventory, DWORD bodyloc));
F7(STD, D2Common,10273,10273,10273,00000,00000,00000,00000, DWORD, D2Common10273, (Inventory* ptInventory, void* unknow));
F7(STD, D2Common,10277,10277,10277,10402,10535,11151,10460, Unit*, D2InventoryGetFirstItem, (Inventory* ptInventory));
F7(STD, D2Common,10304,10304,10304,10934,11140,10770,10464, Unit*, D2UnitGetNextItem, (Unit* ptItem));
F7(STD, D2Common,10305,10305,10305,11095,10748,10852,11147, Unit*, D2GetRealItem, (Unit* ptUnit));
F7(STD, D2Common,10273,10273,10273,00000,00000,00000,00000,00000, DWORD, D2Common10273, (Inventory* ptInventory, void* unknow));
F7(STD, D2Common,10277,10277,10277,10402,10535,11151,10460,11040, Unit*, D2InventoryGetFirstItem, (Inventory* ptInventory));
F7(STD, D2Common,10304,10304,10304,10934,11140,10770,10464,10879, Unit*, D2UnitGetNextItem, (Unit* ptItem));
F7(STD, D2Common,10305,10305,10305,11095,10748,10852,11147,10897, Unit*, D2GetRealItem, (Unit* ptUnit));
//F7(STD, D2Common,10321,10321,10321,00000,00000,00000,00000, SkillData*, D2GetLeftSkill, (Unit* ptChar));
//F7(STD, D2Common,10322,10322,10322,00000,00000,00000,00000, SkillData*, D2GetRightSkill, (Unit* ptChar));
F7(STD, D2Common,10326,10326,00000,00000,00000,00000,00000, DWORD, D2GetPosX, (Unit* ptUnit));//NOT IN 1.10
F7(STD, D2Common,10326,10326,00000,00000,00000,00000,00000,00000, DWORD, D2GetPosX, (Unit* ptUnit));//NOT IN 1.10
//F7(STD, D2Common,10328,10328,10328,00000,00000,00000,00000, void, D2SetPosX, (Unit* ptUnit, DWORD pos));
F7(STD, D2Common,10329,10329,00000,00000,00000,00000,00000, DWORD, D2GetPosY, (Unit* ptUnit));//NOT IN 1.10
F7(STD, D2Common,10329,10329,00000,00000,00000,00000,00000,00000, DWORD, D2GetPosY, (Unit* ptUnit));//NOT IN 1.10
//F7(STD, D2Common,10331,10331,10331,00000,00000,00000,00000, void, D2SetPosY, (Unit* ptUnit, DWORD pos));
F7(STD, D2Common,10332,10332,10332,11080,10056,10543,10141, void, D2GetPosition, (Unit* ptUnit, Position* pos));
F7(STD, D2Common,10339,10339,10339,10455,10864,10941,11060, DWORD, D2GetMaxGoldBank, (Unit* ptUnit));
F7(STD, D2Common,10342,10342,10342,10172,10933,10366,10331, Room*, D2GetRoom, (Unit* ptUnit));
F7(STD, D2Common,10332,10332,10332,11080,10056,10543,10141,11166, void, D2GetPosition, (Unit* ptUnit, Position* pos));
F7(STD, D2Common,10339,10339,10339,10455,10864,10941,11060,11025, DWORD, D2GetMaxGoldBank, (Unit* ptUnit));
F7(STD, D2Common,10342,10342,10342,10172,10933,10366,10331,10846, Room*, D2GetRoom, (Unit* ptUnit));
//F7(STD, D2Common,10348,10348,10348,00000,00000,00000,00000, void, D2SetUnitMode, (Unit* ptUnit, DWORD mode));
//F7(STD, D2Common,10394,10394,10394,00000,00000,00000,00000, ObjectsBIN*,D2GetObjectsBIN, (Unit* ptObject));
F7(STD, D2Common,10420,10420,10420,10218,10079,11097,10356, PlayerData*,D2InitPlayerData, (Unit* ptChar));
F7(STD, D2Common,10420,10420,10420,10218,10079,11097,10356,10404, PlayerData*,D2InitPlayerData, (Unit* ptChar));
//F7(STD, D2Common,10421,10421,10421,10914,10329,00000,00000, DWORD, D2FreePlayerData, (DWORD game1C, Unit* ptChar));
F7(STD, D2Common,10424,10424,10424,10562,10800,10860,10920, PlayerData*,D2GetPlayerData, (Unit* ptChar));
F7(STD, D2Common,10431,10431,10431,00000,00000,00000,00000, DWORD, D2GetDefence, (Unit* ptChar));
F7(STD, D2Common,10433,10433,10433,00000,00000,00000,00000, DWORD, D2GetChanceToBlock, (Unit* ptChar, DWORD isLODGame));
F7(STD, D2Common,10439,10439,10439,10343,11131,10729,10049, DWORD, D2GetMaxGold, (Unit* ptUnit));
F7(STD, D2Common,00000,00000,00000,10440,10572,10481,11090, DWORD, D2Common10572, (Unit* ptObject, DWORD value));
F7(STD, D2Common,10424,10424,10424,10562,10800,10860,10920,11103, PlayerData*,D2GetPlayerData, (Unit* ptChar));
F7(STD, D2Common,10431,10431,10431,00000,00000,00000,00000,00000, DWORD, D2GetDefence, (Unit* ptChar));
F7(STD, D2Common,10433,10433,10433,00000,00000,00000,00000,00000, DWORD, D2GetChanceToBlock, (Unit* ptChar, DWORD isLODGame));
F7(STD, D2Common,10439,10439,10439,10343,11131,10729,10049,11159, DWORD, D2GetMaxGold, (Unit* ptUnit));
F7(STD, D2Common,00000,00000,00000,10440,10572,10481,11090,10193, DWORD, D2Common10572, (Unit* ptObject, DWORD value));
//F7(STD, D2Common,10463,10463,10463,00000,00000,00000,00000, DWORD, D2SetStatWithNoTest, ( Stats* ptStats, DWORD statID, DWORD statValue, DWORD statIndex));
//F7(STD, D2Common,10464,10464,10464,00000,00000,00000,00000, void, D2AddStat, (Stats* ptStats, DWORD statID, DWORD statValue, DWORD statIndex));
//F7(STD, D2Common,10465,10465,10465,00000,00000,00000,00000, DWORD, D2SetStat, (Stats* ptStats, DWORD statID, DWORD statValue, DWORD statIndex));
//F7(STD, D2Common,10466,10466,10466,00000,00000,00000,00000, int, D2GetStat, (Stats* ptStats, DWORD statID, DWORD statIndex));
//F7(STD, D2Common,10470,10470,10470,00000,00000,00000,00000, Stats*, D2AllocNewStats, (DWORD nUnitId, DWORD flags, DWORD uk18, DWORD nUnitType, DWORD nItemNum));
F7(STD, D2Common,00000,00000,00000,10471,11160,10866,10258, BYTE, D2GetObjectFlags, (Unit* ptObject));
F7(STD, D2Common,00000,00000,00000,10572,11048,10150,10111, void, D2SetObjectFlags, (Unit* ptObject, BYTE flags));
F7(STD, D2Common,00000,00000,00000,10471,11160,10866,10258,10040, BYTE, D2GetObjectFlags, (Unit* ptObject));
F7(STD, D2Common,00000,00000,00000,10572,11048,10150,10111,10033, void, D2SetObjectFlags, (Unit* ptObject, BYTE flags));
//F7(STD, D2Common,10471,10471,10471,00000,00000,00000,00000, DWORD, D2Common10471, (void*));
//F7(STD, D2Common,10472,10472,10472,00000,00000,00000,00000, DWORD, D2Common10472, (void*));
//F7(STD, D2Common,10475,10475,10475,00000,00000,00000,00000, void, D2UpdateDisabledStat, (Stats* ptCharStats, Stats* ptStats, DWORD one));
//F7(STD, D2Common,10481,10481,10481,00000,00000,00000,00000, void*, D2Common10481, (Unit* ptUnit, DWORD flags));
//F7(STD, D2Common,10484,10484,10484,00000,00000,00000,00000, Stats*, D2GetAffixStats, (Unit* ptItem, DWORD, DWORD));
//F7(STD, D2Common,10485,10485,10485,00000,00000,00000,00000, void, D2FreeStats, (Stats* ptStats));
F7(STD, D2Common,10487,10487,10487,00000,00000,00000,00000, DWORD, D2isInState, (Unit* ptChar, DWORD isLODGame));
F7(STD, D2Common,10487,10487,10487,00000,00000,00000,00000,00000, DWORD, D2isInState, (Unit* ptChar, DWORD isLODGame));
//F7(STD, D2Common,10517,10517,10517,00000,00000,00000,00000, void, D2SetPlayerStat, (Unit* ptChar, DWORD statID, int amount, DWORD index));
F7(STD, D2Common,10518,10518,10518,10109,10627,10762,10551, void, D2AddPlayerStat, (Unit* ptChar, DWORD statID, int amount, DWORD index));//ONLY 1.11b
F7(STD, D2Common,10519,10519,10519,11092,10061,10658,10973, int, D2GetPlayerStat, (Unit* ptChar, DWORD statID, DWORD index));//ONLY 1.11b
F7(STD, D2Common,10518,10518,10518,10109,10627,10762,10551,10645, void, D2AddPlayerStat, (Unit* ptChar, DWORD statID, int amount, DWORD index));//ONLY 1.11b
F7(STD, D2Common,10519,10519,10519,11092,10061,10658,10973,10550, int, D2GetPlayerStat, (Unit* ptChar, DWORD statID, DWORD index));//ONLY 1.11b
//F7(STD, D2Common,10520,10520,10520,00000,00000,00000,00000, int, D2GetPlayerStat20, (Unit* ptChar, DWORD statID, DWORD index));
F7(STD, D2Common,10521,10521,10521,10733,10550,10494,10587, int, D2GetPlayerBaseStat, (Unit* ptChar, DWORD statID, DWORD index));//ONLY 1.11b
F7(STD, D2Common,10521,10521,10521,10733,10550,10494,10587,10216, int, D2GetPlayerBaseStat, (Unit* ptChar, DWORD statID, DWORD index));//ONLY 1.11b
//F7(STD, D2Common,10527,10527,10527,00000,00000,00000,00000, DWORD, D2Common10527, (Unit* ptUnit));
F7(STD, D2Common,10539,10539,10539,00000,00000,00000,00000, DWORD, D2haveDefenceBonus, (Unit* ptChar));
F7(STD, D2Common,10540,10540,10540,00000,00000,00000,00000, DWORD, D2haveFireResBonus, (Unit* ptChar));
F7(STD, D2Common,10541,10541,10541,00000,00000,00000,00000, DWORD, D2haveColdResBonus, (Unit* ptChar));
F7(STD, D2Common,10542,10542,10542,00000,00000,00000,00000, DWORD, D2haveLightResBonus, (Unit* ptChar));
F7(STD, D2Common,10543,10543,10543,00000,00000,00000,00000, DWORD, D2havePoisonResBonus, (Unit* ptChar));
F7(STD, D2Common,10546,10546,10546,00000,00000,00000,00000, DWORD, D2haveDefenceMalus, (Unit* ptChar));
F7(STD, D2Common,10547,10547,10547,00000,00000,00000,00000, DWORD, D2haveFireResMalus, (Unit* ptChar));
F7(STD, D2Common,10548,10548,10548,00000,00000,00000,00000, DWORD, D2haveColdResMalus, (Unit* ptChar));
F7(STD, D2Common,10549,10549,10549,00000,00000,00000,00000, DWORD, D2haveLightResMalus, (Unit* ptChar));
F7(STD, D2Common,10550,10550,10550,00000,00000,00000,00000, DWORD, D2havePoisonResMalus, (Unit* ptChar));
F7(STD, D2Common,10539,10539,10539,00000,00000,00000,00000,00000, DWORD, D2haveDefenceBonus, (Unit* ptChar));
F7(STD, D2Common,10540,10540,10540,00000,00000,00000,00000,00000, DWORD, D2haveFireResBonus, (Unit* ptChar));
F7(STD, D2Common,10541,10541,10541,00000,00000,00000,00000,00000, DWORD, D2haveColdResBonus, (Unit* ptChar));
F7(STD, D2Common,10542,10542,10542,00000,00000,00000,00000,00000, DWORD, D2haveLightResBonus, (Unit* ptChar));
F7(STD, D2Common,10543,10543,10543,00000,00000,00000,00000,00000, DWORD, D2havePoisonResBonus, (Unit* ptChar));
F7(STD, D2Common,10546,10546,10546,00000,00000,00000,00000,00000, DWORD, D2haveDefenceMalus, (Unit* ptChar));
F7(STD, D2Common,10547,10547,10547,00000,00000,00000,00000,00000, DWORD, D2haveFireResMalus, (Unit* ptChar));
F7(STD, D2Common,10548,10548,10548,00000,00000,00000,00000,00000, DWORD, D2haveColdResMalus, (Unit* ptChar));
F7(STD, D2Common,10549,10549,10549,00000,00000,00000,00000,00000, DWORD, D2haveLightResMalus, (Unit* ptChar));
F7(STD, D2Common,10550,10550,10550,00000,00000,00000,00000,00000, DWORD, D2havePoisonResMalus, (Unit* ptChar));
//F7(STD, D2Common,10552,10552,10552,00000,00000,00000,00000, DWORD, D2Common10552, (Unit* ptUnit));
//F7(STD, D2Common,10567,10567,10567,00000,00000,00000,00000, DWORD, D2CanBeBroken, (Unit* ptItem));
//F7(STD, D2Common,10573,10573,10573,00000,00000,00000,00000, void, D2CopyStats, (Stats* ptDestStats, Stats* ptSrcStats));
@ -217,35 +218,35 @@ F7(STD, D2Common,10550,10550,10550,00000,00000,00000,00000, DWORD, D2havePoiso
//F7(STD, D2Common,10575,10575,10575,00000,00000,00000,00000, void, D2FreeBinFiles, ());
//F7(STD, D2Common,10576,10576,10576,00000,00000,00000,00000, void, D2LoadBinFiles, (DWORD zero1, DWORD zero2, bool));
//F7(STD, D2Common,00000,00000,00000,10651,10651,00000,00000, DWORD, D2CheckQuestState, (void* ptQuest, DWORD index, DWORD value));
F7(STD, D2Common,10578,10578,10578,10653,10496,10244,10849, void*, D2CompileTxtFile, (DWORD unused, const char* filename, BINField* ptFields, DWORD* ptRecordCount, DWORD recordLength));
F7(STD, D2Common,10600,10600,10600,10573,10262,10887,10695, ItemsBIN*, D2GetItemsBIN, (DWORD itemID));
F7(STD, D2Common,10578,10578,10578,10653,10496,10244,10849,10037, void*, D2CompileTxtFile, (DWORD unused, const char* filename, BINField* ptFields, DWORD* ptRecordCount, DWORD recordLength));
F7(STD, D2Common,10600,10600,10600,10573,10262,10887,10695,10994, ItemsBIN*, D2GetItemsBIN, (DWORD itemID));
//F7(STD, D2Common,10601,10601,10601,00000,00000,00000,00000, ItemsBIN*, D2GetByCodeItemStatsBIN, (DWORD code, DWORD* itemID));
//F7(STD, D2Common,10604,10604,10604,00000,00000,00000,00000, AffixBIN*, D2GetAffixBIN, (int affixID));
F7(STD, D2Common,10616,10616,10616,10500,10523,10774,10806, GemsBIN*, D2GetGemsBIN, (DWORD gemID));
F7(STD, D2Common,11232,11232,11232,10746,10258,10913,10783, CubeMainBIN*,D2GetCubeMainBIN, (DWORD cubemainID));
F7(STD, D2Common,11233,11233,11233,10639,11135,10390,10675, int, D2GetNbCubeMainBIN, ());
F7(STD, D2Common,10616,10616,10616,10500,10523,10774,10806,10619, GemsBIN*, D2GetGemsBIN, (DWORD gemID));
F7(STD, D2Common,11232,11232,11232,10746,10258,10913,10783,10393, CubeMainBIN*,D2GetCubeMainBIN, (DWORD cubemainID));
F7(STD, D2Common,11233,11233,11233,10639,11135,10390,10675,10235, int, D2GetNbCubeMainBIN, ());
//F7(STD, D2Common,10737,10737,10737,00000,00000,00000,00000, LevelsBIN*, D2GetLevelsBIN, (DWORD levelID));
F7(STD, D2Common,10628,10628,10628,00000,00000,00000,00000, DWORD, D2GetNextLevelXP, (DWORD classID, DWORD level));
F7(STD, D2Common,10629,10629,10629,00000,00000,00000,00000, DWORD, D2GetMaxLevel, (DWORD classID));
F7(STD, D2Common,10655,10655,10655,10655,10309,10297,10218, DifficultyLevelsBIN*, D2GetDifficultyLevelsBIN, (DWORD difficultyLevel));
F7(STD, D2Common,10628,10628,10628,00000,00000,00000,00000,00000, DWORD, D2GetNextLevelXP, (DWORD classID, DWORD level));
F7(STD, D2Common,10629,10629,10629,00000,00000,00000,00000,00000, DWORD, D2GetMaxLevel, (DWORD classID));
F7(STD, D2Common,10655,10655,10655,10655,10309,10297,10218,10694, DifficultyLevelsBIN*, D2GetDifficultyLevelsBIN, (DWORD difficultyLevel));
//F7(STD, D2Common,10659,10659,10659,00000,00000,00000,00000, TreasureClassBIN*, D2GetTreasureClassBIN, (WORD id, DWORD uk));
//F7(STD, D2Common,10668,10668,10668,10450,10953,00000,00000, SuperUniqueBIN*, D2GetSuperUniqueBIN, (WORD id));
F7(STD, D2Common,10695,10695,10695,10927,10899,10276,10106, DWORD, D2GetItemQuality, (Unit* ptItem));
F7(STD, D2Common,10707,10707,10707,10911,10303,10989,10202, DWORD, D2TestFlags, (Unit* ptUnit, DWORD flags, DWORD line, const char* file));
F7(STD, D2Common,10695,10695,10695,10927,10899,10276,10106,10911, DWORD, D2GetItemQuality, (Unit* ptItem));
F7(STD, D2Common,10707,10707,10707,10911,10303,10989,10202,10458, DWORD, D2TestFlags, (Unit* ptUnit, DWORD flags, DWORD line, const char* file));
//F7(STD, D2Common,10708,10708,10708,00000,00000,00000,00000, void, D2SetFlags, (Unit* ptUnit, DWORD flags, DWORD bitNewValue));
//F7(STD, D2Common,10709,10709,10709,00000,00000,00000,00000, DWORD, D2GetFlags, (Unit* ptUnit));
//F7(STD, D2Common,10711,10711,10711,00000,00000,00000,00000, void, D2ItemSetFlags, (Unit* ptItem, DWORD flags, DWORD toSet));// toSet = 0 for set to 0 the selected flags else set to 1
F7(STD, D2Common,10717,10717,10717,10898,10100,10410,10086, DWORD, D2GetItemLevel, (Unit* ptItem));
F7(STD, D2Common,10719,10719,10719,10820,10505,10370,10020, BYTE, D2ItemGetPage, (Unit* ptUnit));
F7(STD, D2Common,10720,10720,10720,10485,10608,10223,10012, void, D2ItemSetPage, (Unit* ptItem, BYTE page));
F7(STD, D2Common,10731,10731,10731,11017,10890,10231,10744, DWORD, D2CheckItemType, (Unit* ptItem, DWORD itype));
F7(STD, D2Common,10732,10732,10732,10692,10685,10280,10620, int, D2GetUniqueID, (Unit* ptItem));
F7(STD, D2Common,10734,10734,10734,00000,00000,00000,00000, void, D2SetAnim, (Unit* ptUnit, int anim));
F7(STD, D2Common,10717,10717,10717,10898,10100,10410,10086,10008, DWORD, D2GetItemLevel, (Unit* ptItem));
F7(STD, D2Common,10719,10719,10719,10820,10505,10370,10020,10810, BYTE, D2ItemGetPage, (Unit* ptUnit));
F7(STD, D2Common,10720,10720,10720,10485,10608,10223,10012,11026, void, D2ItemSetPage, (Unit* ptItem, BYTE page));
F7(STD, D2Common,10731,10731,10731,11017,10890,10231,10744,10601, DWORD, D2CheckItemType, (Unit* ptItem, DWORD itype));
F7(STD, D2Common,10732,10732,10732,10692,10685,10280,10620,10075, int, D2GetUniqueID, (Unit* ptItem));
F7(STD, D2Common,10734,10734,10734,00000,00000,00000,00000,00000, void, D2SetAnim, (Unit* ptUnit, int anim));
//F7(STD, D2Common,10749,10749,10749,00000,00000,00000,00000, void, D2GetWidthHeight, (Unit* ptItem, BYTE* Width, BYTE* Height);
//F7(STD, D2Common,10751,10751,10751,00000,00000,00000,00000, DWORD, D2GetItemType, (Unit* ptUnit));
//F7(STD, D2Common,10757,10757,10757,00000,00000,00000,00000, DWORD, D2GetItemLevelReq, (Unit* ptChar, Unit* ptItem));
F7(STD, D2Common,10619,10619,10619,10687,10877,10321,11032, int*, D2GetNbRunesBIN, ());//return the point on th number
F7(STD, D2Common,10620,10620,10620,10775,10296,10622,10006, RunesBIN*, D2GetRunesBIN, (int runesID));
F7(STD, D2Common,10619,10619,10619,10687,10877,10321,11032,10981, int*, D2GetNbRunesBIN, ());//return the point on th number
F7(STD, D2Common,10620,10620,10620,10775,10296,10622,10006,10405, RunesBIN*, D2GetRunesBIN, (int runesID));
//F7(STD, D2Common,10792,10792,10792,00000,00000,00000,00000, DWORD, D2CanBeRare, (Unit* ptItem));
//F7(STD, D2Common,10810,10810,10810,00000,00000,00000,00000, BYTE, D2CheckHasInv, (Unit* ptItem));
//F7(STD, D2Common,10813,10813,10813,00000,00000,00000,00000, DWORD, D2GetStaffMods, (Unit* ptItem));
@ -254,35 +255,35 @@ F7(STD, D2Common,10620,10620,10620,10775,10296,10622,10006, RunesBIN*, D2GetRun
//F7(STD, D2Common,10855,10855,10855,00000,00000,00000,00000, void, D2AddAffix, (DWORD, DWORD, Unit* ptItem, AffixBIN* ptAffix, DWORD, DWORD));
//F7(STD, D2Common,10872,10872,10872,00000,00000,00000,00000, DWORD, D2WarpPlayer, (Path* ptPath, Unit* ptChar, Room* ptRoom, DWORD x, DWORD y));
//F7(STD, D2Common,10875,10875,10875,00000,00000,00000,00000, WORD, D2GetItemVersion, (Unit* ptItem));
F7(STD, D2Common,11163,11163,11163,10880,11068,10436,11107, DWORD, D2isEtheral, (Unit* ptItem));//ONLY UNTIL 1.10
F7(STD, D2Common,10881,10881,10881,10956,11156,10218,10987, DWORD, D2SaveItem, (Unit* ptItem, saveBitField* data, DWORD startSize, DWORD p4, DWORD p5, DWORD p6));
F7(STD, D2Common,11163,11163,11163,10880,11068,10436,11107,10963, DWORD, D2isEtheral, (Unit* ptItem));//ONLY UNTIL 1.10
F7(STD, D2Common,10881,10881,10881,10956,11156,10218,10987,10665, DWORD, D2SaveItem, (Unit* ptItem, saveBitField* data, DWORD startSize, DWORD p4, DWORD p5, DWORD p6));
//F7(STD, D2Common,10916,10916,10916,00000,00000,00000,00000, void, DoNothing916, ());
//F7(STD, D2Common,10940,10940,10940,10027,10105,10953,00000, void, D2Common10027, (Unit* ptChar, DWORD skillID));
//F7(STD, D2Common,10950,10950,10950,00000,00000,00000,00000, SkillData*, D2GetSkillPointer, (Unit* ptChar, WORD SkillID));
//F7(STD, D2Common,10952,10952,10952,10950,10256,10858,00000, SkillData*, D2IncSkillBaseLevel, (Unit* ptChar, DWORD skillID));
F7(STD, D2Common,10953,10953,10953,10099,10255,10210,10302, void, D2SetSkillBaseLevel,(Unit* ptChar, DWORD skillID, DWORD slvl, DWORD bRemove, char*, DWORD));
F7(STD, D2Common,10953,10953,10953,10099,10255,10210,10302,10335, void, D2SetSkillBaseLevel,(Unit* ptChar, DWORD skillID, DWORD slvl, DWORD bRemove, char*, DWORD));
//F7(STD, D2Common,10963,10963,10963,00000,00000,00000,00000, DWORD, D2GetSkillID, (SkillData* ptSkill, const char* file, DWORD line));
//F7(FAST, D2Common,10966,10966,10966,00000,00000,00000,00000, SkillsBIN*, D2GetSkillsBIN, (SkillData* ptSkill));
F7(STD, D2Common,10968,10968,10968,10700,10109,10904,10306, DWORD, D2GetSkillLevel, (Unit* ptChar, SkillData* ptSkill, DWORD includingBonus));
F7(STD, D2Common,10968,10968,10968,10700,10109,10904,10306,10007, DWORD, D2GetSkillLevel, (Unit* ptChar, SkillData* ptSkill, DWORD includingBonus));
//F7(STD, D2Common,11023,11023,11023,00000,00000,00000,00000, DWORD, D2GetCriticalStrikeFromMasteries, (Unit* ptChar, Unit* ptItem, DWORD zero, DWORD two));
//F7(STD, D2Common,11007,11007,11007,00000,00000,00000,00000, bool, D2TestQuestState, (void* ptQuest, DWORD QuestID, DWORD QuestState));
//F7(STD, D2Common,11041,11041,11041,00000,00000,00000,00000, int, D2GetPlayerSkillID, (DWORD playerID, DWORD skillNumber));
//F7(STD, D2Common,11042,11042,11042,00000,00000,00000,00000, int, D2GetNbSkillsPerPlayer, (DWORD playerID));
//F7(STD, D2Common,11269,11269,11269,00000,00000,00000,00000, DWORD, D2GetAllIndexFromStat, (Stats* ptStats, DWORD statID, D2Stat* allIndex, DWORD maxIndex));
//F7(STD, D2Common,11270,11270,11270,00000,00000,00000,00000, DWORD, D2GetAllIndexFromStatID, (Unit* ptItem, DWORD statID, D2Stat* allIndex, DWORD));
F7(STD, D2Common,11276,11276,11276,10254,10074,10111,10435, DWORD, D2GetSkillCost, (Unit* ptChar, int skpoints, DWORD skillID, DWORD curSkillLevel));//not 10447
A7(FAST, D2Common,00000,00000,82C80, 15D0, 1800, 1220, 12D0, CharStatsBIN*, D2GetCharStatsBIN, (DWORD charID));
A7(FAST, D2Common,00000,00000,12410,5D7D0,1A100,116C0,1C020, DWORD, D2CompileCubeInput, (CubeInput* cubeinput, char* s, DWORD p1, DWORD p2));
A7(FAST, D2Common,00000,00000,12910,5D210,19B40,11100,1BA60, DWORD, D2CompileCubeOutput, (CubeOutput* cubeoutput, char* s, DWORD p1, DWORD p2));
A7(FAST, D2Common,00000,00000,2B1A0, 11F0, 1380, 1140, 1300, ItemTypesBIN*, D2GetItemTypesBIN, (DWORD itemTypesId));
F7(STD, D2Common,11276,11276,11276,10254,10074,10111,10435,11081, DWORD, D2GetSkillCost, (Unit* ptChar, int skpoints, DWORD skillID, DWORD curSkillLevel));//not 10447
A7(FAST, D2Common,00000,00000,82C80, 15D0, 1800, 1220, 12D0, 17B0, CharStatsBIN*, D2GetCharStatsBIN, (DWORD charID));
A7(FAST, D2Common,00000,00000,12410,5D7D0,1A100,116C0,1C020,5B0E0, DWORD, D2CompileCubeInput, (CubeInput* cubeinput, char* s, DWORD p1, DWORD p2));
A7(FAST, D2Common,00000,00000,12910,5D210,19B40,11100,1BA60,5AB20, DWORD, D2CompileCubeOutput, (CubeOutput* cubeoutput, char* s, DWORD p1, DWORD p2));
A7(FAST, D2Common,00000,00000,2B1A0, 11F0, 1380, 1140, 1300, 1160, ItemTypesBIN*, D2GetItemTypesBIN, (DWORD itemTypesId));
//A7(FAST, D2Common,00000,00000,62FD0,00000,00000,00000,00000, void, D2EncodeValueCheckMax, (saveBitField* data, DWORD value, DWORD bitSize));
A7(FAST, D2Common,00000,00000,642B0, 13F0, 12F0, 1540, 17A0, ItemStatCostBIN*,D2GetItemStatCostBIN, (DWORD id));
A7(FAST, D2Common,00000,00000,642B0, 13F0, 12F0, 1540, 17A0, 17E0, ItemStatCostBIN*,D2GetItemStatCostBIN, (DWORD id));
//A7(FAST, D2Common,00000,00000,764A0,00000,00000,00000,00000, void*, D2Common764A0, (Stats* ptStats, DWORD stat, ItemStatCostBIN* itemStatCost ,DWORD));
//A7(STD, D2Common,00000,00000,76E30,00000,00000,00000,00000, void, D2PreUpdateDisabledStat, (Stats* ptStats));
//A7(FAST, D2Common,00000,00000,76C10,00000,00000,00000,00000, void, D2ApplyStat,(Stats* ptCharStats, DWORD statId, DWORD value, Unit* ptItem));
A7(FAST, D2Common,738A4,739B4,84268, 96E0, 98D0, 9900, 9900, void*, D2ReadFile,(DWORD unused, char* filename, DWORD* size, const char*, DWORD));
A7(FAST, D2Common,738A4,739B4,84268, 96E0, 98D0, 9900, 9900, B5E0, void*, D2ReadFile,(DWORD unused, char* filename, DWORD* size, const char*, DWORD));
//A7(FAST, D2Common,00000,00000, 94D0,00000,00000,00000,00000, void*, D2GetStringIDForTxtFile,(const char * string));
A7(STD, D2Common,1F500,1F510,29FA0,71EB0,32AA0,7D2A0,59870, void, D2LoadSuperuniques,(DWORD mempool));//FASCALL UNTIL 1.10
A7(STD, D2Common,1F500,1F510,29FA0,71EB0,32AA0,7D2A0,59870,80C40, void, D2LoadSuperuniques,(DWORD mempool));//FASCALL UNTIL 1.10
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -307,24 +308,24 @@ A7(STD, D2Common,1F500,1F510,29FA0,71EB0,32AA0,7D2A0,59870, void, D2LoadSuper
//E2F(D2Client,5BA90, void, D2ReloadGambleScreen, ());//1.11b
//E2F(D2Client,1FEB0, void, D2OpenNPCMenu, (Unit* ptNPC));//1.11b by ESI
A7(FAST, D2Client, 1000, 1000, 1000,75D00,A9070,BEF70,2B420, void*, D2LoadImage, (const char* filename, DWORD filetype));
A7(FAST, D2Client, 1150, 1150, 1140,00000,00000,00000,00000, void, D2FreeImage, (void* image));//6FAA1140
A7(FAST, D2Client, D640, D630, DB50,73620,5E4E0,79670,147A0, void, D2SendMsgToAll,(BYTE* data));//1.11 and 1.11b by ESI !!
A7(FAST, D2Client, 1000, 1000, 1000,75D00,A9070,BEF70,2B420,A9480, void*, D2LoadImage, (const char* filename, DWORD filetype));
A7(FAST, D2Client, 1150, 1150, 1140,00000,00000,00000,00000,00000, void, D2FreeImage, (void* image));//6FAA1140
A7(FAST, D2Client, D640, D630, DB50,73620,5E4E0,79670,147A0,B6890, void, D2SendMsgToAll,(BYTE* data));//1.11 and 1.11b by ESI !!
//A7(STD, D2Client,00000,00000,15A80,00000,00000,00000,00000, int, D2GetAvgChanceMonsterWillHitYou, ());//6FAB5A80
A7(STD, D2Client,00000,00000,15A80,00000,00000,00000,00000, DWORD, D2GetLastMonsterIDFight, ());//6FAB5A80
A7(STD, D2Client,29800,297F0,2FD60,828A0,89320,6B280,BCEA0, void, D2PrintStatsPage, ());
A7(STD, D2Client,00000,00000,15A80,00000,00000,00000,00000,00000, DWORD, D2GetLastMonsterIDFight, ());//6FAB5A80
A7(STD, D2Client,29800,297F0,2FD60,828A0,89320,6B280,BCEA0,BF640, void, D2PrintStatsPage, ());
//A7(FAST, D2Client,00000,00000,45990,00000,00000,00000,00000, Unit*, D245990, (Inventory*,DWORD idItem);//6FAE5990
A7(FAST, D2Client,4BB20,4BB20,521C0,B8CB0,21250,88EA0,54E10, DWORD, D2PrintStat,(Unit* ptItem, Stats* ptStats, DWORD statID, DWORD statIndex, DWORD statValue, LPWSTR lpText));//statID=EAX, lpText=ESI 1.11b
A7(FAST, D2Client,85A60,84DE0,80430,9EEB0,62070,8B7A0,BF5F0, LPWSTR, D2SetColorPopup, (LPWSTR popupText, DWORD color));//1.11 and 1.11b BY EDI
A7(FAST, D2Client,4BB20,4BB20,521C0,B8CB0,21250,88EA0,54E10,2CE40, DWORD, D2PrintStat,(Unit* ptItem, Stats* ptStats, DWORD statID, DWORD statIndex, DWORD statValue, LPWSTR lpText));//statID=EAX, lpText=ESI 1.11b
A7(FAST, D2Client,85A60,84DE0,80430,9EEB0,62070,8B7A0,BF5F0,18820, LPWSTR, D2SetColorPopup, (LPWSTR popupText, DWORD color));//1.11 and 1.11b BY EDI
//A7(FAST, D2Client,00000,00000,869F0,00000,00000,00000,00000, Unit*, D2ClientGetObject, (DWORD itemNum, DWORD type));//6FB269F0
A7(FAST, D2Client,B4360,B36E0,B5820,3ACC0,54210,31FA0,88A70, DWORD, D2PlaySound, (DWORD id, DWORD, DWORD, DWORD, DWORD));
A7(FAST, D2Client,B4360,B36E0,B5820,3ACC0,54210,31FA0,88A70,26270, DWORD, D2PlaySound, (DWORD id, DWORD, DWORD, DWORD, DWORD));
//A7(FAST, D2Client,B9970,B8CF0,BB0F0,00000,00000,00000,00000, void, D2FillRect,(DWORD x, DWORD y, DWORD Width, DWORD Height, DWORD color, DWORD transTbl));
A7(FAST, D2Client,00000,00000,00000,00000,571C0,18450,46150, Unit*, D2GetCurrentNPC, ());
A7(FAST, D2Client,00000,00000,00000,73260,5DE40,791A0,143E0, void, D2SendToServerXX,(DWORD size, BYTE * data));//by EBX
A7(FAST, D2Client,88940,87CC0,83260,A1F30,65690,8EF00,C2790, void, D2TogglePage, (DWORD a, DWORD b, DWORD c));
A7(FAST, D2Client,00000,00000,00000,A6520,710C0,A6640,8CD00, void, D2ClickOnStashButton, (DWORD x, DWORD y));//BY x=ESI y=EDI
A7(STD, D2Client,897B0,88B30,84110,9E3B0,621C0,8B8F0,BEAF0, void*, D2LoadBuySelBtn, ());
A7(FAST, D2Client,00000,00000,00000,8E480,5BA90,1CC00,4ABE0, void, D2ReloadGambleScreen, ());
A7(FAST, D2Client,00000,00000,00000,00000,571C0,18450,46150,790D0, Unit*, D2GetCurrentNPC, ());
A7(FAST, D2Client,00000,00000,00000,73260,5DE40,791A0,143E0,B61F0, void, D2SendToServerXX,(DWORD size, BYTE * data));//by EBX
A7(FAST, D2Client,88940,87CC0,83260,A1F30,65690,8EF00,C2790,1C190, void, D2TogglePage, (DWORD a, DWORD b, DWORD c));
A7(FAST, D2Client,00000,00000,00000,A6520,710C0,A6640,8CD00,90C10, void, D2ClickOnStashButton, (DWORD x, DWORD y));//BY x=ESI y=EDI
A7(STD, D2Client,897B0,88B30,84110,9E3B0,621C0,8B8F0,BEAF0,18AA0, void*, D2LoadBuySelBtn, ());
A7(FAST, D2Client,00000,00000,00000,8E480,5BA90,1CC00,4ABE0,7DC60, void, D2ReloadGambleScreen, ());
//A7(FAST, D2Client,00000,00000,00000,00000,1FEB0,5CDD0,00000, void, D2OpenNPCMenu, (Unit* ptNPC));//by ESI
@ -369,43 +370,43 @@ A7(FAST, D2Client,00000,00000,00000,8E480,5BA90,1CC00,4ABE0, void, D2ReloadGamb
//E2S(D2Game,E66D0, void, D2SaveGame, (Game* ptGame));//1.11b
F7(FAST, D2Game,10059,10059,10059,10039,10007,10037,10049, void, D2SetNbPlayers, (DWORD nbPlayers));
F7(FAST, D2Game,10059,10059,10059,10039,10007,10037,10049,10002, void, D2SetNbPlayers, (DWORD nbPlayers));
//A7(FAST, D2Game,00000,00000,01DE0,00000,00000,00000,00000, void*, D2GetClientByClientID, (Game* ptGame, DWORD clientID));//6FC31DE0
A7(FAST, D2Game,00000,00000, 6C60,E3DA0,E8210,EB060,49930, void, D2AddClient, (DWORD clientID));//BY EAX
A7(STD, D2Game,00000,00000, 94E0,E0520,E49A0,A6360,2AAE0, Game*, D2GetGameByClientID, (DWORD clientID));//6FC394E0
A7(FAST, D2Game,00000,00000, B0E0,DF250,E36D0,A5080,29820, void, D2BroadcastFunction, (Game* ptGame, void* fct, void* param));//00DAB0E0
A7(FAST, D2Game, C380, C650, C710,41420,A0D50,7D220,8A3E0, DWORD, D2SendPacket, (void* ptNetClient, LPVOID pData, DWORD size));//EAX=ptNetClient [ESP]=pData
A7(FAST, D2Game, D650, D920, DB50,44D00,A3F20,802E0,8D5F0, void, D2SetSkillBaseLevelOnClient, (void* ptClient, Unit* ptChar, DWORD skillID, DWORD sLvl, DWORD bRemove));//by EAX,ESI,EBX
A7(FAST, D2Game,00000,00000, 6C60,E3DA0,E8210,EB060,49930,E5070, void, D2AddClient, (DWORD clientID));//BY EAX
A7(STD, D2Game,00000,00000, 94E0,E0520,E49A0,A6360,2AAE0,BC700, Game*, D2GetGameByClientID, (DWORD clientID));//6FC394E0
A7(FAST, D2Game,00000,00000, B0E0,DF250,E36D0,A5080,29820,BB510, void, D2BroadcastFunction, (Game* ptGame, void* fct, void* param));//00DAB0E0
A7(FAST, D2Game, C380, C650, C710,41420,A0D50,7D220,8A3E0,DB780, DWORD, D2SendPacket, (void* ptNetClient, LPVOID pData, DWORD size));//EAX=ptNetClient [ESP]=pData
A7(FAST, D2Game, D650, D920, DB50,44D00,A3F20,802E0,8D5F0,DD4F0, void, D2SetSkillBaseLevelOnClient, (void* ptClient, Unit* ptChar, DWORD skillID, DWORD sLvl, DWORD bRemove));//by EAX,ESI,EBX
//A7(FAST, D2Game,00000,00000,0E6F0,00000,00000,00000,00000, void, D2UpdateClientItem, (NetClient* ptNetClient, Unit* ptChar, Unit* ptItem,DWORD,DWORD,DWORD));//6FC3E6F0
//A7(FAST, D2Game,00000,00000,10FB0,00000,00000,00000,00000, DWORD, D2UpdateInventory, (Game* ptGame, Unit* ptChar, void* ptNetClient, Inventory* pInventory));//6FC40FB0
//A7(FAST, D2Game,00000,00000,110E0,00000,00000,00000,00000, DWORD, D2UpdateItem, (Unit* ptChar, Unit* ptItem, Unit* ptSocketedItem, void* ptNetClient));//6FC410E0
A7(STD, D2Game,00000,00000,00000,27230,109F0,AE930,A22E0, DWORD, D2LinkPortal, (Game* ptGame, Unit* ptObject, DWORD levelEndID, DWORD levelStartID));
A7(FAST, D2Game,00000,00000,128F0,38D90,43E60,11FF0,D2070, DWORD, D2VerifIfNotCarry1, (Unit* ptItem, ItemsBIN* itemsData, Unit* ptFirstItem));// BY EBX=itemsData EAX=ptFirstItem [ESP]=ptItem
A7(STD, D2Game,00000,00000,00000,27230,109F0,AE930,A22E0,15F40, DWORD, D2LinkPortal, (Game* ptGame, Unit* ptObject, DWORD levelEndID, DWORD levelStartID));
A7(FAST, D2Game,00000,00000,128F0,38D90,43E60,11FF0,D2070,B2F70, DWORD, D2VerifIfNotCarry1, (Unit* ptItem, ItemsBIN* itemsData, Unit* ptFirstItem));// BY EBX=itemsData EAX=ptFirstItem [ESP]=ptItem
//A7(FAST, D2Game,00000,00000,1ED80,00000,00000,00000,00000, Unit*, D2CreateItem, (Game* ptGame, ItemGenerationData* itemGenerationData, DWORD));//6FC4ED80
A7(FAST, D2Game,00000,00000,22070, 1090, 1DF0, 11F0, 1280, Room*, D2TestPositionInRoom, (Room* ptRoom, DWORD x, DWORD y));
A7(FAST, D2Game,00000,00000,22070, 1090, 1DF0, 11F0, 1280, 1340, Room*, D2TestPositionInRoom, (Room* ptRoom, DWORD x, DWORD y));
//A7(FAST, D2Game,00000,00000,22410,00000,00000,00000,00000, void, D2AddStaffModAffixes, (Unit* ptItem, ItemGenerationData* itemParam));//6FC52410
//A7(FAST, D2Game,00000,00000,22C00,00000,00000,00000,00000, WORD, D2GetNewAffix, (Unit* ptItem, DWORD testIfSpawnable, DWORD mustSelectOne, DWORD addToItem, DWORD isPrefix, int affixID, WORD autoAffixGroupID));//6FC52C00
//A7(FAST, D2Game,00000,00000,23610,00000,00000,00000,00000, WORD, D2GetRareAffixName, (Unit* ptItem, DWORD wantPrefix));//6FC53610
//A7(FAST, D2Game,00000,00000,3AD10,00000,00000,00000,00000, DWORD, D2GetSuperUniqueMonsterID, (Game* ptGame, Unit* ptMonster));//6FC6AD10
A7(FAST, D2Game,00000,00000,3F220,4ABE0,EC7E0,40B90,24950, DWORD, D2SpawnMonster, (Game* ptGame, Room* ptRoom, DWORD zero1, DWORD x, DWORD y, DWORD minusOne, DWORD superuniqueID, DWORD zero2));//wrong param
A7(STD, D2Game,00000,00000,00000,D6D10,235C0, D410,200E0, void, D2Game235C0, (Game* ptGame, Room* ptRoom));
A7(FAST, D2Game,00000,00000,3F220,4ABE0,EC7E0,40B90,24950,CDE20, DWORD, D2SpawnMonster, (Game* ptGame, Room* ptRoom, DWORD zero1, DWORD x, DWORD y, DWORD minusOne, DWORD superuniqueID, DWORD zero2));//wrong param
A7(STD, D2Game,00000,00000,00000,D6D10,235C0, D410,200E0,59980, void, D2Game235C0, (Game* ptGame, Room* ptRoom));
//A7(FAST, D2Game,00000,00000,4C7B0,00000,00000,00000,00000, Unit*, D2GetSkillItem, (Unit* ptChar));//6FC7C7B0
//A7(FAST, D2Game,00000,00000,5A500,00000,00000,00000,00000, DWORD, D2SavePlayer, (Game* ptGame, Unit* ptChar, char* playername, DWORD zero));//6FC8A500
A7(FAST, D2Game,4F100,4F500,5B8A0,B9D70,25D50,44950,54810, DWORD, D2LoadInventory, (Game* ptGame, Unit* pChar, saveBitField* pdata, DWORD p2, DWORD maxSize, DWORD p4, DWORD *ptNbBytesRead));//6FC8B8A0
A7(FAST, D2Game,7BAE0,7BFD0,8BB00,97620,BEF80,93650,E03A0, Unit*, D2GameGetObject, (Game* ptGame, DWORD type, DWORD itemNum));//6FCBBB00
A7(FAST, D2Game,4F100,4F500,5B8A0,B9D70,25D50,44950,54810,3A4C0, DWORD, D2LoadInventory, (Game* ptGame, Unit* pChar, saveBitField* pdata, DWORD p2, DWORD maxSize, DWORD p4, DWORD *ptNbBytesRead));//6FC8B8A0
A7(FAST, D2Game,7BAE0,7BFD0,8BB00,97620,BEF80,93650,E03A0,6DC40, Unit*, D2GameGetObject, (Game* ptGame, DWORD type, DWORD itemNum));//6FCBBB00
//A7(FAST, D2Game,00000,00000,9F320,501C0,F1C50,F1A50,F3220, Unit*, D2GetOwnerMonster, (Unit* ptMonster));
//A7(FAST, D2Game,00000,00000,E08D0,00000,00000,00000,00000, void, D2UpdateSkillDataAfterUnassignment, (Game* ptGame, Unit* ptChar, DWORD skillID));//6FD108D0
A7(FAST, D2Game,00000,00000,00000,99760,C09E0,94E70,E1D90, Unit*, D2CreateUnit, (DWORD type, DWORD id, DWORD x, DWORD y, Game* ptGame, Room* ptRoom, DWORD uk1, DWORD uk2, DWORD uk3));
A7(FAST, D2Game,00000,00000,00000,9B480,34920,D1AA0,70180, void, D2OpenPandPortal, (Game* ptGame, Unit* ptChar));
A7(FAST, D2Game,00000,00000,00000,9B470,34910,D1A90,70170, void, D2OpenPandFinalPortal, (Game* ptGame, Unit* ptChar));
A7(FAST, D2Game,00000,00000,00000,84730,85AA0,DBE90,A9610, void, D2MephIA, (Game* ptGame, Unit* ptMonster, DWORD*));
A7(FAST, D2Game,00000,00000,00000,75980,D7BD0,CD0F0,85B60, void, D2DiabloIA, (Game* ptGame, Unit* ptMonster, DWORD*));
A7(FAST, D2Game,00000,00000,00000,EAB20,2BC80,B3B90,B8610, void, D2BaalIA, (Game* ptGame, Unit* ptMonster, DWORD*));
A7(FAST, D2Game,00000,00000,00000,70320,D2D70,C2A90,7B4E0, void, D2UberMephIA, (Game* ptGame, Unit* ptMonster, DWORD*));
A7(FAST, D2Game,00000,00000,00000,7F200,7FE60,D6250,A39D0, void, D2UberDiabloIA, (Game* ptGame, Unit* ptMonster, DWORD*));
A7(FAST, D2Game,00000,00000,00000,E92B0,2A300,B2210,B6C80, void, D2UberBaalIA, (Game* ptGame, Unit* ptMonster, DWORD*));
A7(FAST, D2Game,00000,00000,00000,99760,C09E0,94E70,E1D90,6FE10, Unit*, D2CreateUnit, (DWORD type, DWORD id, DWORD x, DWORD y, Game* ptGame, Room* ptRoom, DWORD uk1, DWORD uk2, DWORD uk3));
A7(FAST, D2Game,00000,00000,00000,9B480,34920,D1AA0,70180,941E0, void, D2OpenPandPortal, (Game* ptGame, Unit* ptChar));
A7(FAST, D2Game,00000,00000,00000,9B470,34910,D1A90,70170,941D0, void, D2OpenPandFinalPortal, (Game* ptGame, Unit* ptChar));
A7(FAST, D2Game,00000,00000,00000,84730,85AA0,DBE90,A9610,31920, void, D2MephIA, (Game* ptGame, Unit* ptMonster, DWORD*));
A7(FAST, D2Game,00000,00000,00000,75980,D7BD0,CD0F0,85B60,4EAD0, void, D2DiabloIA, (Game* ptGame, Unit* ptMonster, DWORD*));
A7(FAST, D2Game,00000,00000,00000,EAB20,2BC80,B3B90,B8610,C8850, void, D2BaalIA, (Game* ptGame, Unit* ptMonster, DWORD*));
A7(FAST, D2Game,00000,00000,00000,70320,D2D70,C2A90,7B4E0,49480, void, D2UberMephIA, (Game* ptGame, Unit* ptMonster, DWORD*));
A7(FAST, D2Game,00000,00000,00000,7F200,7FE60,D6250,A39D0,2C3F0, void, D2UberDiabloIA, (Game* ptGame, Unit* ptMonster, DWORD*));
A7(FAST, D2Game,00000,00000,00000,E92B0,2A300,B2210,B6C80,C6EC0, void, D2UberBaalIA, (Game* ptGame, Unit* ptMonster, DWORD*));
//A7(FAST, D2Game,00000,00000,00000,00000,92420,00000,00000, void, D2ReloadGambleScreenGame, (Unit* ptNPC, Game* ptGame, Unit* ptChar, DWORD, DWORD one));
A7(STD, D2Game,00000,00000, 89C0,E2390,E66D0,A8090,2C830, void, D2SaveGame, (Game* ptGame) );
A7(STD, D2Game,00000,00000, 89C0,E2390,E66D0,A8090,2C830,BE660, void, D2SaveGame, (Game* ptGame) );
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -413,8 +414,8 @@ A7(STD, D2Game,00000,00000, 89C0,E2390,E66D0,A8090,2C830, void, D2SaveGame, (G
//D2S(D2Net,10020, DWORD, D2SendToServer, (DWORD size, DWORD one, void* data));//ONLY 1.11b
//D2S(D2Net,10018, DWORD, D2SendToClient, (DWORD zero, DWORD clientID, void* data, DWORD size));//ONLY 1.11b
F7(STD, D2Net, 10005,10005,10005,10035,10020,10036,10024, DWORD, D2SendToServer, (DWORD size, DWORD one, void* data));//(DWORD zero, void* data, DWORD size) for 1.10 and before
F7(STD, D2Net, 10006,10006,10006,10018,10018,10015,10002, DWORD, D2SendToClient, (DWORD zero, DWORD clientID, void* data, DWORD size));
F7(STD, D2Net, 10005,10005,10005,10035,10020,10036,10024,10015, DWORD, D2SendToServer, (DWORD size, DWORD one, void* data));//(DWORD zero, void* data, DWORD size) for 1.10 and before
F7(STD, D2Net, 10006,10006,10006,10018,10018,10015,10002,10012, DWORD, D2SendToClient, (DWORD zero, DWORD clientID, void* data, DWORD size));
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -439,25 +440,25 @@ F7(STD, D2Net, 10006,10006,10006,10018,10018,10015,10002, DWORD, D2SendToClien
////D2S(Fog,10217, int, D2GetIDFromLookUpTable, (void* table, char* string, bool));//6FF53840
//D2S(Fog,10265, int, D2GetInstructionPointer, ());//ONLY 1.11/1.11b NOT 1.10
F7(STD, Fog, 10023,10023,10023,00000,00000,00000,00000, void, D2FogAssertOld, (const char* ptMessage, DWORD eip, DWORD line));//(STDCALL until 1.10)
F7(FAST, Fog, 00000,00000,00000,10024,10024,10024,10024, void, D2FogAssert, (const char* ptMessage, DWORD eip, DWORD line));
F7(FAST, Fog, 10042,10042,10042,10042,10042,10042,10042, void*, D2FogMemAlloc, (DWORD dwMemSize, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
F7(FAST, Fog, 10043,10043,10043,10043,10043,10043,10043, void*, D2FogMemDeAlloc, (void* ptMemLoc, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
F7(FAST, Fog, 10045,10045,10045,10045,10045,10045,10045, void*, D2AllocMem, (DWORD,DWORD dwMemSize, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
F7(FAST, Fog, 10046,10046,10046,10046,10046,10046,10046, void*, D2FreeMem, (DWORD,void* ptMemLoc, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
F7(FAST, Fog, 10102,10102,10102,10102,10102,10102,10102, DWORD, D2MPQOpenFile, (char* ptPath, void** buf));
F7(FAST, Fog, 10103,10103,10103,10103,10103,10103,10103, DWORD, D2MPQCloseFile, (void* mpqfile));
F7(FAST, Fog, 10104,10104,10104,10104,10104,10104,10104, DWORD, D2MPQReadFile, (void* mpqfile, BYTE* buffer, DWORD nbToRead, DWORD* nbRead,DWORD,DWORD,DWORD));
F7(FAST, Fog, 10105,10105,10105,10105,10105,10105,10105, DWORD, D2MPQGetSizeFile, (void* mpqfile, DWORD* toReset));
F7(FAST, Fog, 10115,10115,10115,10115,10115,10115,10115, void, D2FogGetSavePath, (char* ptPath, DWORD maxsize));
F7(FAST, Fog, 10116,10116,10116,10116,10116,10116,10116, void, D2FogGetInstallPath, (char* ptPath, DWORD maxsize));
F7(STD, Fog, 10023,10023,10023,00000,00000,00000,00000,00000, void, D2FogAssertOld, (const char* ptMessage, DWORD eip, DWORD line));//(STDCALL until 1.10)
F7(FAST, Fog, 00000,00000,00000,10024,10024,10024,10024,10024, void, D2FogAssert, (const char* ptMessage, DWORD eip, DWORD line));
F7(FAST, Fog, 10042,10042,10042,10042,10042,10042,10042,10042, void*, D2FogMemAlloc, (DWORD dwMemSize, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
F7(FAST, Fog, 10043,10043,10043,10043,10043,10043,10043,10043, void*, D2FogMemDeAlloc, (void* ptMemLoc, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
F7(FAST, Fog, 10045,10045,10045,10045,10045,10045,10045,10045, void*, D2AllocMem, (DWORD,DWORD dwMemSize, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
F7(FAST, Fog, 10046,10046,10046,10046,10046,10046,10046,10046, void*, D2FreeMem, (DWORD,void* ptMemLoc, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
F7(FAST, Fog, 10102,10102,10102,10102,10102,10102,10102,10102, DWORD, D2MPQOpenFile, (char* ptPath, void** buf));
F7(FAST, Fog, 10103,10103,10103,10103,10103,10103,10103,10103, DWORD, D2MPQCloseFile, (void* mpqfile));
F7(FAST, Fog, 10104,10104,10104,10104,10104,10104,10104,10104, DWORD, D2MPQReadFile, (void* mpqfile, BYTE* buffer, DWORD nbToRead, DWORD* nbRead,DWORD,DWORD,DWORD));
F7(FAST, Fog, 10105,10105,10105,10105,10105,10105,10105,10105, DWORD, D2MPQGetSizeFile, (void* mpqfile, DWORD* toReset));
F7(FAST, Fog, 10115,10115,10115,10115,10115,10115,10115,10115, void, D2FogGetSavePath, (char* ptPath, DWORD maxsize));
F7(FAST, Fog, 10116,10116,10116,10116,10116,10116,10116,10116, void, D2FogGetInstallPath, (char* ptPath, DWORD maxsize));
//F7(STD, Fog, 10126,10126,10126,10126,10126,10126,10126, DWORD, D2InitBitField, (saveBitField* data, BYTE* buf, DWORD bufsize));//6FF536C0
//F7(STD, Fog, 10127,10127,10127,10127,10127,10127,10127, DWORD, D2GetBitFieldSize, (saveBitField* data));//6FF536C0
//F7(STD, Fog, 10128,10128,10128,10128,10128,10128,10128, void, D2EncodeValue, (saveBitField* data, DWORD value, DWORD bitSize));//6FF536C0
//F7(STD, Fog, 10130,10130,10130,10130,10130,10130,10130, DWORD, D2DecodeValue, (saveBitField* data,DWORD readingSize));//6FF53840
F7(STD, Fog, 10212,10212,10212,10212,10212,10212,10212, void, D2Fog10212, (DWORD unknow));
F7(STD, Fog, 10212,10212,10212,10212,10212,10212,10212,10212, void, D2Fog10212, (DWORD unknow));
//F7(STD, Fog, 10217,10217,10217,10217,10217,10217,10217, int, D2GetIDFromLookUpTable, (void* table, char* string, bool));//6FF53840
F7(STD, Fog, 00000,00000,00000,10265,10265,10265,10265, int, D2GetInstructionPointer, ());
F7(STD, Fog, 00000,00000,00000,10265,10265,10265,10265,10265, int, D2GetInstructionPointer, ());
//Fog10213 getIndexFromLookupTable (&table,code,bool)
@ -476,12 +477,12 @@ F7(STD, Fog, 00000,00000,00000,10265,10265,10265,10265, int, D2GetInstructionP
////E2F(D2Lang,2CD0, DWORD, D2unicodenwidth, (char* ptChar, DWORD size));//6FC12CD0_unicodenwidth
////E2S(D2Lang,1670, DWORD, D2swprintf, (DWORD bufSize, LPWSTR buf, LPWSTR string, ...));//6FC11670_sprintf
//F7(FAST, D2Lang, 10003,10003,10003,00000,00000,00000,00000, LPWSTR, D2GetStringFromString, (const char* ptString));//6FC13BC0
F7(FAST, D2Lang, 10004,10004,10004,10005,10000,10005,10003, LPWSTR, D2GetStringFromIndex, (WORD dwIndexNum));
F7(FAST, D2Lang, 10003,10003,10003,10002,10004,10010,10011,10011, LPWSTR, D2GetStringFromString, (const char* ptString));//6FC13BC0
F7(FAST, D2Lang, 10004,10004,10004,10005,10000,10005,10003,10004, LPWSTR, D2GetStringFromIndex, (WORD dwIndexNum));
//F7(STD, D2Lang, 10006,10006,10006,00000,00000,00000,00000, void, D2GetStringLang, (LPSTR ptLang, DWORD Zero));//6FC13FB0
F7(STD, D2Lang, 10007,10007,10007,10009,10013,10002,10009, DWORD, D2GetLang, ());
F7(STD, D2Lang, 10010,10010,10010,00000,00000,00000,00000, DWORD, D2PrintBigNumber, (LPWSTR ptBuf , DWORD number, DWORD size));//6FC14210
//F7(STD, D2Lang, 10013,10013,10013,00000,00000,00000,00000, DWORD, D2GetStringAndIndexFromString, (const char* ptString , LPWSTR result));//6FC13960
F7(STD, D2Lang, 10007,10007,10007,10009,10013,10002,10009,10001, DWORD, D2GetLang, ());//14b 00522A20
F7(STD, D2Lang, 10010,10010,10010,00000,00000,00000,00000,00000, DWORD, D2PrintBigNumber, (LPWSTR ptBuf , DWORD number, DWORD size));//6FC14210
F7(STD, D2Lang, 10013,10013,10013,00000,00000,00000,00000,10005, DWORD, D2GetStringAndIndexFromString, (const char* ptString , LPWSTR result));//6FC13960
//A7(FAST, D2Lang, 00000,00000,029B0,00000,00000,00000,00000, DWORD, D2UnicodeWidth, (DWORD MemLoc, WORD Size));//6FC129B0
//A7(FAST, D2Lang, 00000,00000,02E60,00000,00000,00000,00000, LPWSTR, D2GetStrFromIndex , (void* ptFile, void* ptMemLoc, DWORD dwIndexNum));//6FC12E60
//A7(FAST, D2Lang, 00000,00000,03640,00000,00000,00000,00000, TblHeader*, D2LoadTblFile, (LPCSTR lpszFileName));//6FC13640
@ -497,9 +498,9 @@ F7(STD, D2Lang, 10010,10010,10010,00000,00000,00000,00000, DWORD, D2PrintBigNu
//D2S(Storm,511, void, D2FreeWinMessage, (sWinMessage* msg));//1.11/1.11b
//F7(STD, Storm, 253, 253, 253, 253, 253, 253, 000, void, D2StormMPQCloseFile, (void* mpqfile));
F7(STD, Storm, 268, 268, 268, 268, 268, 268, 268, DWORD, D2StormMPQOpenFile, (DWORD zero, LPCSTR fileName, DWORD dwSearchScope, void** buffer))
F7(STD, Storm, 503, 503, 503, 503, 503, 503, 503, void, D2Storm503, (DWORD, DWORD, DWORD));
F7(STD, Storm, 511, 511, 511, 511, 511, 511, 511, void, D2FreeWinMessage, (sWinMessage* msg));
F7(STD, Storm, 268, 268, 268, 268, 268, 268, 268, 268, DWORD, D2StormMPQOpenFile, (DWORD zero, LPCSTR fileName, DWORD dwSearchScope, void** buffer))
F7(STD, Storm, 503, 503, 503, 503, 503, 503, 503, 503, void, D2Storm503, (DWORD, DWORD, DWORD));
F7(STD, Storm, 511, 511, 511, 511, 511, 511, 511, 511, void, D2FreeWinMessage, (sWinMessage* msg));
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -511,12 +512,12 @@ F7(STD, Storm, 511, 511, 511, 511, 511, 511, 511, void, D2FreeWinMessa
//D2S(D2gfx,10000, void, D2FillArea,(DWORD x1, DWORD y1, DWORD x2, DWORD y2, DWORD color, DWORD transTbl));//ONLY 1.11b
//D2S(D2gfx,10044, void, D2PrintImage,(sDrawImageInfo* data, DWORD x, DWORD y, DWORD p4, DWORD p5, DWORD p6) );//ONLY 1.11b
F7(STD, D2gfx, 10005,10005,10005,10000,10063,10043,10031, DWORD, D2GetResolution,() );
F7(STD, D2gfx, 10005,10005,10005,10000,10063,10043,10031,10012, DWORD, D2GetResolution,() );
//F7,STD, D2gfx, 10023,10023,10023,00000,00000,00000,00000, DWORD, D2CreateMainWindow,(DWORD,DWORD) );
//F7(STD, D2gfx, 10026,10026,10026,00000,00000,00000,00000, DWORD, D2ShowWindow,() );
//F7,STD, D2gfx, 10027,10027,10027,00000,00000,00000,00000, HWND, D2GetWindowHandle,() );//6FA749C0
F7(STD, D2gfx, 10055,10055,10055,10028,10000,10062,10014, void, D2FillArea,(DWORD x1, DWORD y1, DWORD x2, DWORD y2, DWORD color, DWORD transTbl));
F7(STD, D2gfx, 10072,10072,10072,10047,10044,10024,10041, void, D2PrintImage,(sDrawImageInfo* data, DWORD x, DWORD y, DWORD p4, DWORD p5, DWORD p6) );
F7(STD, D2gfx, 10055,10055,10055,10028,10000,10062,10014,10028, void, D2FillArea,(DWORD x1, DWORD y1, DWORD x2, DWORD y2, DWORD color, DWORD transTbl));
F7(STD, D2gfx, 10072,10072,10072,10047,10044,10024,10041,10042, void, D2PrintImage,(sDrawImageInfo* data, DWORD x, DWORD y, DWORD p4, DWORD p5, DWORD p6) );
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -530,36 +531,36 @@ F7(STD, D2gfx, 10072,10072,10072,10047,10044,10024,10041, void, D2PrintImage,(
//D2F(D2Win,10132, DWORD, D2PrintTextPopup,(LPWSTR s, DWORD x, DWORD y, DWORD uk, DWORD type, DWORD color) );//6F8AB080
//D2S(D2Win,10113, void*, D2CreateTextBox,(DWORD* data) );//ONLY 1.11b
F7(FAST, D2Win, 10046,10046,10046,10061,10075,10015,10022, void, D2PrintLineOnTextBox,(void* screen, char* s, DWORD color) );
F7(FAST, D2Win, 10117,10117,10117,10020,10064,10001,10150, void, D2PrintString,(LPWSTR s, DWORD x, DWORD y, DWORD color, DWORD bfalse) );
F7(FAST, D2Win, 10121,10121,10121,10034,10128,10132,10028, DWORD, D2GetPixelLen,(LPWSTR s) );
F7(FAST, D2Win, 10127,10127,10127,10141,10170,10010,10184, DWORD, D2SetFont,(DWORD fontID) );
F7(FAST, D2Win, 10129,10129,10129,10118,10039,10031,10085, void, D2PrintPopup,(LPWSTR s, DWORD x, DWORD y, DWORD color, DWORD center) );
F7(FAST, D2Win, 10131,10131,10131,00000,00000,00000,00000, void, D2GetPixelRect,(LPWSTR s, DWORD* x, DWORD* y) );//6F8AB260
F7(FAST, D2Win, 10132,10132,10132,00000,00000,00000,00000, DWORD, D2PrintTextPopup,(LPWSTR s, DWORD x, DWORD y, DWORD uk, DWORD type, DWORD color) );//6F8AB080
F7(STD, D2Win, 10017,10017,10017,10147,10113,10098,10098, void*, D2CreateTextBox,(DWORD* data) );
F7(FAST, D2Win, 10046,10046,10046,10061,10075,10015,10022,10051, void, D2PrintLineOnTextBox,(void* screen, char* s, DWORD color) );
F7(FAST, D2Win, 10117,10117,10117,10020,10064,10001,10150,10076, void, D2PrintString,(LPWSTR s, DWORD x, DWORD y, DWORD color, DWORD bfalse) );
F7(FAST, D2Win, 10121,10121,10121,10034,10128,10132,10028,10150, DWORD, D2GetPixelLen,(LPWSTR s) );
F7(FAST, D2Win, 10127,10127,10127,10141,10170,10010,10184,10047, DWORD, D2SetFont,(DWORD fontID) );
F7(FAST, D2Win, 10129,10129,10129,10118,10039,10031,10085,10137, void, D2PrintPopup,(LPWSTR s, DWORD x, DWORD y, DWORD color, DWORD center) );
F7(FAST, D2Win, 10131,10131,10131,00000,00000,00000,00000,00000, void, D2GetPixelRect,(LPWSTR s, DWORD* x, DWORD* y) );//6F8AB260
F7(FAST, D2Win, 10132,10132,10132,00000,00000,00000,00000,00000, DWORD, D2PrintTextPopup,(LPWSTR s, DWORD x, DWORD y, DWORD uk, DWORD type, DWORD color) );//6F8AB080
F7(STD, D2Win, 10017,10017,10017,10147,10113,10098,10098,10164, void*, D2CreateTextBox,(DWORD* data) );
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//D2CMP : ????0000
//D2S(D2CMP,10014, DWORD, D2CMP10014, (void* image) );//ONLY 1.11
F7(STD, D2CMP, 10032,10032,10032,10021,10014,10106,10065, DWORD, D2CMP10014, (void* image) );
F7(STD, D2CMP, 10032,10032,10032,10021,10014,10106,10065,10020, DWORD, D2CMP10014, (void* image) );
//ONLY UNTIL 1.10 :
A7(FAST, D2Client, BA00, B9F0, C080,00000,00000,00000,00000, DWORD, D2isLODGame, ());//6FAAC080
A7(FAST, D2Client, 00000,00000, C090,00000,00000,00000,00000, BYTE, D2GetDifficultyLevel, ());//6FAAC090 1.09 should be BA10 (b) BA00 (d)
A7(STD, D2Client, B6670,B59F0,B7BC0,00000,00000,00000,00000, DWORD, D2GetMouseX, ());//6FB57BC0
A7(STD, D2Client, B6680,B5A00,B7BD0,00000,00000,00000,00000, DWORD, D2GetMouseY, ());//6FB57BD0
A7(STD, D2Client, 8DC40,8CFC0,883D0,00000,00000,00000,00000, Unit*, D2GetClientPlayer, ());//6FB283D0
A7(FAST, D2Client, B920, B910, BF60,00000,00000,00000,00000, void, D2CleanStatMouseUp, ());//6FAABF60
A7(FAST, D2Client, D210, D200, D990,00000,00000,00000,00000, void, D2SendToServer3, (BYTE type, WORD p));//6FAAD990
A7(FAST, D2Client, BA00, B9F0, C080,00000,00000,00000,00000,00000, DWORD, D2isLODGame, ());//6FAAC080
A7(FAST, D2Client, 00000,00000, C090,00000,00000,00000,00000,00000, BYTE, D2GetDifficultyLevel, ());//6FAAC090 1.09 should be BA10 (b) BA00 (d)
A7(STD, D2Client, B6670,B59F0,B7BC0,00000,00000,00000,00000,00000, DWORD, D2GetMouseX, ());//6FB57BC0
A7(STD, D2Client, B6680,B5A00,B7BD0,00000,00000,00000,00000,00000, DWORD, D2GetMouseY, ());//6FB57BD0
A7(STD, D2Client, 8DC40,8CFC0,883D0,00000,00000,00000,00000,00000, Unit*, D2GetClientPlayer, ());//6FB283D0
A7(FAST, D2Client, B920, B910, BF60,00000,00000,00000,00000,00000, void, D2CleanStatMouseUp, ());//6FAABF60
A7(FAST, D2Client, D210, D200, D990,00000,00000,00000,00000,00000, void, D2SendToServer3, (BYTE type, WORD p));//6FAAD990
//A7(FAST, D2Client, 00000,00000, DA20,00000,00000,00000,00000, void, D2SendToServer5, (BYTE type, DWORD p));//6FAADA20
//A7(FAST, D2Client, 00000,00000, D9E0,00000,00000,00000,00000, void, D2SendToServer7, (BYTE type, WORD p1, WORD p2, WORD p3));//6FAAD9E0
//A7(FAST, D2Client, 00000,00000, DA40,00000,00000,00000,00000, void, D2SendToServer9, (BYTE type, DWORD p1, DWORD p2));//6FAADA40
//A7(FAST, D2Client, 00000,00000, DA70,00000,00000,00000,00000, void, D2SendToServer13,(BYTE type, DWORD p1, DWORD p2, DWORD p3));//6FAADA70
A7(FAST, D2Game, 7C2C0,7C7B0,8C2E0,00000,00000,00000,00000, NetClient*, D2GetClient, (Unit* ptUnit, char* lpszErrFile, DWORD ErrLine));//6FCBC2E0
A7(FAST, D2Game, 7C2C0,7C7B0,8C2E0,00000,00000,00000,00000,00000, NetClient*, D2GetClient, (Unit* ptUnit, char* lpszErrFile, DWORD ErrLine));//6FCBC2E0
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// VARIABLES ////////
@ -581,22 +582,23 @@ A7(FAST, D2Game, 7C2C0,7C7B0,8C2E0,00000,00000,00000,00000, NetClient*, D2GetCli
//E2C(D2Client,11C1E0,Unit*, ptClientChar);//1.11b
//C7(D2Common,000000,000000, 96A20, 9B74C, 9EE8C, 9B500, 99E1C, DataTables*,SgptDataTables); //03836A20 - 037A0000 //01EE6A20
C7(D2Client, D50E8, D40E0, D40F0, F5C60, F4FC8, DC6E4, DBC4C, DWORD, ResolutionY);//0x258 = 600
C7(D2Client, D50EC, D40E4, D40F4, F5C5C, F4FC4, DC6E0, DBC48, DWORD, ResolutionX);//0x320 = 800
C7(D2Client,125AD8,124958,11A74C,11BD28,11BEFC,11BD2C,11B9A4, DWORD, NegWindowStartY);//0xFFFFFFC4 = -60
C7(D2Client,125AD4,124954,11A748,11BD24,11BEF8,11BD28,11B9A0, DWORD, WindowStartX);//0x50 = 80
C7(D2Client, D50E8, D40E0, D40F0, F5C60, F4FC8, DC6E4, DBC4C,F7038, DWORD, ResolutionY);//0x258 = 600
C7(D2Client, D50EC, D40E4, D40F4, F5C5C, F4FC4, DC6E0, DBC48,F7034, DWORD, ResolutionX);//0x320 = 800
C7(D2Client,125AD8,124958,11A74C,11BD28,11BEFC,11BD2C,11B9A4,11D358, DWORD, NegWindowStartY);//0xFFFFFFC4 = -60
C7(D2Client,125AD4,124954,11A748,11BD24,11BEF8,11BD28,11B9A0,11D354, DWORD, WindowStartX);//0x50 = 80
//C7(D2Launch, 55818, 56088, 2CD5C,000000, 2CD5C,000000,000000, DWORD, GameTypeMode);//0x50 = 80 //6FA3CD5C-6FA10000
C7(D2Game, F2A80, F2918,113FB8,111718,1115E0,1105E0,1107B8, NetClient*, ClientTable);
C7(D2Game, F2A80, F2918,113FB8,111718,1115E0,1105E0,1107B8,1105E0, NetClient*, ClientTable);
//C7(D2Client,000000,000000,000000,000000,104225,000000,000000, DWORD, CurrentNPCNum);
C7(D2Client,000000,000000,000000, FB3F4,11A2F4,10330C,119854, DWORD, IsLodGame);
C7(D2Client,000000,000000,10795C,11BFB8,11C2A8,11BFF4,000000, BYTE, DifficultyLevel);
C7(D2Client,000000,000000,000000,10A40C,11B414,101634,11B824, DWORD, MouseY);//0x258 = 600
C7(D2Client,000000,000000,000000,10A410,11B418,101638,11B828, DWORD, MouseX);//0x320 = 800
C7(D2Client,000000,000000,000000,11C4F0,11C1E0,11C3D0,11BBFC, Unit*, ptClientChar);
C7(D2Client,000000,000000,000000, FB3F4,11A2F4,10330C,119854,1087B4, DWORD, IsLodGame);
C7(D2Client,000000,000000,10795C,11BFB8,11C2A8,11BFF4,000000,000000, BYTE, DifficultyLevel);
//C7(D2Client,000000,000000,10795C,11BFB8,11C2A8,11BFF4,000000,11D1D8, BYTE, DifficultyLevel);
C7(D2Client,000000,000000,000000,10A40C,11B414,101634,11B824,11C94C, DWORD, MouseY);//0x258 = 600
C7(D2Client,000000,000000,000000,10A410,11B418,101638,11B828,11C950, DWORD, MouseX);//0x320 = 800
C7(D2Client,000000,000000,000000,11C4F0,11C1E0,11C3D0,11BBFC,11D050, Unit*, ptClientChar);
C7(D2Client, DB918, DA828,000000,000000,000000,000000,000000, DWORD, NbStatDesc);
C7(D2Client, DAF98, D9EA8,000000,000000,000000,000000,000000, DWORD, StatDescTable);
C7(D2Client, DB918, DA828,000000,000000,000000,000000,000000,000000, DWORD, NbStatDesc);
C7(D2Client, DAF98, D9EA8,000000,000000,000000,000000,000000,000000, DWORD, StatDescTable);
/* NEXT NOT TESTED IN 1.10 (1.09b fct)
D2_STD(D2Common10066, void, D2RemoveFromRoom, (DrlgRoom1* hRoom, DWORD untitype, DWORD unitID), 0x6FD7CFD0);

118
Commons/VersionInfo.cpp Normal file
View File

@ -0,0 +1,118 @@
#include "VersionInfo.h"
#pragma comment(lib, "Version.Lib") //ïî ñðàâíåíèþ ñ Delphi 7 - òàêîé ãåììîðîé! :(
bool IsFile(char* sPath)
{
bool bFile = false;
HANDLE hFile = CreateFile
(
sPath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if(hFile != INVALID_HANDLE_VALUE)
{
CloseHandle(hFile);
bFile = true;
}
return bFile;
}
bool GetAppVersion(char* FileName, TFileVersion* VerInfo){ // ïîëó÷åíèå âåðñèè ôàéëà
VerInfo->full = -1;
if(!IsFile(FileName)){ // Ïðîâåðÿåì íàëè÷èå ôàéëà
return false; // Åñëè íåò ô-öèÿ íåóñïåøíà
}
DWORD FSize = GetFileVersionInfoSize(FileName,NULL); // ðàçìåð èíôû î âåðñèè ôàéëà
if(FSize==0){ // Åñëè 0 ôóíêöèÿ íåóñïåøíà
return false;
}
LPVOID pBlock = (char*)malloc(FSize); // àäðåñ áóôåðà äëÿ ðåñóðñîâ âåðñèè
GetFileVersionInfo(FileName,NULL,FSize,pBlock); // ïîëó÷àåì ðåñóðñ èíôîðìàöèè î âåðñèè
LPVOID MS;
UINT LS;
try{
VerQueryValue(pBlock,"\\",&MS,&LS); // èçâëåêàåì èíôîðìàöèþ èç ðåñóðñà
}
catch(...){
return false; // â ñëó÷àå îøèáêè ôóíêöèÿ íåóñïåøíà
}
VS_FIXEDFILEINFO FixedFileInfo; // ñòðóêòóðà ñ èíôîðìàöèåé î âåðñèè ôàéëà
memmove(&FixedFileInfo, MS, LS); // ïðèâîäèì èíôîðìàöèþ ê ñòðóêòóðå
DWORD FileVersionMS = FixedFileInfo.dwFileVersionMS;
DWORD FileVersionLS = FixedFileInfo.dwFileVersionLS;
VerInfo->major = HIWORD(FileVersionMS) ; // ïîëó÷àåì çíà÷åíèÿ
VerInfo->minor = LOWORD(FileVersionMS); // è ïðèñâàèâàåè èõ âõîäíîìó óêàçàòåëþ
VerInfo->revision = HIWORD(FileVersionLS);
VerInfo->subrevision = LOWORD(FileVersionLS);
return true; // ôóíêöèÿ óñïåøíà
}
#define SUBKEY "Software\\Blizzard Entertainment\\Diablo II"
#define GAMEFILE "\\Game.exe"
bool GetD2Path(char* buf, DWORD bufsize)
{
HKEY hKey;
DWORD type;
int res;
if (RegOpenKeyEx(HKEY_CURRENT_USER, SUBKEY, 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
res = RegQueryValueEx(hKey,"InstallPath",NULL,&type,(LPBYTE)buf,&bufsize);
RegCloseKey(hKey);
if (res!=ERROR_SUCCESS) return false;
} else if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, SUBKEY, 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
res = RegQueryValueEx(hKey,"InstallPath",NULL,&type,(LPBYTE)buf,&bufsize);
RegCloseKey(hKey);
if (res!=ERROR_SUCCESS) return false;
} else {
return false;
}
strcat(buf, GAMEFILE);
if (GetFileAttributes(buf) == INVALID_FILE_ATTRIBUTES)
return false;
return true;
};
int GetVerD2(TFileVersion GameVer)
{
if ((GameVer.major != 1)||(GameVer.minor != 0)) return -1;
switch (GameVer.revision)
{
case 9:
if (GameVer.subrevision == 20) return v109b;
if (GameVer.subrevision == 22) return v109d;
break;
case 10:
if (GameVer.subrevision == 39) return v110;
break;
case 11:
if (GameVer.subrevision == 45) return v111;
if (GameVer.subrevision == 46) return v111b;
break;
case 12:
if (GameVer.subrevision == 49) return v112;
break;
case 13:
if (GameVer.subrevision == 60) return v113c;
if (GameVer.subrevision == 64) return v113d;
break;
}
return -1;
}
int GetD2Version(char* PathGameExe)
{
TFileVersion GameVer = {-1};
if (! GetAppVersion(PathGameExe, &GameVer)) return -1;
int ver = GetVerD2(GameVer);
return ver;
}

30
Commons/VersionInfo.h Normal file
View File

@ -0,0 +1,30 @@
#include <windows.h>
union TFileVersion
{
__int64 full;
struct {
WORD subrevision;
WORD revision;
WORD minor;
WORD major;
};
WORD w[4];
};
enum eGameVersion
{
v109b=0,
v109d,
v110,
v111,
v111b,
v112,
v113c,
v113d,
v114a
};
bool GetAppVersion(char* FileName, TFileVersion* VerInfo); // ïîëó÷åíèå âåðñèè ôàéëà
bool GetD2Path(char* buf, DWORD bufsize);
int GetD2Version(char* PathGameExe);

7
PlugY/BigStash.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Use a more big stash
@ -78,16 +79,17 @@ void Install_BigStash()
log_msg("Patch D2Common & D2Client for make 10x10 squares in the stash. (BigStash)\n");
// modification of stash grid
mem_seek R7(D2Common, C9F3, CA03, 14ED3, 5FCB5, 2A505, 1BDB5, 82CA5);
mem_seek R7(D2Common, C9F3, CA03, 14ED3, 5FCB5, 2A505, 1BDB5, 82CA5, 6CC25);
MEMC_REF4( D2CompileTxtFile, caller_modifStashGrid);
//01B64ED2 |. E8 99AEFFFF CALL D2Common.#10578
//6FDAFCB4 |. E8 A7C3FCFF CALL D2Common.#10653
//6FD7A504 |. E8 5743FEFF CALL D2Common.#10496 ; \#10496
//6FD6BDB4 |. E8 97600200 CALL D2Common.#10244 ; \#10244
//6FDD2CA4 |. E8 97C2FDFF CALL D2Common.#10849 ; \#10849
//6FDBCC24 |. E8 B7FEF9FF CALL D2Common.#10037 ; \#10037
// modification of stash background
mem_seek R7(D2Client, 45B1C, 45B1C, 4C61C, A643C, 749BC, A9D7C, 8CC1C);
mem_seek R7(D2Client, 45B1C, 45B1C, 4C61C, A643C, 749BC, A9D7C, 8CC1C, 943FC);
memt_byte( 0x68, 0xE8 ); // CALL caller_changeTradeStash
MEMT_REF4( 0x00000104, caller_changeTradeStash);
//6FAEC61C |. 68 04010000 PUSH 104
@ -95,6 +97,7 @@ void Install_BigStash()
//6FB249BC |. 68 04010000 PUSH 104
//6FB59D7C |. 68 04010000 PUSH 104
//6FB3CC1C |. 68 04010000 PUSH 104
//6FB443FC |. 68 04010000 PUSH 104
log_msg("\n");

34
PlugY/Commands.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Updating server.
@ -15,6 +16,7 @@
#include "newInterface_CubeListing.h"
#include "extraOptions.h"
bool active_Commands=true;
bool active_listAllCubeFormula=true;
@ -140,13 +142,15 @@ void updateSharedGold(DWORD goldAmount)
int STDCALL commands (char* ptText)
{
//return 0;
Unit* ptChar = D2GetClientPlayer();
//return 0;
char command[MAX_CMD_SIZE];
ZeroMemory(command,MAX_CMD_SIZE);
//return 0;
strncpy(command,ptText,MAX_CMD_SIZE-1);
strlwr(command);
//return 0;
strlwr(command);
if (!strncmp(command,CMD_RENAME,strlen(CMD_RENAME)))
{
if (!active_multiPageStash) return 1;
@ -220,7 +224,6 @@ int STDCALL commands (char* ptText)
active_AlwaysDisplayLifeMana = !active_AlwaysDisplayLifeMana;
return 0;
}
return 1;
}
@ -248,6 +251,19 @@ MANAGESOUNDCHAOSDEBUG:
RETN 8
}}
FCT_ASM ( caller_Commands_113d )
TEST EAX,EAX
JE MANAGESOUNDCHAOSDEBUG
PUSH EDI
CALL commands
TEST EAX,EAX
JNZ MANAGESOUNDCHAOSDEBUG
ADD DWORD PTR SS:[ESP],7
MANAGESOUNDCHAOSDEBUG:
RETN 8
}}
void Install_Commands()
{
static int isInstalled = false;
@ -261,9 +277,9 @@ void Install_Commands()
active_savegame = version_D2Common >= V111;
// Run custom commmand
mem_seek R7(D2Client, 2C120, 2C110, 32BDD, C1EE6, 91C16, 86926, 70AE6);
memt_byte( 0x83, 0xE8 ); // CALL
MEMT_REF4( 0xC08508C4 , version_D2Client >= V111 ? caller_Commands_111 : caller_Commands);
mem_seek R7(D2Client, 2C120, 2C110, 32BDD, C1EE6, 91C16, 86926, 70AE6, B1FD6);
memt_byte( 0x83, 0xE8 ); // CALL
MEMT_REF4( 0xC08508C4 , version_D2Client == V113d ? caller_Commands_113d : version_D2Client >= V111 ? caller_Commands_111 : caller_Commands);
//6FB71EE6 . 83C4 08 ADD ESP,8
//6FB71EE7 . 85C0 TEST EAX,EAX
//6FB41C16 |. 83C4 08 ADD ESP,8
@ -272,9 +288,9 @@ void Install_Commands()
//6FB36929 |. 85C0 TEST EAX,EAX
//6FB20AE6 |. 83C4 08 ADD ESP,8
//6FB20AE9 |. 85C0 TEST EAX,EAX
//6FB20AE6 |. 83C4 08 ADD ESP,8
//6FB20AE9 |. 85C0 TEST EAX,EAX
//6FB61FD6 |. 83C4 08 ADD ESP,8
//6FB61FD9 |. 85C0 TEST EAX,EAX
log_msg("\n");
isInstalled = true;

540
PlugY/Common.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
*Modified by L'Autour.
Common functions.
@ -8,9 +9,12 @@
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "INIfile.h"
#define sPlugyExt ".\\PlugY\\PlugYLocal.dll"
s_shifting shifting;
bool isOnRect(DWORD x, DWORD y, DWORD x0, DWORD y0, DWORD l, DWORD h)
{return (x>=x0) && (x<x0+l) && (y>y0-h) && (y<=y0);}
@ -22,445 +26,120 @@ void freeMessage(sWinMessage* msg)
D2FreeWinMessage(msg);
}
//MS C++__fastcall(ecx,edx,) vs Delphi register(eax,edx,ecx) - :(
LPWSTR getString(LPWSTR eng, LPWSTR esp, LPWSTR deu, LPWSTR fra, LPWSTR por, LPWSTR ita, LPWSTR jpn, LPWSTR kor, LPWSTR sin, LPWSTR chi, LPWSTR pol, LPWSTR rus)
typedef int (__stdcall *p_UCS2toUTF8)(char*, int, LPWSTR, int);
p_UCS2toUTF8 _UCS2toUTF8;
int UCS2toUTF8(char* dst, int maxdst, LPWSTR src, int lensrc)
{
switch(D2GetLang())
{
case LNG_ENG: return eng;
case LNG_ESP: return esp;
case LNG_DEU: return deu;
case LNG_FRA: return fra;
case LNG_POR: return por;
case LNG_ITA: return ita;
case LNG_JPN: return jpn;
case LNG_KOR: return kor;
case LNG_SIN: return sin;
case LNG_CHI: return chi;
case LNG_POL: return pol;
case LNG_RUS: return rus;
case LNG_DEF:
default: return eng;
}
if (_UCS2toUTF8 == NULL) return 0;
return _UCS2toUTF8(dst, maxdst, src, lensrc);
}
#define LANGUAGE(I,ENG,FRA,DEU,ITA,ESP,POL/*,CHI*/) case I : return getString(L##ENG,L##ESP,L##DEU,L##FRA,L##ENG,L##ITA,L##ENG,L##ENG,L##ENG,L##ENG,L##POL,L##ENG)
typedef int (__stdcall *p_UTF8toUCS2)(LPWSTR, int, char*, int);
p_UTF8toUCS2 _UTF8toUCS2;
int UTF8toUCS2(LPWSTR dst, int maxdst, char* src, int lensrc)
{
if (_UTF8toUCS2 == NULL) return 0;
return _UTF8toUCS2(dst, maxdst, src, lensrc);
}
typedef const LPWSTR(__fastcall *p_getTypeString)(DWORD, char**);
p_getTypeString _getTypeString;
const LPWSTR getTypeString(DWORD code, char** IdxStr)
{
if (_getTypeString == NULL) return L"#";
return _getTypeString(code, IdxStr);
}
typedef LPWSTR(__fastcall *p_getTranslatedString)(int);
p_getTranslatedString _getTranslatedString;
LPWSTR getTranslatedString(int stringID)
{
switch(stringID)
{
/* LANGUAGE2( STR_STATS_UNASSIGN_WITH_LIMIT,
"+Alt: ;,+Shift: %d \x70B9\x6570",//"+Alt: Unassign, +Shift: by %d points",
// "+Alt: \x91CD\x5206\x914D;,+Shift: %d \x70B9\x6570",//"+Alt: Unassign, +Shift: by %d points",
"+Alt: Désallocation, +Shift: par %d points,",
"+Alt: Zurücksetzen, +Shift: um %d Punkte",
"+Alt: Rimuovi, +Shift: Assegna %d punti",
"+Alt: Quita, +Shift: por %d puntos",
"+Alt: \37325\20998\37197;,+Shift:%d \28857\25968");
*/
LANGUAGE( STR_STATS_UNASSIGN_WITH_LIMIT,
"+Alt: Unassign, +Shift: by %d points",
"+Alt: Désallocation, +Shift: par %d points",
"+Alt: Zurücksetzen, +Shift: um %d Punkte",
"+Alt: Rimuovi, +Shift: Assegna %d punti",
"+Alt: Quita, +Shift: por %d puntos",
"+Alt: Odejmij, +Shift: %d punktów");
// "+Alt: ????, +Shift: %d ??");
if (_getTranslatedString == NULL) return L"#";
return _getTranslatedString(stringID);
}
LANGUAGE( STR_STATS_UNASSIGN_WITHOUT_LIMIT,
"+Alt: Unassign, +Shift: all remaining points",
"+Alt: Désallocation, +Shift: Tous les points restants",
"+Alt: Zurücksetzen, +Shift: Alle verbleibenden Punkte",
"+Alt: Rimuovi, +Shift: Assegna tutti i punti rimanenti",
"+Alt: Quita, +Shift: Todos los puntos restantes",
"+Alt: Odejmij, +Shift: wszystkie pozostale punkty");
// "+Alt: ????, +Shift: ???");
typedef int(__stdcall *p_wSprintStringLastGender)(LPWSTR, int, int);
p_wSprintStringLastGender _wSprintStringLastGender;
LANGUAGE( STR_STATS_BASE_MIN,
"Base: %d (Min: %d)",
"Base: %d (Min: %d)",
"Basiswert: %d (Min: %d)",
"Base: %d (Min: %d)",
"Base: %d (Min: %d)",
"Bazowo: %d (Minimum: %d)");
// "??: %d(??: %d)");
int wSprintStringLastGender(LPWSTR buf, int lenbuf,int stringID)
{
if (_wSprintStringLastGender == NULL) return 0;
return _wSprintStringLastGender(buf, lenbuf, stringID);
}
LANGUAGE( STR_SKILLS_UNASSIGN,
"Un-allocate all skills points",
"Désalloue tous les points d'aptitudes",
"Alle Fertigkeitspunkte zurücksetzen",
"Rimuovi tutte le abilità",
"Quita todos los puntos de habilidades",
"Rozdaj od nowa wszystkie punkty umiejetnosci");
// "????????");
typedef LPWSTR(__fastcall *p_cutStringGender)(LPWSTR);
p_cutStringGender _cutStringGender;
LANGUAGE( STR_STASH_PREVIOUS_PAGE,
"Previous Page (+shift: First Page)",
"Page précédente (+shift: Première page)",
"Vorherige Seite (+shift: Erste Seite)",
"Pagina Precedente (+shift: Prima Pagina)",
"Pagina anterior (+shift: Primera Pagina)",
"Poprzednia Strona (+shift: Pierwsza Strona)");
// "??? (+shift: ??)");
LPWSTR cutStringGender(LPWSTR str)
{
if (_cutStringGender == NULL) return str;
return _cutStringGender(str);
}
LANGUAGE( STR_STASH_NEXT_PAGE,
"Next Page (+shift: Last not empty Page)",
"Page suivante (+shift: Dernière page non vide)",
"Nächste Seite (+shift: Letzte nicht leere Seite )",
"Pagina Successiva (+shift: Ultima Pagina non vuota)",
"Pagina Siguiente (+shift: Ultima pagina non vacia)",
"Nastepna Strona (+shift: Ostatnia nie pusta Strona)");
// "??? (+shift: ?????");
typedef LPWSTR(__fastcall *p_setMonoString)(LPWSTR);
p_setMonoString _setMonoString;
LANGUAGE( STR_TOGGLE_TO_PERSONAL,
"Toggle to Personal Stash",
"Voir coffre personnel",
"Wechselt zum persönlichen Goldschatz",
"Vai all'Inventario Personale",
"Ver el cofre personal",
"Przejdz do Skrzyni Osobistej");
// "????????");
LANGUAGE( STR_TOGGLE_TO_SHARED,
"Toggle to Shared Stash",
"Voir coffre partagé",
"Wechselt zum gemeinsamen Goldschatz",
"Vai all'Inventario Condiviso",
"Ver el cofre compartido",
"Przejdz do Skrzyni Wspólnej");
// "????????");
LANGUAGE( STR_STASH_PREVIOUS_INDEX,
"Previous Index : by %d Pages (+Shift: %d)",
"Index précédent : par %d pages (+shift: %d)",
"Vorheriger Index: in %d Seiten (+shift: %d)",
"Schermata Precedente : Indietro di %d Pagine (+Shift: %d)",
"Indice anterior : por %d paginas (+shift: %d)",
"Poprzednia Strona : po %d Stron (+Shift: %d)");
// "???? : %d ? (+Shift:%d)");
LANGUAGE( STR_STASH_NEXT_INDEX,
"Next Index : by %d Pages (+shift: %d)",
"Index suivant : par %d pages (+shift: %d)",
"Nächster Index: in %d Seiten (+shift: %d)",
"Schermata Successiva : Avanti di %d Pagine (+shift: %d)",
"Indice siguiente : por %d paginas (+shift: %d)",
"Nastepna Strona : po %d Stron (+shift: %d)");
// "???? : %d ? (+shift:%d)");
LANGUAGE( STR_PUT_GOLD,
"Put Gold",
"Poser de l'Or",
"Gib Gold",
"Immetti Oro",
"Poner oro",
"Zdeponuj Zloto");
// "????");
LANGUAGE( STR_TAKE_GOLD,
"Take Gold",
"Prendre de l'Or",
"Nehme Gold",
"Ritira Oro",
"Tomar oro",
"Wyplac zloto");
// "????");
LANGUAGE( STR_PERSONAL_PAGE_NUMBER,
"Personal Page n°%u",
"Page perso n°%u",
"Persönliche Seite n°%u",
"Pagina Personale n°%u",
"Pagina personal n°%u",
"Strona Osobista n°%u");
// "????? n°%u");
LANGUAGE( STR_SHARED_PAGE_NUMBER,
"Shared Page n°%u",
"Page partagée n°%u",
"Gemeinsame Seite n°%u",
"Pagina Condivisa n°%u",
"Pagina personal n°%u",
"Strona Wspólna n°%u");
// "????? n°%u");
LANGUAGE( STR_NO_SELECTED_PAGE,
"No selected page",
"Aucune page sélectionnée",
"Keine ausgewählte Seite",
"Nessuna pagina selezionata",
"Ninguna pagina seleccionada",
"Nie zaznaczono strony");
// "????");
LANGUAGE( STR_SHARED_GOLD_QUANTITY,
"Shared Gold : %u",
"Or partagé : %u",
"Gemeinsamen Gold : %u",
"Oro Condiviso : %u",
"Oro compartido : %u",
"Wspólne Zloto : %u");
// "????: %u");
LANGUAGE( STR_PREVIOUS_PAGE,
"Previous Page",
"Page précédente",
"Vorherige Seite",
"Pagina Precedente",
"Pagina anterior",
"Poprzednia Strona");
// "???");
LANGUAGE( STR_NEXT_PAGE,
"Next Page",
"Page suivante",
"Nächste Seite",
"Pagina Successiva",
"Pagina siguiente",
"Nastepna Strona");
// "???");
default : return L"";
}
LPWSTR setMonoString(LPWSTR str)
{
if (_setMonoString == NULL) return str;
return _setMonoString(str);
}
/*=================================================================*/
typedef bool(__fastcall *p_initTranslatedString)(int);
const char* SNONE="";
const char* c_shie[3]={"Shield (Not Class Specific)",SNONE,SNONE};
const char* c_tors[3]={"Body Armor",SNONE,SNONE};
const char* c_gold[3]={"Gold",SNONE,SNONE};
const char* c_bowq[3]={"Arrow",SNONE,SNONE};
const char* c_xboq[3]={"Bolt",SNONE,SNONE};
const char* c_play[3]={"Ear",SNONE,SNONE};
const char* c_herb[3]={"Herb",SNONE,SNONE};
const char* c_poti[3]={"Potion",SNONE,SNONE};
const char* c_ring[3]={"Ring",SNONE,SNONE};
const char* c_elix[3]={"Elixir",SNONE,SNONE};
const char* c_amul[3]={"Amulet",SNONE,SNONE};
const char* c_char[3]={"Charm",SNONE,SNONE};
const char* c_boot[3]={"Boot",SNONE,SNONE};
const char* c_glov[3]={"Glove",SNONE,SNONE};
const char* c_book[3]={"Book",SNONE,SNONE};
const char* c_belt[3]={"Belt",SNONE,SNONE};
const char* c_gem[3]={"Gem",SNONE,SNONE};
const char* c_torc[3]={"Torch",SNONE,SNONE};
const char* c_scro[3]={"Scroll",SNONE,SNONE};
const char* c_scep[3]={"Scepter",SNONE,SNONE};
const char* c_wand[3]={"Wand",SNONE,SNONE};
const char* c_staf[3]={"Staff",SNONE,SNONE};
const char* c_bow[3]={"Bow",SNONE,SNONE};
const char* c_axe[3]={"Axe",SNONE,SNONE};
const char* c_club[3]={"Club",SNONE,SNONE};
const char* c_swor[3]={"Sword",SNONE,SNONE};
const char* c_hamm[3]={"Hammer",SNONE,SNONE};
const char* c_knif[3]={"Knife",SNONE,SNONE};
const char* c_spea[3]={"Spear",SNONE,SNONE};
const char* c_pole[3]={"Polearm",SNONE,SNONE};
const char* c_xbow[3]={"Crossbow",SNONE,SNONE};
const char* c_mace[3]={"Mace",SNONE,SNONE};
const char* c_helm[3]={"Helm",SNONE,SNONE};
HINSTANCE PlugyLocalLib = NULL;
const char* c_tpot[3]={"Missile Potion",SNONE,SNONE};
const char* c_ques[3]={"Quest Item",SNONE,SNONE};
const char* c_body[3]={"Body Part",SNONE,SNONE};
const char* c_key[3]={"Key",SNONE,SNONE};
const char* c_tkni[3]={"Throwing Knife",SNONE,SNONE};
const char* c_taxe[3]={"Throwing Axe",SNONE,SNONE};
const char* c_jave[3]={"Javelin",SNONE,SNONE};
const char* c_weap[3]={"Weapon",SNONE,SNONE};
const char* c_mele[3]={"Melee Weapon",SNONE,SNONE};
const char* c_miss[3]={"Missile Weapon",SNONE,SNONE};
const char* c_thro[3]={"Throwing Weapon",SNONE,SNONE};
const char* c_comb[3]={"Combo Weapon",SNONE,SNONE};
const char* c_armo[3]={"Armor",SNONE,SNONE};
const char* c_shld[3]={"Any Shield",SNONE,SNONE};
const char* c_misc[3]={"Miscellaneous",SNONE,SNONE};
const char* c_sock[3]={"Socket Filler",SNONE,SNONE};
const char* c_seco[3]={"Second Hand Item",SNONE,SNONE};
const char* c_rod[3]={"Staves And Rods",SNONE,SNONE};
const char* c_misl[3]={"Missile",SNONE,SNONE};
const char* c_blun[3]={"Blunt",SNONE,SNONE};
const char* c_jewl[3]={"Jewel",SNONE,SNONE};
const char* c_clas[3]={"Class Specific",SNONE,SNONE};
const char* c_amaz[3]={"Amazon Item",SNONE,SNONE};
const char* c_barb[3]={"Barbarian Item",SNONE,SNONE};
const char* c_necr[3]={"Necromancer Item",SNONE,SNONE};
const char* c_pala[3]={"Paladin Item",SNONE,SNONE};
const char* c_sorc[3]={"Sorceress Item",SNONE,SNONE};
const char* c_assn[3]={"Assassin Item",SNONE,SNONE};
const char* c_drui[3]={"Druid Item",SNONE,SNONE};
const char* c_h2h[3]={"Claw",SNONE,SNONE};
const char* c_orb[3]={"Orb",SNONE,SNONE};
const char* c_head[3]={"Voodoo Heads",SNONE,SNONE};
const char* c_ashd[3]={"Paladin Shield",SNONE,SNONE};
const char* c_phlm[3]={"Barbarian Helm",SNONE,SNONE};
const char* c_pelt[3]={"Druid Helm",SNONE,SNONE};
const char* c_cloa[3]={"Cloak",SNONE,SNONE};
const char* c_rune[3]={"Rune",SNONE,SNONE};
const char* c_circ[3]={"Circlet",SNONE,SNONE};
const char* c_hpot[3]={"Healing Potion",SNONE,SNONE};
const char* c_mpot[3]={"Mana Potion",SNONE,SNONE};
const char* c_rpot[3]={"Rejuvenation potion",SNONE,SNONE};
const char* c_spot[3]={"Stamina Potion",SNONE,SNONE};
const char* c_apot[3]={"Antidote Potion",SNONE,SNONE};
const char* c_wpot[3]={"Thawing Potion",SNONE,SNONE};
const char* c_scha[3]={"Small Charm",SNONE,SNONE};
const char* c_mcha[3]={"Large Charm",SNONE,SNONE};
const char* c_lcha[3]={"Grand Charm",SNONE,SNONE};
const char* c_abow[3]={"Amazon Bow",SNONE,SNONE};
const char* c_aspe[3]={"Amazon Spear",SNONE,SNONE};
const char* c_ajav[3]={"Amazon Javelin",SNONE,SNONE};
const char* c_h2h2[3]={"Assassin Claw",SNONE,SNONE};
const char* c_mboq[3]={"Magic Arrow",SNONE,SNONE};
const char* c_mxbq[3]={"Magic Bolt",SNONE,SNONE};
const char* c_gem0[3]={"Chipped Gem",SNONE,SNONE};
const char* c_gem1[3]={"Flawed Gem",SNONE,SNONE};
const char* c_gem2[3]={"Normal Gem",SNONE,SNONE};
const char* c_gem3[3]={"Flawless Gem",SNONE,SNONE};
const char* c_gem4[3]={"Perfect Gem",SNONE,SNONE};
const char* c_gema[3]={"Amethyst",SNONE,SNONE};
const char* c_gemd[3]={"Diamond",SNONE,SNONE};
const char* c_geme[3]={"Emerald",SNONE,SNONE};
const char* c_gemr[3]={"Ruby",SNONE,SNONE};
const char* c_gems[3]={"Sapphire",SNONE,SNONE};
const char* c_gemt[3]={"Topaz",SNONE,SNONE};
const char* c_gemz[3]={"Skull",SNONE,SNONE};
const char* getTypeString (DWORD code)
bool initLocaleStrings()
{
DWORD lang = 0;//D2GetLang();
if ((lang == LNG_FRA) || (lang == LNG_DEU)) lang--;
else lang = 0;
switch (code)
{
case BIN('s','h','i','e') : return c_shie[0];
case BIN('t','o','r','s') : return c_tors[0];
case BIN('g','o','l','d') : return c_gold[0];
case BIN('b','o','w','q') : return c_bowq[0];
case BIN('x','b','o','q') : return c_xboq[0];
case BIN('p','l','a','y') : return c_play[0];
case BIN('h','e','r','b') : return c_herb[0];
case BIN('p','o','t','i') : return c_poti[0];
case BIN('r','i','n','g') : return c_ring[0];
case BIN('e','l','i','x') : return c_elix[0];
case BIN('a','m','u','l') : return c_amul[0];
case BIN('c','h','a','r') : return c_char[0];
case BIN('b','o','o','t') : return c_boot[0];
case BIN('g','l','o','v') : return c_glov[0];
case BIN('b','o','o','k') : return c_book[0];
case BIN('b','e','l','t') : return c_belt[0];
case BIN('g','e','m',' ') : return c_gem[0];
case BIN('t','o','r','c') : return c_torc[0];
case BIN('s','c','r','o') : return c_scro[0];
case BIN('s','c','e','p') : return c_scep[0];
case BIN('w','a','n','d') : return c_wand[0];
case BIN('s','t','a','f') : return c_staf[0];
case BIN('b','o','w',' ') : return c_bow[0];
case BIN('a','x','e',' ') : return c_axe[0];
case BIN('c','l','u','b') : return c_club[0];
case BIN('s','w','o','r') : return c_swor[0];
case BIN('h','a','m','m') : return c_hamm[0];
case BIN('k','n','i','f') : return c_knif[0];
case BIN('s','p','e','a') : return c_spea[0];
case BIN('p','o','l','e') : return c_pole[0];
case BIN('x','b','o','w') : return c_xbow[0];
case BIN('m','a','c','e') : return c_mace[0];
case BIN('h','e','l','m') : return c_helm[0];
case BIN('t','p','o','t') : return c_tpot[0];
case BIN('q','u','e','s') : return c_ques[0];
case BIN('b','o','d','y') : return c_body[0];
case BIN('k','e','y',' ') : return c_key[0];
case BIN('t','k','n','i') : return c_tkni[0];
case BIN('t','a','x','e') : return c_taxe[0];
case BIN('j','a','v','e') : return c_jave[0];
case BIN('w','e','a','p') : return c_weap[0];
case BIN('m','e','l','e') : return c_mele[0];
case BIN('m','i','s','s') : return c_miss[0];
case BIN('t','h','r','o') : return c_thro[0];
case BIN('c','o','m','b') : return c_comb[0];
case BIN('a','r','m','o') : return c_armo[0];
case BIN('s','h','l','d') : return c_shld[0];
case BIN('m','i','s','c') : return c_misc[0];
case BIN('s','o','c','k') : return c_sock[0];
case BIN('s','e','c','o') : return c_seco[0];
case BIN('r','o','d',' ') : return c_rod[0];
case BIN('m','i','s','l') : return c_misl[0];
case BIN('b','l','u','n') : return c_blun[0];
case BIN('j','e','w','l') : return c_jewl[0];
case BIN('c','l','a','s') : return c_clas[0];
case BIN('a','m','a','z') : return c_amaz[0];
case BIN('b','a','r','b') : return c_barb[0];
case BIN('n','e','c','r') : return c_necr[0];
case BIN('p','a','l','a') : return c_pala[0];
case BIN('s','o','r','c') : return c_sorc[0];
case BIN('a','s','s','n') : return c_assn[0];
case BIN('d','r','u','i') : return c_drui[0];
case BIN('h','2','h',' ') : return c_h2h[0];
case BIN('h','2','h','2') : return c_h2h2[0];
case BIN('o','r','b',' ') : return c_orb[0];
case BIN('h','e','a','d') : return c_head[0];
case BIN('a','s','h','d') : return c_ashd[0];
case BIN('p','h','l','m') : return c_phlm[0];
case BIN('p','e','l','t') : return c_pelt[0];
case BIN('c','l','o','a') : return c_cloa[0];
case BIN('r','u','n','e') : return c_rune[0];
case BIN('c','i','r','c') : return c_circ[0];
case BIN('h','p','o','t') : return c_hpot[0];
case BIN('m','p','o','t') : return c_mpot[0];
case BIN('r','p','o','t') : return c_rpot[0];
case BIN('s','p','o','t') : return c_spot[0];
case BIN('a','p','o','t') : return c_apot[0];
case BIN('w','p','o','t') : return c_wpot[0];
case BIN('s','c','h','a') : return c_scha[0];
case BIN('m','c','h','a') : return c_mcha[0];
case BIN('l','c','h','a') : return c_lcha[0];
case BIN('a','b','o','w') : return c_abow[0];
case BIN('a','s','p','e') : return c_aspe[0];
case BIN('a','j','a','v') : return c_ajav[0];
case BIN('m','b','o','q') : return c_mboq[0];
case BIN('m','x','b','q') : return c_mxbq[0];
case BIN('g','e','m','0') : return c_gem0[0];
case BIN('g','e','m','1') : return c_gem1[0];
case BIN('g','e','m','2') : return c_gem2[0];
case BIN('g','e','m','3') : return c_gem3[0];
case BIN('g','e','m','4') : return c_gem4[0];
case BIN('g','e','m','a') : return c_gema[0];
case BIN('g','e','m','d') : return c_gemd[0];
case BIN('g','e','m','e') : return c_geme[0];
case BIN('g','e','m','r') : return c_gemr[0];
case BIN('g','e','m','s') : return c_gems[0];
case BIN('g','e','m','t') : return c_gemt[0];
case BIN('g','e','m','z') : return c_gemz[0];
default: return NULL;
}
p_initTranslatedString initTranslatedString;
PlugyLocalLib = LoadLibrary(sPlugyExt);
if (PlugyLocalLib != NULL)
{
log_msg("Loading PlugYLocal.dll\n");
initTranslatedString = (p_initTranslatedString)GetProcAddress(PlugyLocalLib, "__fastcall initTranslatedString");
if (NULL != initTranslatedString)
{
log_msg("Loading local strings from PlugYLocal.ini\n");
_UCS2toUTF8 = (p_UCS2toUTF8)GetProcAddress(PlugyLocalLib, "__stdcall UCS2toUTF8");
_UTF8toUCS2 = (p_UTF8toUCS2)GetProcAddress(PlugyLocalLib, "__stdcall UTF8toUCS2");
_getTypeString = (p_getTypeString)GetProcAddress(PlugyLocalLib, "__fastcall getTypeString");
_cutStringGender = (p_cutStringGender)GetProcAddress(PlugyLocalLib, "__fastcall cutStringGender");
_wSprintStringLastGender = (p_wSprintStringLastGender)GetProcAddress(PlugyLocalLib, "__stdcall wSprintStringLastGender");
_setMonoString = (p_setMonoString)GetProcAddress(PlugyLocalLib, "__fastcall setMonoString");
_getTranslatedString = (p_getTranslatedString)GetProcAddress(PlugyLocalLib, "__fastcall getTranslatedString");
if ((NULL != _getTranslatedString) &&
(NULL != _getTypeString))
{
initTranslatedString(D2GetLang());
return true;
}
log_msg("Failed loading local strings\n");
}
if (FreeLibrary(PlugyLocalLib))
{
PlugyLocalLib = NULL;
}
} else log_msg("Failed loading PlugYLocal.dll\n");
return false;
}
char* getTypeAString (WORD id, char* lpText, DWORD size)
void freeLocaleStrings()
{
ItemTypesBIN* itemTypeData = D2GetItemTypesBIN(id);
if (!itemTypeData)
{
strncpy(lpText, "Bad Type", size);
return lpText;
}
const char* string = getTypeString(itemTypeData->code);
if (!string)
{
struct {
DWORD code;
BYTE zero;
} code;
code.code = itemTypeData->code;
code.zero = 0;
strncpy(lpText, (char*)&code, size);
} else
strncpy(lpText, string, size);
return lpText;
if (PlugyLocalLib == NULL) return;
FreeLibrary(PlugyLocalLib);
}
LPWSTR getTypeUString (WORD id, LPWSTR lpText, DWORD size)
@ -468,22 +147,35 @@ LPWSTR getTypeUString (WORD id, LPWSTR lpText, DWORD size)
ItemTypesBIN* itemTypeData = D2GetItemTypesBIN(id);
if (!itemTypeData)
{
mbstowcs(lpText, "Bad Type", size);
wcsncpy(lpText, L"Bad Type", size);
return lpText;
}
const char* string = getTypeString(itemTypeData->code);
char* idxstr;
LPWSTR string = getTypeString(itemTypeData->code, &idxstr);
if (idxstr)
{
LPWSTR string2 = D2GetStringFromString(idxstr);
if (string2)
{
wcsncpy(lpText, string2, size);
return lpText;
}
}
if (!string)
{
struct {
DWORD code;
BYTE zero;
} code;
} code;
code.code = itemTypeData->code;
code.zero = 0;
mbstowcs(lpText, (char*)&code, size);
UTF8toUCS2(lpText,size, (char*)&code, 0xFFFF);
} else
mbstowcs(lpText, string, size);
wcsncpy(lpText, string, size);
return lpText;
}
/*================================= END OF FILE =================================*/

41
PlugY/D2functions.cpp
View File

@ -1,5 +1,6 @@
/*================================================
File created by Yohann NICOLAS.
*Add support 1.13d by L'Autour.
This file implements some common and useful
function related to some Diablo II mechanisms.
@ -16,9 +17,9 @@
#define E2S(F, A, R, N, P) T##N N;
#define E2F(F, A, R, N, P) T##N N;
#define E2C(F, A, T, N) T* pt##N;
#define F7(X, Z, A,B,C,D,E,F,G, R, N, P) T##N N;
#define A7(X, Z, A,B,C,D,E,F,G, R, N, P) T##N N;
#define C7(Z, A,B,C,D,E,F,G, T, N) T* pt##N;
#define F7(X, Z, A,B,C,D,E,F,G,H, R, N, P) T##N N;
#define A7(X, Z, A,B,C,D,E,F,G,H, R, N, P) T##N N;
#define C7(Z, A,B,C,D,E,F,G,H, T, N) T* pt##N;
#include "../Commons/D2Funcs.h"
DataTables* SgptDataTables;
@ -616,12 +617,12 @@ bool initD2functions()
#define E2S(F, A, R, N, P) N = (T##N)(offset_##F + 0x##A);
#define E2F(F, A, R, N, P) N = (T##N)(offset_##F + 0x##A);
#define E2C(F, A, T, N) pt##N = (T*)(offset_##F + 0x##A);
#define F7(X, Z, A,B,C,D,E,F,G, R, N, P) setFctAddr((DWORD*)&N, (HMODULE)offset_##Z, (LPCSTR)((version_##Z == V113? G : (version_##Z == V112? F : version_##Z == V111b? E : (version_##Z == V111? D : (version_##Z == V110? C : (version_##Z == V109d? B : A)))))));
#define A7(X, Z, A,B,C,D,E,F,G, R, N, P) N = (T##N)R7(Z,A,B,C,D,E,F,G);
#define C7(Z, A,B,C,D,E,F,G, T, N) pt##N = (T*)R7(Z,A,B,C,D,E,F,G);
#define F7(X, Z, A,B,C,D,E,F,G,H, R, N, P) setFctAddr((DWORD*)&N, (HMODULE)offset_##Z, (LPCSTR)((version_##Z == V113d? H : (version_##Z == V113c? G : (version_##Z == V112? F : (version_##Z == V111b? E : (version_##Z == V111? D : (version_##Z == V110? C : (version_##Z == V109d? B : A)))))))));
#define A7(X, Z, A,B,C,D,E,F,G,H, R, N, P) N = (T##N)R7(Z,A,B,C,D,E,F,G,H);
#define C7(Z, A,B,C,D,E,F,G,H, T, N) pt##N = (T*)R7(Z,A,B,C,D,E,F,G,H);
#include "../Commons/D2Funcs.h"
SgptDataTables = *(DataTables**) R7(D2Common, 0000, 0000, 96A20, 9B74C, 9EE8C, 9B500, 99E1C);
SgptDataTables = *(DataTables**) R7(D2Common, 0000, 0000, 96A20, 9B74C, 9EE8C, 9B500, 99E1C, A33F0);
if (version_D2Common < V110)
{
D2S(D2Common,10581, CharStatsBIN*, D2Common10581, (DWORD charID));//ONLY in 1.09
@ -915,10 +916,10 @@ bool initD2functions()
D2GetClientPlayer = D2GetClientPlayer_111;
D2GetRealItem = D2GetRealItem_111;
D2CleanStatMouseUp = D2CleanStatMouseUp_111;
StatMouse1 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C004, 11C2F4, 11C040, 11C3DC);
StatMouse2 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C008, 11C2F8, 11C044, 11C3E0);
StatMouse3 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C020, 11C310, 11C05C, 11C3F8);
StatMouse4 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C024, 11C314, 11C060, 11C3FC);
StatMouse1 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C004, 11C2F4, 11C040, 11C3DC, 11D224);
StatMouse2 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C008, 11C2F8, 11C044, 11C3E0, 11D228);
StatMouse3 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C020, 11C310, 11C05C, 11C3F8, 11D240);
StatMouse4 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C024, 11C314, 11C060, 11C3FC, 11D244);
} else {
D2SendToServer = (TD2SendToServer) D2SendToServer_1XX;
D2GetGameByClientID = (TD2GetGameByClientID) D2GetGameByClientID_1XX;
@ -946,16 +947,16 @@ bool initD2functions()
//////////////// STRUCTURE MANAGEMENT ////////////////
//L'Autour - ??????
// shifting.ptPYPlayerData = V7(D2Common,118,118,F4,F4,F4,F4,F4);
shifting.ptPYPlayerData = *(DWORD*)((DWORD)D2InitPlayerData + V7(D2Common,5D,5D,5D,49,49,49,49));
shifting.ptSpecificData = V7(D2Common,70,70,14,14,14,14,14);
shifting.ptGame = V7(D2Common,A4,A4,80,80,80,80,80);
shifting.ptClientGame = V7(D2Common,170,194,1A8,1A8,1A8,1A8,1A8);
shifting.ptInventory = V7(D2Common,84,84,60,60,60,60,60);
shifting.ptSkills = V7(D2Common,CC,CC,A8,A8,A8,A8,A8);
shifting.ptImage = V7(D2Common,04,04,04,08,08,3C,34);
shifting.ptFrame = V7(D2Common,08,08,08,44,44,40,00);
shifting.ptPYPlayerData = *(DWORD*)((DWORD)D2InitPlayerData + V7(D2Common,5D,5D,5D,49,49,49,49,49));
shifting.ptSpecificData = V7(D2Common,70,70,14,14,14,14,14,14);
shifting.ptGame = V7(D2Common,A4,A4,80,80,80,80,80,80);
shifting.ptClientGame = V7(D2Common,170,194,1A8,1A8,1A8,1A8,1A8,1A8);
shifting.ptInventory = V7(D2Common,84,84,60,60,60,60,60,60);
shifting.ptSkills = V7(D2Common,CC,CC,A8,A8,A8,A8,A8,A8);
shifting.ptImage = V7(D2Common,04,04,04,08,08,3C,34,34);
shifting.ptFrame = V7(D2Common,08,08,08,44,44,40,00,00);
return true;
}

94
PlugY/D2wrapper.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
@file D2wrapper.cpp
@brief Main Diablo II extra DLL handler.
@ -31,26 +32,27 @@
#include "uberQuest.h" // Install_UberQuest()
#include "extraOptions.h" // Install_AlwaysRegenMapInSP()
#include "language.h" // Install_LanguageManagement()
#include "../Commons/VersionInfo.h"
int version_SmackW32=V113;
int version_D2Common=V113;
int version_ijl11=V113;
int version_D2Gdi=V113;
int version_D2Win=V113;
int version_D2sound=V113;
int version_D2MCPCLI=V113;
int version_D2Launch=V113;
int version_D2gfx=V113;
int version_D2Client=V113;
int version_D2Net=V113;
int version_D2Lang=V113;
int version_D2Game=V113;
int version_D2CMP=V113;
int version_Bnclient=V113;
int version_Fog=V113;
int version_Storm=V113;
//-------------------------
int version_SmackW32=V113d;
int version_D2Common=V113d;
int version_ijl11=V113d;
int version_D2Gdi=V113d;
int version_D2Win=V113d;
int version_D2sound=V113d;
int version_D2MCPCLI=V113d;
int version_D2Launch=V113d;
int version_D2gfx=V113d;
int version_D2Client=V113d;
int version_D2Net=V113d;
int version_D2Lang=V113d;
int version_D2Game=V113d;
int version_D2CMP=V113d;
int version_Bnclient=V113d;
int version_Fog=V113d;
int version_Storm=V113d;
//-------------------------
DWORD offset_SmackW32=NULL;
DWORD offset_D2Common=NULL;
@ -375,6 +377,7 @@ bool initD2version()
}
*/
/*
void getVersion(DWORD addr, int* ver, DWORD v109b, DWORD v109d, DWORD v110, DWORD v111, DWORD v111b, DWORD v112, DWORD v113, const char * filename)
{
log_msg("version of %s\t",filename);
@ -432,6 +435,47 @@ bool initD2version()
log_msg("\n\n");
return true;
}
*/
const char sD2Ver[8][7] = {{"v1.09b"},{"v1.09d"},{"v1.10 "},{"v1.11 "},{"v1.11b"},{"v1.12 "},{"v1.13c"},{"v1.13d"}};
bool initD2version()
{
char currentpath[MAX_PATH];
if (! GetD2Path(currentpath, MAX_PATH))
{
log_msg("Path to Game.exe not found");
return false;
}
log_msg("***** Get Game.exe version *****\n");
int ver = GetD2Version(currentpath);
if (ver == -1) return false;
//--------------------
version_SmackW32=ver;
version_D2Common=ver;
version_ijl11=ver;
version_D2Gdi=ver;
version_D2Win=ver;
version_D2sound=ver;
version_D2MCPCLI=ver;
version_D2Launch=ver;
version_D2gfx=ver;
version_D2Client=ver;
version_D2Net=ver;
version_D2Lang=ver;
version_D2Game=ver;
version_D2CMP=ver;
version_Bnclient=ver;
version_Fog=ver;
version_Storm=ver;
//-------------------
log_msg("version Game.exe - ");
log_msg(sD2Ver[ver]);
log_msg("\n");
return true;
}
//////////////////////////////////// EXPORTS FUNCTIONS ////////////////////////////////////
extern "C" __declspec(dllexport) void* __stdcall Init(LPSTR IniName)
@ -445,7 +489,12 @@ extern "C" __declspec(dllexport) void* __stdcall Init(LPSTR IniName)
loadD2Libraries();
if (!initD2version()) return NULL;
if (!initD2version())
{
log_msg("wrong G ame.exe version\n");
return NULL;
}
if (!initD2functions()) return NULL;
@ -539,6 +588,10 @@ extern "C" __declspec(dllexport) void* __stdcall Init(LPSTR IniName)
unhookLibraries();
log_msg("\n*****Loading locale strings.*****\n");
initLocaleStrings();
log_msg("\n\n\n");
initCustomLibraries();
log_msg("***** ENTERING DIABLO II *****\n\n" );
@ -555,6 +608,7 @@ extern "C" __declspec(dllexport) bool __stdcall Release()
log_msg("\n***** ENDING DIABLO II *****\n\n" );
freeCustomLibraries();
freeLocaleStrings();
freeD2Libraries();
return true;
}

61
PlugY/ExtraOptions.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
More little options.
@ -26,7 +27,9 @@ void STDCALL displayItemlevel(LPWSTR popup, Unit* ptItem)
{
if (onRealm && (selectModParam==MOD_NO)) return;
WCHAR text[0x50];
swprintf(text, L"Item Level: %u\n", D2GetItemLevel(ptItem));
//swprintf(text, L"Item Level: %u\n", D2GetItemLevel(ptItem));
swprintf(text, getTranslatedString(STR_ITEM_LEVEL), D2GetItemLevel(ptItem));
wcscat(text,L"\n");
D2SetColorPopup(text,WHITE);
wcscat(popup,text);
}
@ -139,17 +142,18 @@ void Install_DisplayItemLevel()
log_msg("Patch D2Client for display item popup. (DisplayPopup)\n");
// print the text in the final buffer
mem_seek R7(D2Client, 3D47C, 3D47C, 438A1, ADD0A, 789DA, AE0AA, 941C0);
mem_seek R7(D2Client, 3D47C, 3D47C, 438A1, ADD0A, 789DA, AE0AA, 941C0, 98590);
memt_byte( 0x68 , 0xE8);
MEMT_REF4( 0x100, version_D2Client >= V113 ? caller_displayItemlevel_113 : version_D2Client >= V111 ? caller_displayItemlevel_111 : version_D2Client == V110 ? caller_displayItemlevel : caller_displayItemlevel_9);
MEMT_REF4( 0x100, version_D2Client >= V113c ? caller_displayItemlevel_113 : version_D2Client >= V111 ? caller_displayItemlevel_111 : version_D2Client == V110 ? caller_displayItemlevel : caller_displayItemlevel_9);
//6FAE38A1 . 68 00010000 PUSH 100
//6FB5DD0A |. 68 00010000 PUSH 100
//6FB289DA |. 68 00010000 PUSH 100
//6FB5E0AA |. 68 00010000 PUSH 100
//6FB441C0 |. 68 00010000 PUSH 100
//6FB48590 |. 68 00010000 PUSH 100
// print the text in the final buffer (for set items)
mem_seek R7(D2Client, 3C452, 3C452, 427BE, AC773, 77773, ACEB3, 92FE3);
mem_seek R7(D2Client, 3C452, 3C452, 427BE, AC773, 77773, ACEB3, 92FE3, 973B3);
memt_byte( 0x68 , 0xE8);
MEMT_REF4( 0x100, version_D2Client >= V111 ? caller_displayItemlevelSet_111 : version_D2Client == V110 ? caller_displayItemlevelSet : caller_displayItemlevelSet_9);
//6FAE27BE . 68 00010000 PUSH 100
@ -157,6 +161,7 @@ void Install_DisplayItemLevel()
//6FB27773 |. 68 00010000 PUSH 100
//6FB5CEB3 |. 68 00010000 PUSH 100
//6FB42FE3 |. 68 00010000 PUSH 100
//6FB473B3 |. 68 00010000 PUSH 100
log_msg("\n");
@ -208,12 +213,12 @@ void Install_SendPlayersCommand()
log_msg("Patch D2Client for init default nb /players. (SendPlayersCommand)\n");
infoEnabledSendPlayersCommand = (DWORD*)R7(D2Client, 111D60, 110BC0, 107960, 11BFBC, 11C2AC, 11BFF8, 11C394);
infoEnabledSendPlayersCommand = (DWORD*)R7(D2Client, 111D60, 110BC0, 107960, 11BFBC, 11C2AC, 11BFF8, 11C394, 11D1DC);
if ( version_D2Client >= V110 )
msgNBPlayersString = (char*)R7(D2Client, 0000, 0000, D8448, D06A8, D4748, D4680, D4E00);
msgNBPlayersString = (char*)R7(D2Client, 0000, 0000, D8448, D06A8, D4748, D4680, D4E00, D470C);
// Set nb Player to default
mem_seek R7(D2Client, 8723B, 865BB, 81B8B, A3602, 66A02, 90162, C39F2);//6FB1C7B7-6FAA0000
mem_seek R7(D2Client, 8723B, 865BB, 81B8B, A3602, 66A02, 90162, C39F2, 1D3F2);//6FB1C7B7-6FAA0000
MEMJ_REF4( D2GetResolution , caller_SendPlayersCommand);
//6FB2723A |. E8 7D8E0300 CALL <JMP.&D2gfx.#10005>
//6FB265BA |. E8 7D8E0300 CALL <JMP.&D2gfx.#10005>
@ -222,6 +227,7 @@ void Install_SendPlayersCommand()
//6FB16A01 |. E8 AA65FAFF CALL <JMP.&D2gfx.#10063>
//6FB40161 |. E8 1ECFF7FF CALL <JMP.&D2gfx.#10043>
//6FB739F1 |. E8 B896F4FF CALL <JMP.&D2gfx.#10031>
//6FACD3F1 |. E8 EAFBFEFF CALL <JMP.&D2gfx.#10012>
log_msg("\n");
@ -239,13 +245,14 @@ void Install_AlwaysRegenMapInSP()
log_msg("Patch D2Game for always regenerate maps in Single player. (AlwaysRegenMapInSP)\n");
// Always regenerate maps in Single player
mem_seek R7(D2Game, 517ED, 51BFA, 5DE88, 6235D, 2966D, 1E1FE, ED3BE);
mem_seek R7(D2Game, 517ED, 51BFA, 5DE88, 6235D, 2966D, 1E1FE, ED3BE, 26D7E);
memt_byte( 0x74 , 0xEB); // JMP SHORT D2Game.01FE2368
//6FC8DE88 |. 74 09 JE SHORT D2Game.6FC8DE93
//01FE235D |. 74 09 JE SHORT D2Game.01FE2368
//01F9966D |. 74 09 JE SHORT D2Game.01F99678
//6FC3E1FE |. 74 09 JE SHORT D2Game.6FC3E209
//6FD0D3BE |. 74 09 JE SHORT D2Game.6FD0D3C9
//6FC46D7E |. 74 09 JE SHORT D2Game.6FC46D89
log_msg("\n");
@ -262,11 +269,12 @@ void Install_RunLODs()
log_msg("Patch D2gfx for launch any number of Diablo II game in the same computer. (RunLODs)\n");
// execute if it's our packet else continue
mem_seek R7(D2gfx, 447C, 447C, 446A, 84CF, 84AF, 894F, 85BF);
mem_seek R7(D2gfx, 447C, 447C, 446A, 84CF, 84AF, 894F, 85BF, B6B0);
memt_byte( 0x74, 0xEB ); // JMP SHORT D2gfx.6FA884F6
//6FA884AF |. 74 45 JE SHORT D2gfx.6FA884F6
//6FA8894F |. 74 45 JE SHORT D2gfx.6FA88996
//6FA885BF |. 74 45 JE SHORT D2gfx.6FA88606
//6FA8B6B0 |. 74 45 JE SHORT D2gfx.6FA8B6F7
log_msg("\n");
@ -381,9 +389,9 @@ void Install_AlwaysDisplayLifeMana()
log_msg("Patch D2Client for always display life and mana. (ALwaysPrintLifeMana)\n");
if ( version_D2Client >= V113 )
if ( version_D2Client >= V113c )
{
mem_seek R7(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2764A);
mem_seek R7(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2764A, 6D6FA);
memt_byte( 0x0F , 0x90);
memt_byte( 0x8C , 0xE8);
MEMT_REF4( 0x000000BC, caller_AlwaysDisplayLife_113);
@ -393,10 +401,13 @@ void Install_AlwaysDisplayLifeMana()
//6FAD7659 |. A1 4CBCB86F MOV EAX,DWORD PTR DS:[6FB8BC4C]
//6FAD7667 |. 0F8C A4000000 JL D2Client.6FAD7711
//--
//6FB1D717 |. 0F8C A4000000 JL D2Client.6FB1D7C1
} else {
// Always display life.
mem_seek R7(D2Client, 58B32, 58B32, 5F102, 2D713, B5DF3, 81733, 0000);
mem_seek R7(D2Client, 58B32, 58B32, 5F102, 2D713, B5DF3, 81733, 0000, 0000);
memt_byte( 0xA1 , 0xE8);
MEMT_REF4( ptResolutionY , version_D2Client >= V111 ? caller_AlwaysDisplayLife_111 : caller_AlwaysDisplayLife);
//6FADD713 |. A1 605CBA6F MOV EAX,DWORD PTR DS:[6FBA5C60]
@ -406,13 +417,13 @@ void Install_AlwaysDisplayLifeMana()
// Always display mana.
if ( version_D2Client >= V113 )
if ( version_D2Client >= V113c )
{
//mem_seek R7(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 27711);
//memt_byte( 0x8B , 0x90);
//memt_byte( 0x0D , 0xE8);
//MEMT_REF4( offset_D2Client + 0x11C4B4 , caller_AlwaysDisplayMana_113);
mem_seek R7(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2770C);
mem_seek R7(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2770C, 6D7BC);
memt_byte( 0xA1 , 0xE8);
MEMT_REF4( ptResolutionY , caller_AlwaysDisplayMana_113);
//6FAD770C |> A1 4CBCB86F MOV EAX,DWORD PTR DS:[6FB8BC4C]
@ -426,10 +437,12 @@ void Install_AlwaysDisplayLifeMana()
//6FAD77CA |. 5B POP EBX
//6FAD77CB |. 81C4 28030000 ADD ESP,328
//6FAD77D1 \. C3 RETN
//--
//6FB1D7BC |> A1 3870BA6F MOV EAX,DWORD PTR DS:[6FB8BC4C]
}
else if ( version_D2Client >= V110 )
{
mem_seek R7(D2Client, 0000, 0000, 5F1E6, 2D7FB, B5EDB, 8181B, 0000);
mem_seek R7(D2Client, 0000, 0000, 5F1E6, 2D7FB, B5EDB, 8181B, 0000, 0000);
memt_byte( 0x5F , 0xE8);
MEMT_REF4( 0x815B5D5E , caller_AlwaysDisplayMana);
memt_byte( 0xC4 , 0x90); // NOP
@ -454,7 +467,7 @@ void Install_AlwaysDisplayLifeMana()
//6FB3181F |. 81C4 5C020000 ADD ESP,25C
//6FB31825 |. C3 RETN
} else {
mem_seek R7(D2Client, 58C09, 58C09, 0000, 0000, 0000, 0000, 0000);
mem_seek R7(D2Client, 58C09, 58C09, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0xE9 , 0xE8);
MEMT_REF4( 0x000000C2 , caller_AlwaysDisplayMana_9);
//6FAF8C09 . E9 C2000000 JMP D2Client.6FAF8CD0
@ -539,23 +552,25 @@ void Install_DisplayBaseStatsValue()
log_msg("Patch D2Client for display base stats value. (DisplayBaseStatsValue)\n");
// Always print stat button images.
mem_seek R7(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5);
mem_seek R7(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5, BF955);
memt_byte( 0x8B, 0xEB ); // JMP SHORT D2Client.6FAD0088
memt_byte( 0x4C, V7(D2Client, 12, 12, 13, 13, 13, 13, 13) );
memt_byte( 0x4C, V7(D2Client, 12, 12, 13, 13, 13, 13, 13, 13) );
memt_byte( 0x24, 0x90 ); // NOP
memt_byte( V7(D2Client, 20, 20, 14, 1C, 1C, 1C, 1C), 0x90 ); // NOP (V109d:0x20 , V110:0x14
memt_byte( V7(D2Client, 20, 20, 14, 1C, 1C, 1C, 1C, 1C), 0x90 ); // NOP (V109d:0x20 , V110:0x14
//6FAD0073 8B4C24 14 MOV ECX,DWORD PTR SS:[ESP+14]
//6FB32BBA > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB3963A > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB1B59A > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB6D1B5 |> 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB6F955 |> 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
mem_seek R7(D2Client, 29B9D, 29B8D, 300FD, 82C54, 896D4, 6B637, BD23E);
mem_seek R7(D2Client, 29B9D, 29B8D, 300FD, 82C54, 896D4, 6B637, BD23E, BF9DE);
MEMJ_REF4( D2PrintImage, caller_displayBaseStatsValue);
//6FB32C53 . E8 82A3F8FF CALL <JMP.&D2gfx.#10047>
//6FB396D3 . E8 D238F8FF CALL <JMP.&D2gfx.#10044>
//6FB1B636 . E8 431AFAFF CALL <JMP.&D2gfx.#10024>
//6FB6D23D |. E8 54FEF4FF |CALL <JMP.&D2gfx.#10041>
//6FB6F9DD |. E8 54FEF4FF |CALL <JMP.&D2gfx.#10042>
log_msg("\n");
@ -583,13 +598,14 @@ void Install_LadderRunewords()
log_msg("Patch D2Common for enabled the ladder only runewords. (LadderRunewords)\n");
mem_seek R7(D2Common, 0000, 0000, 1E965, 61762, 43A72, 5D492, 724B2);
mem_seek R7(D2Common, 0000, 0000, 1E965, 61762, 43A72, 5D492, 724B2, 63782);
MEMC_REF4( D2CompileTxtFile, compileRunesTxt);
//01B6E964 |. E8 0714FFFF CALL D2Common.#10578 ; \#10578
//6FDB1761 |. E8 FAA8FCFF CALL D2Common.#10653 ; \#10653
//6FD93A71 |. E8 EAADFCFF CALL D2Common.#10496 ; \#10496
//6FDAD491 |. E8 BA49FEFF CALL D2Common.#10244 ; \#10244
//6FDC24B1 |. E8 8ACAFEFF CALL D2Common.#10849 ; \#10849
//6FDB3781 |. E8 5A93FAFF CALL D2Common.#10037 ; \#10037
log_msg("\n");
@ -607,7 +623,7 @@ void Install_EnabledCowPortalWhenCowKingWasKill()
log_msg("Patch D2Game for enabled the opening of Cow Portal when player have already kill the cow king in that difficulty. (EnabledCowPortalWhenCowKingWasKill)\n");
mem_seek R7(D2Game, 5DFF7, 5E457, 6C5E7 , B1278, 5DB68, 75C68, 67508);
mem_seek R7(D2Game, 5DFF7, 5E457, 6C5E7 , B1278, 5DB68, 75C68, 67508, EBE8);
memt_byte( 0x85 , 0x33); // XOR EAX,EAX
//6FC8DFF7 . 85C0 TEST EAX,EAX
//6FC8E457 . 85C0 TEST EAX,EAX
@ -616,6 +632,7 @@ void Install_EnabledCowPortalWhenCowKingWasKill()
//01FEDB68 |. 85C0 TEST EAX,EAX
//6FC95C68 |. 85C0 TEST EAX,EAX
//6FC87508 |. 85C0 TEST EAX,EAX
//6FC2EBE8 |. 85C0 TEST EAX,EAX
log_msg("\n");

9
PlugY/GlobalVariable.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Updating server.
@ -101,7 +102,7 @@ void Install_VariableOnRealm()
log_msg("Patch D2Launch for set not on realm variable. (VariableonRealm)\n");
// click on Battle.net button
mem_seek R7(D2Launch, 8195, 81A5, 9915, 129E5, 18AA5, 17D15, 19295);
mem_seek R7(D2Launch, 8195, 81A5, 9915, 129E5, 18AA5, 17D15, 19295, 11C65);
memt_byte( 0x81, 0xE8 ); // CALL
MEMT_REF4( 0x000400EC, caller_BnetBtnPress);
memt_byte( 0x00, 0x90 ); // NOP
@ -114,7 +115,7 @@ void Install_VariableOnRealm()
//6FA1EFFC . B8 01000000 MOV EAX,1
// click on TCP/IP button
mem_seek R7(D2Launch, 87B9, 87C9, 9F99, 11329, 17409, 16659, 17B8E);
mem_seek R7(D2Launch, 87B9, 87C9, 9F99, 11329, 17409, 16659, 17B8E, 1053E);
if (version_D2Launch == V109b || version_D2Launch == V109d || version_D2Launch == V110)
{
memt_byte( 0xBD, 0xE8 ); // CALL
@ -126,7 +127,7 @@ void Install_VariableOnRealm()
}
// click on SinglePlayer button
mem_seek R7(D2Launch, D1F6, D1E6, EC16, B726, 117E6, 10A56, 11F36);
mem_seek R7(D2Launch, D1F6, D1E6, EC16, B726, 117E6, 10A56, 11F36, A906);
memt_byte( 0xBA, 0xE8 ); // CALL
MEMT_REF4( 0x00000400, caller_SinglePlayerBtnPress);
//6FA4B726 . BA 00040000 MOV EDX,400
@ -135,7 +136,7 @@ void Install_VariableOnRealm()
{
log_msg("\nPatch D2Game for fixing ptClient removing bug. (VariableonRealm)\n");
//Bug crash ptClient search fix (for Megalixir Mod).
mem_seek R7(D2Game, 0000, 0000, 2B97, 0000, 0000, 0000, 0000);
mem_seek R7(D2Game, 0000, 0000, 2B97, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0x39 ,0xE8);
MEMT_REF4( 0x8B0C7429 , caller_fixClientRemovingBug);
memt_byte( 0xC1 ,0x90);

18
PlugY/InfinityStash.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Gestion of the infinity and shared Stash.
@ -80,7 +81,7 @@ Stash* newStash(DWORD id)
d2_assert( id == 0xFFFFFFFF , "trop de stash", __FILE__, __LINE__);
Stash* stash = (Stash*)malloc(sizeof(Stash));//D2AllocMem(memPool, sizeof(Stash),__FILE__,__LINE__,0);
d2_assert(!stash , "pb de génération de stash", __FILE__, __LINE__);
d2_assert(!stash , "pb de generation de stash", __FILE__, __LINE__);
ZeroMemory(stash, sizeof(Stash));
stash->id = id;
@ -804,42 +805,45 @@ void Install_MultiPageStash()
log_msg("Patch D2Game for carry1 unique item. (MultiPageStash)\n");
// Cannot put 2 items carry1 in inventory
mem_seek R7(D2Game, 0000, 0000, 55050, 57CA3, 2FE63, 99B03, CF1E3);
mem_seek R7(D2Game, 0000, 0000, 55050, 57CA3, 2FE63, 99B03, CF1E3, 6B013);
MEMJ_REF4( D2ItemSetPage , version_D2Game >= V111 ? caller_carry1Limit_111 : caller_carry1Limit);
//6FC8504F . E8 94670900 CALL <JMP.&D2Common.#10720>
//01FD7CA2 . E8 6329FBFF CALL <JMP.&D2Common.#10485>
//01F9FE62 . E8 47A8FDFF CALL <JMP.&D2Common.#10608>
//6FCB9B02 . E8 9709F7FF CALL <JMP.&D2Common.#10223>
//6FCEF1E2 . E8 47B7F3FF CALL <JMP.&D2Common.#10012>
//6FC8B012 . E8 13F7F9FF CALL <JMP.&D2Common.#11026>
// Cannot put 2 items carry1 in inventory by swapping
mem_seek R7(D2Game, 0000, 0000, 558D9, 58968, 310E8, 9B6E8, D10C8);
mem_seek R7(D2Game, 0000, 0000, 558D9, 58968, 310E8, 9B6E8, D10C8, 6BC78);
MEMJ_REF4( D2ItemGetPage , version_D2Game >= V112 ? caller_carry1LimitSwap_112 : version_D2Game >= V111 ? caller_carry1LimitSwap_111 : caller_carry1LimitSwap);
//6FC858D8 . E8 175F0900 CALL <JMP.&D2Common.#10719>
//01FD8967 . E8 8E1DFBFF CALL <JMP.&D2Common.#10820>
//01FA10E7 . E8 9A96FDFF CALL <JMP.&D2Common.#10505>
//6FCBB6E7 . E8 CAEDF6FF CALL <JMP.&D2Common.#10370>
//6FCF10C7 . E8 F895F3FF CALL <JMP.&D2Common.#10020>
//6FC8BC77 . E8 22E9F9FF CALL <JMP.&D2Common.#10810>
if ( version_D2Game >= V111 )
{
// Cannot put 2 items carry1 in inventory when drop cube
mem_seek R7(D2Game, 0000, 0000, 0000, 3D935, 49FD5, 17AD5, D7B75);
mem_seek R7(D2Game, 0000, 0000, 0000, 3D935, 49FD5, 17AD5, D7B75, B7B15);
MEMJ_REF4( D2CanPutItemInInv , caller_carry1LimitWhenDrop_111);
//01FBD934 |. E8 5BD3FCFF |CALL <JMP.&D2Common.#10855>
//01FB9FD4 |. E8 3912FCFF |CALL <JMP.&D2Common.#10813>
//6FC37AD4 |. E8 0535FFFF |CALL <JMP.&D2Common.#10289>
//6FCF7B74 |. E8 232FF3FF |CALL <JMP.&D2Common.#10133>
//6FCD7B14 |. E8 7D32F5FF |CALL <JMP.&D2Common.#10402>
} else {
// Cannot put 2 items carry1 in inventory when drop cube
mem_seek R7(D2Game, 0000, 0000, 14341, 0000, 0000, 0000, 0000);
mem_seek R7(D2Game, 0000, 0000, 14341, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0xBA ,0xE8);
MEMT_REF4( 0x00000806 , caller_carry1LimitWhenDrop);
//6FC44341 |. BA 06080000 |MOV EDX,806
}
// Verif only carry1 out of stash page when pick up an item
mem_seek R7(D2Game, 0000, 0000, 1299E, 38E3B, 43F0B, 1209B, D211B);
mem_seek R7(D2Game, 0000, 0000, 1299E, 38E3B, 43F0B, 1209B, D211B, B301B);
memt_byte( 0x8B ,0xE8);
MEMT_REF4( version_D2Game >= V111 ? 0x850C2474 : 0x85102444 , version_D2Game >= V111 ? caller_carry1OutOfStash_111 : caller_carry1OutOfStash);
memt_byte( version_D2Game >= V111 ? 0xF6 : 0xC0 ,0x90);
@ -853,6 +857,8 @@ void Install_MultiPageStash()
//6FC3209F |. 85F6 |TEST ESI,ESI
//6FCF211B |. 8B7424 0C |MOV ESI,DWORD PTR SS:[ESP+C]
//6FCF211F |. 85F6 |TEST ESI,ESI
//6FCD301B |. 8B7424 0C |MOV ESI,DWORD PTR SS:[ESP+C]
//6FCD301F |. 85F6 |TEST ESI,ESI
log_msg("\n");
}

23
PlugY/Interface_Skills.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Interface functions
@ -36,7 +37,7 @@ void STDCALL printSkillsPageBtns()
if ( isOnButtonUnassignSkill(D2GetMouseX(),D2GetMouseY()))
{
LPWSTR popupText = getTranslatedString(STR_SKILLS_UNASSIGN);
LPWSTR popupText = getTranslatedString(STR_SKILLS_UNASSIGN);
D2PrintPopup(popupText, getXSkillBtn()+getLSkillBtn()/2, getYSkillBtn()-getHSkillBtn(), 0, 1);
}
}
@ -140,7 +141,7 @@ void Install_InterfaceSkills()
log_msg("Patch D2Client for skills interface. (InterfaceSkills)\n");
// Print new buttons images
mem_seek R7(D2Client, 7AC20, 7AC20, 77073, 16190, 8A9C0, 7F320, 77F20);
mem_seek R7(D2Client, 7AC20, 7AC20, 77073, 16190, 8A9C0, 7F320, 77F20, 2F380);
memt_byte( 0x5F, 0xE9 ); // JMP caller_printBtns
if ( version_D2Client >= V111 ) {
MEMT_REF4( 0xCCC35B5E, caller_printSkillsPageBtns_111);
@ -164,6 +165,11 @@ void Install_InterfaceSkills()
//6FB27F22 |. 5B POP EBX
//6FB27F23 \. C3 RETN
//6FB27F24 CC INT3
//6FADF380 |> 5F POP EDI
//6FADF381 |. 5E POP ESI
//6FADF382 |. 5B POP EBX
//6FADF383 \. C3 RETN
//6FADF384 CC INT3
} else {
MEMT_REF4( 0x835B5D5E, caller_printSkillsPageBtns);
memt_byte( 0xC4, 0x90 ); // NOP
@ -180,7 +186,7 @@ void Install_InterfaceSkills()
if (posXUnassignSkillBtn==-1 && posYUnassignSkillBtn==-1)
{
// Don't print "Skill Points Remaining"
mem_seek R7(D2Client, 7AC30, 7AC30, 77080, 16294, 8AC74, 7ECF4, 78334);
mem_seek R7(D2Client, 7AC30, 7AC30, 77080, 16294, 8AC74, 7ECF4, 78334, 2F7E4);
memt_byte( 0xB9, 0xE8 );
MEMT_REF4( 0x00001083, version_D2Client >= V111 ? caller_DontPrintSkillPointsRemaining_111 : caller_DontPrintSkillPointsRemaining);
//6FB17080 /$ B9 83100000 MOV ECX,1083
@ -188,10 +194,11 @@ void Install_InterfaceSkills()
//6FB3AC74 |. B9 83100000 MOV ECX,1083
//6FB2ECF4 |. B9 83100000 MOV ECX,1083
//6FB28334 |. B9 83100000 MOV ECX,1083
//6FADF7E4 |. B9 83100000 MOV ECX,1083
}
// Manage mouse down (Play sound)
mem_seek R7(D2Client, 7BBD1, 7BBD1, 780E4, 17BC2, 8C6E2, 808B2, 79C62);
mem_seek R7(D2Client, 7BBD1, 7BBD1, 780E4, 17BC2, 8C6E2, 808B2, 79C62, 31112);
memt_byte( 0xC7, 0xE8 ); // CALL caller_skillsPageMouseDown
MEMT_REF4( version_D2Client >= V111 ? 0x00001845 : 0x00001843, version_D2Client >= V111 ? caller_skillsPageMouseDown_111 : caller_skillsPageMouseDown);
memt_byte( 0x00, 0x90 ); // NOP
@ -199,17 +206,19 @@ void Install_InterfaceSkills()
//6FB180E4 > C743 18 00000000 MOV DWORD PTR DS:[EBX+18],0
//6FAC7BC2 > C745 18 00000000 MOV DWORD PTR SS:[EBP+18],0
//6FB3C6E2 > C745 18 00000000 MOV DWORD PTR SS:[EBP+18],0
//6FB308B2 > C745 18 000000>MOV DWORD PTR SS:[EBP+18],0
//6FB29C62 > C745 18 000000>MOV DWORD PTR SS:[EBP+18],0
//6FB308B2 > C745 18 00000000 MOV DWORD PTR SS:[EBP+18],0
//6FB29C62 > C745 18 00000000 MOV DWORD PTR SS:[EBP+18],0
//6FAE1112 > C745 18 00000000 MOV DWORD PTR SS:[EBP+18],0
// Manage mouse up
mem_seek R7(D2Client, 7BC40, 7BC40, 78466, 17558, 8C078, 80248, 795F8);
mem_seek R7(D2Client, 7BC40, 7BC40, 78466, 17558, 8C078, 80248, 795F8, 30AA8);
MEMJ_REF4( D2FreeWinMessage, caller_skillsPageMouseUp);//0xFFF93B0A
//6FB18465 . E8 C07D0400 CALL <JMP.&Storm.#511>
//6FAC7557 .^E9 4248FFFF JMP <JMP.&Storm.#511>
//6FB3C077 .^E9 16FDF7FF JMP <JMP.&Storm.#511>
//6FB30247 .^E9 2CBCF8FF JMP <JMP.&Storm.#511>
//6FB295F7 .^E9 8828F9FF JMP <JMP.&Storm.#511>
//6FAE0AA7 .^E9 E0B2FDFF JMP <JMP.&Storm.#511>
log_msg("\n");

24
PlugY/Interface_Stash.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Interface stats page functions
@ -450,43 +451,47 @@ void Install_InterfaceStash()
log_msg("Patch D2Client for stash interface. (InterfaceStash)\n");
// Print button images
mem_seek R7(D2Client, 39060, 39060, 3F399, B1006, 7DF86, B3656, 99A56);
mem_seek R7(D2Client, 39060, 39060, 3F399, B1006, 7DF86, B3656, 99A56, 9DE26);
MEMC_REF4( D2LoadBuySelBtn, printBtns);
//6FADF398 |. E8 734D0400 CALL D2Client.6FB24110
//6FB61005 |. E8 A6D3FEFF CALL D2Client.6FB4E3B0
//6FB2DF85 |. E8 3642FEFF CALL D2Client.6FB121C0
//6FB63655 |. E8 9682FDFF CALL D2Client.6FB3B8F0
//6FB49A55 |. E8 96500200 CALL D2Client.6FB6EAF0
//6FB4DE25 |. E8 76ACF7FF CALL D2Client.6FAC8AA0
// print page number
mem_seek R7(D2Client, 3903C, 3903C, 3F375, B0FE3, 7DF63, B3633, 99A33);
mem_seek R7(D2Client, 3903C, 3903C, 3F375, B0FE3, 7DF63, B3633, 99A33, 9DE03);
MEMJ_REF4( D2PrintString, printPageNumber);
//6FADF374 |. E8 3FCC0800 CALL <JMP.&D2Win.#10117>
//6FB60FE2 |. E8 99C2F5FF CALL <JMP.&D2Win.#10020>
//6FB2DF62 |. E8 19F3F8FF CALL <JMP.&D2Win.#10064>
//6FB63632 |. E8 299DF5FF CALL <JMP.&D2Win.#10001>
//6FB49A32 |. E8 4739F7FF CALL <JMP.&D2Win.#10150>
//6FB49A32 |. E8 91F4F6FF CALL <JMP.&D2Win.#10150>
//6FB4DE02 |. E8 4739F7FF CALL <JMP.&D2Win.#10076>
// Manage mouse down (Play sound)
mem_seek R7(D2Client, 45091, 45091, 4BBA1, B4666, 7FDD6, B54A6, 9B8A6);
mem_seek R7(D2Client, 45091, 45091, 4BBA1, B4666, 7FDD6, B54A6, 9B8A6, 9FC76);
MEMC_REF4( version_D2Client >= V111 ? (DWORD)D2ClickOnStashButton : (DWORD)D2isLODGame, version_D2Client >= V111 ? caller_manageBtnDown_111 : caller_manageBtnDown);
//6FAEBBA0 > E8 DB04FCFF CALL D2Client.6FAAC080
//6FB64665 . E8 B61EFFFF CALL D2Client.6FB56520
//6FB2FDD5 . E8 E612FFFF CALL D2Client.6FB210C0
//6FB654A5 . E8 9611FFFF CALL D2Client.6FB56640
//6FB4B8A5 . E8 5614FFFF CALL D2Client.6FB3CD00
//6FB4FC75 . E8 960FFFFF CALL D2Client.6FB40C10
// Manage mouse up
mem_seek R7(D2Client, 455F9, 455F9, 4C0F9, B57B9, 7FC09, B52D9, 9B6D9);
mem_seek R7(D2Client, 455F9, 455F9, 4C0F9, B57B9, 7FC09, B52D9, 9B6D9, 9FAA9);
MEMC_REF4( version_D2Client >= V111 ? (DWORD)D2ClickOnStashButton : (DWORD)D2isLODGame, version_D2Client >= V111 ? caller_manageBtnUp_111 : caller_manageBtnUp);
//6FAEC0F8 > E8 83FFFBFF CALL D2Client.6FAAC080
//6FB657B8 > E8 630DFFFF CALL D2Client.6FB56520
//6FB2FC08 > E8 B314FFFF CALL D2Client.6FB210C0
//6FB652D8 > E8 6313FFFF CALL D2Client.6FB56640
//6FB4B6D8 > E8 2316FFFF CALL D2Client.6FB3CD00
//6FB4FAA8 > E8 6311FFFF CALL D2Client.6FB40C10
// init state of button on open stash page
mem_seek R7(D2Client, 45B3A, 45B3A, 4C63A, A645A, 749DA, A9D9A, 8CC3A);
mem_seek R7(D2Client, 45B3A, 45B3A, 4C63A, A645A, 749DA, A9D9A, 8CC3A, 9441A);
memt_byte( 0x81, 0xE9 ); // CALL initBtnsStates
MEMT_REF4( 0x000104C4, initBtnsStates);
memt_byte( 0x00, 0x90 );
@ -497,24 +502,27 @@ void Install_InterfaceStash()
//6FB249DA |> 81C4 04010000 ADD ESP,104
//6FB59D9A |> 81C4 04010000 ADD ESP,104
//6FB3CC3A |> 81C4 04010000 ADD ESP,104
//6FB4441A |> 81C4 04010000 ADD ESP,104
// init the search of print in green the item set name we have in stash
mem_seek R7(D2Client, 3F098, 3F098, 45997, A71F4, 71F64, A7314, 8D434);
mem_seek R7(D2Client, 3F098, 3F098, 45997, A71F4, 71F64, A7314, 8D434, 91A24);
MEMJ_REF4( D2InventoryGetFirstItem, initGetNextItemForSet);
//6FAE5996 |. E8 D5500800 CALL <JMP.&D2Common.#10277>
//6FB571F3 |. E8 D64EF6FF CALL <JMP.&D2Common.#10402>
//6FB21F63 |. E8 96A1F9FF CALL <JMP.&D2Common.#10535>
//6FB57313 |. E8 8250F6FF CALL <JMP.&D2Common.#11151>
//6FB3D433 |. E8 B8F0F7FF CALL <JMP.&D2Common.#10460>
//6FB41A23 |. E8 96A7F7FF CALL <JMP.&D2Common.#11040>
// Get next item for print in green the item set name we have in stash
mem_seek R7(D2Client, 3F0FA, 3F0FA, 45A1C, A728B, 71FFB, A73AB, 8D4CB);
mem_seek R7(D2Client, 3F0FA, 3F0FA, 45A1C, A728B, 71FFB, A73AB, 8D4CB, 91ABB);
MEMJ_REF4( D2UnitGetNextItem, getNextItemForSet);
//6FAE5A1B E8 4A500800 CALL <JMP.&D2Common.#10304>
//6FB5728A |. E8 0B4FF6FF |CALL <JMP.&D2Common.#10934>
//6FB21FFA |. E8 A1A1F9FF |CALL <JMP.&D2Common.#11140>
//6FB573AA |. E8 7550F6FF |CALL <JMP.&D2Common.#10770>
//6FB3D4CA |. E8 99F0F7FF |CALL <JMP.&D2Common.#10464>
//6FB41ABA |. E8 A3A8F7FF |CALL <JMP.&D2Common.#10879>
log_msg("\n");

34
PlugY/Interface_Stats.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Interface functions
@ -48,17 +49,17 @@ void STDCALL printStatsPageBtns()
sDrawImageInfo data;
ZeroMemory(&data,sizeof(data));
if (printBackgroundOnMainPage && D2GetResolution())
{
{
setImage(&data, statsBackgroundImages);
setFrame(&data, 1);
setFrame(&data, 1);
D2PrintImage(&data, getXPreviousPageBtn()-7, getYPreviousPageBtn()+8, -1, 5, 0);
}
setImage(&data, D2LoadBuySelBtn());
if (D2GetResolution())
{
{
setFrame(&data, 12 + isDownBtn.previousPage);
D2PrintImage(&data, getXPreviousPageBtn(), getYPreviousPageBtn(), -1, 5, 0);
}
@ -67,12 +68,12 @@ void STDCALL printStatsPageBtns()
D2SetFont(1);
if (D2GetResolution() && isOnPreviousPageBtn(mx,my)) //print popup "previous page"
{
{
lpText = getTranslatedString(STR_PREVIOUS_PAGE);
D2PrintPopup(lpText, getXPreviousPageBtn()+getLPreviousPageBtn()/2, getYPreviousPageBtn()-getHPreviousPageBtn(), WHITE, 1);
}
else if ( isOnNextPageBtn(mx,my))
{
{
lpText = getTranslatedString(STR_NEXT_PAGE);
D2PrintPopup(lpText, getXNextPageBtn()+getLNextPageBtn()/2, getYNextPageBtn()-getHNextPageBtn(), WHITE, 1);
}
@ -245,7 +246,7 @@ void Install_InterfaceStats()
log_msg("Patch D2Client for stats interface. (InterfaceStats)\n");
// Print new buttons images
mem_seek R7(D2Client, 2A7BE, 2A7AE, 30F86, 83636, 8A0B6, 6C016, BDC16);
mem_seek R7(D2Client, 2A7BE, 2A7AE, 30F86, 83636, 8A0B6, 6C016, BDC16, C03B6);
memt_byte( 0x5F, 0xE9 ); // JMP
MEMT_REF4( 0x815B5D5E, version_D2Client >= V111 ? caller_printStatsPageBtns_111: version_D2Client == V110 ? caller_printStatsPageBtns : caller_printStatsPageBtns_9);
//6FAD0F86 . 5F POP EDI
@ -278,34 +279,41 @@ void Install_InterfaceStats()
//6FB6DC19 |. 5B POP EBX
//6FB6DC1A |. 81C4 70030000 ADD ESP,370
//6FB6DC20 \. C3 RETN
//6FB703B6 |. 5F POP EDI
//6FB703B7 |. 5E POP ESI
//6FB703B8 |. 5D POP EBP
//6FB703B9 |. 5B POP EBX
//6FB703BA |. 81C4 70030000 ADD ESP,370
//6FB703Ñ0 \. C3 RETN
if ( version_D2Client >= V111 )
{
// Manage mouse down (Play sound)
mem_seek R7(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, BCDC8);
mem_seek R7(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, BCDC8, BF568);
memt_byte( 0xA1, 0xE8 );
MEMT_REF4( ptptClientChar, caller_statsPageMouseDown);
//6FB327C8 . A1 F0C4BC6F MOV EAX,DWORD PTR DS:[6FBCC4F0]
//6FB39248 . A1 E0C1BC6F MOV EAX,DWORD PTR DS:[6FBCC1E0]
//6FB1B1A8 . A1 D0C3BC6F MOV EAX,DWORD PTR DS:[6FBCC3D0]
//6FB6CDC8 . A1 FCBBBC6F MOV EAX,DWORD PTR DS:[6FBCBBFC]
//6FB6F568 . A1 50D0BC6F MOV EAX,DWORD PTR DS:[6FBCD050]
// Manage mouse up
mem_seek R7(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, BDE33);
mem_seek R7(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, BDE33, C05D3);
memt_byte( 0xA1, 0xE8 );
MEMT_REF4( ptptClientChar, caller_statsPageMouseUp);
//6FB33853 . A1 F0C4BC6F MOV EAX,DWORD PTR DS:[6FBCC4F0]
//6FB3A2D3 . A1 E0C1BC6F MOV EAX,DWORD PTR DS:[6FBCC1E0]
//6FB1C233 . A1 D0C3BC6F MOV EAX,DWORD PTR DS:[6FBCC3D0]
//6FB6DE33 . A1 FCBBBC6F MOV EAX,DWORD PTR DS:[6FBCBBFC]
//6FB705D3 . A1 50D0BC6F MOV EAX,DWORD PTR DS:[6FBCD050]
} else {
// Manage mouse down (Play sound)
mem_seek R7(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, 0000);
mem_seek R7(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, 0000, 0000);
MEMC_REF4( D2GetClientPlayer, caller_statsPageMouseDown);
//6FAD133C . E8 8F700500 CALL D2Client.6FB283D0
// Manage mouse up
mem_seek R7(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, 0000);
mem_seek R7(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, 0000, 0000);
MEMC_REF4( D2GetClientPlayer, version_D2Client == V110 ? caller_statsPageMouseUp : caller_statsPageMouseUp_9);//0x00056EB2
//6FAD1519 . E8 B26E0500 CALL D2Client.6FB283D0
}

19
PlugY/LoadPlayerData.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Load Player Custom Data.
@ -476,7 +477,7 @@ void Install_LoadPlayerData()
log_msg("Patch D2Game & D2Client for load Player's custom data. (LoadPlayerData)\n");
// Load SP player custom data.
mem_seek R7(D2Game, 5046F, 5086F, 5CB0F, BB8ED, 278CD, 465BD, 5638D);
mem_seek R7(D2Game, 5046F, 5086F, 5CB0F, BB8ED, 278CD, 465BD, 5638D, 3BCCD);
memt_byte( 0x8B, 0xE8); // CALL caller_LoadSPPlayerCustomData
MEMT_REF4( 0x75F685F0 , caller_LoadSPPlayerCustomData);
memt_byte( 0x16, 0x90); // NOP
@ -495,9 +496,12 @@ void Install_LoadPlayerData()
//6FC7638D |> 8BF0 MOV ESI,EAX
//6FC7638F |. 85F6 TEST ESI,ESI
//6FC76391 |. 75 16 JNZ SHORT D2Game.6FC763A9
//6FC5BCCD |> 8BF0 MOV ESI,EAX
//6FC5BCCF |. 85F6 TEST ESI,ESI
//6FC5BCD1 |. 75 16 JNZ SHORT D2Game.6FC5BCE9
// Load MP player custom data.
mem_seek R7(D2Game, 50790, 50B90, 5CC66, BB777, 27757, 46447, 56217);
mem_seek R7(D2Game, 50790, 50B90, 5CC66, BB777, 27757, 46447, 56217, 3BB57);
memt_byte( 0x83, 0xE8);
MEMT_REF4( version_D2Game >= V111 ? 0x2174003B : version_D2Game == V110 ? 0x4674003F : 0x1D74003F, version_D2Game >= V111 ? caller_LoadMPPlayerCustomData_111 : version_D2Game == V110 ? caller_LoadMPPlayerCustomData: caller_LoadMPPlayerCustomData_9);
//6FC8CC66 . 833F 00 CMP DWORD PTR DS:[EDI],0
@ -510,18 +514,21 @@ void Install_LoadPlayerData()
//6FC6644A |. 74 21 JE SHORT D2Game.6FC6646D
//6FC76217 |> 833B 00 CMP DWORD PTR DS:[EBX],0
//6FC7621A |. 74 21 JE SHORT D2Game.6FC7623D
//6FC5BB57 |> 833B 00 CMP DWORD PTR DS:[EBX],0
//6FC5BB5A |. 74 21 JE SHORT D2Game.6FC5BB7D
// Send save files to Server.
mem_seek R7(D2Client, CF42, CF32, D5A2, 733FC, 5DFDC, 7933C, 1457C);
mem_seek R7(D2Client, CF42, CF32, D5A2, 733FC, 5DFDC, 7933C, 1457C, B638C);
MEMJ_REF4( D2FogGetSavePath, version_D2Game >= V111 ? caller_SendSaveFiles_111 : caller_SendSaveFiles);
//6FAAD5A1 |. E8 88D10B00 CALL <JMP.&Fog.#10115>
//6FB233FB |. E8 CA8AF9FF CALL <JMP.&Fog.#10115>
//6FB0DFDB |. E8 C6DEFAFF CALL <JMP.&Fog.#10115>
//6FB2933B |. E8 6A2CF9FF CALL <JMP.&Fog.#10115>
//6FAC457B |. E8 187AFFFF CALL <JMP.&Fog.#10115>
//6FB6638B |. E8 2E5BF5FF CALL <JMP.&Fog.#10115>
// Receive save files from client.
mem_seek R7(D2Game, 183A, 183A, 191A, 376E9, 703D9, 624D9, CAF39);
mem_seek R7(D2Game, 183A, 183A, 191A, 376E9, 703D9, 624D9, CAF39, D53E9);
memt_byte( 0x8B ,0xE8);
if ( version_D2Game >= V111 ) {
MEMT_REF4( 0xB60F005D, caller_ReceiveSaveFiles_111);
@ -535,6 +542,8 @@ void Install_LoadPlayerData()
//6FC824DC |. 0FB645 04 MOVZX EAX,BYTE PTR SS:[EBP+4]
//6FCEAF39 |. 8B5D 00 MOV EBX,DWORD PTR SS:[EBP]
//6FCEAF3C |. 0FB645 04 MOVZX EAX,BYTE PTR SS:[EBP+4]
//6FCF53E9 |. 8B5D 00 MOV EBX,DWORD PTR SS:[EBP]
//6FCF53EC |. 0FB645 04 MOVZX EAX,BYTE PTR SS:[EBP+4]
} else {
MEMT_REF4( 0x04468A3E, caller_ReceiveSaveFiles);
//6FC3191A |. 8B3E MOV EDI,DWORD PTR DS:[ESI]
@ -543,7 +552,7 @@ void Install_LoadPlayerData()
if ( version_Fog <= V109d )
{
mem_seek R7(Fog, 47DE, 45AE, 0000, 0000, 0000, 0000, 0000);
mem_seek R7(Fog, 47DE, 45AE, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0x8B ,0xE8);
MEMT_REF4( 0x891C2444, version_Fog == V109b? caller_BugFix109b : caller_BugFix109d);
memt_byte( 0x44 ,0x90);

12
PlugY/MainScreen.cpp
View File

@ -1,5 +1,7 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Add "plugY v1.00" on screen.
@ -46,7 +48,7 @@ void Install_PrintPlugYVersion()
log_msg("Patch D2Launch to print PlugY version. (PrintPlugYVersion)\n");
// Print PlugY version.
mem_seek R7(D2Launch, 7F5D, 7F7D, 9639, 117C7, 178A7, 16AF7, 18061);
mem_seek R7(D2Launch, 7F5D, 7F7D, 9639, 117C7, 178A7, 16AF7, 18061, 10A11);
MEMJ_REF4( D2CreateTextBox, caller_printPlugYVersion);
//6FA19638 |. E8 1BED0000 CALL <JMP.&D2Win.#10017>
//6FA517C6 |. E8 6F81FFFF CALL <JMP.&D2Win.#10147>
@ -54,6 +56,7 @@ void Install_PrintPlugYVersion()
//6FA56B1F |. E8 1A2EFFFF CALL <JMP.&D2Win.#10098>
//6FA56AF6 |. E8 432EFFFF CALL <JMP.&D2Win.#10098>
//6FA58060 |. E8 ED18FFFF CALL <JMP.&D2Win.#10098>
//6FA50A10 |. E8 218FFFFF CALL <JMP.&D2Win.#10164>
log_msg("\n");
@ -91,7 +94,7 @@ void Install_VersionChange()// BUG WITH 2MOD if D2Mod started before PlugY ????
// Print LoD/Mod version.
if (version_D2Launch >= V110)
{
mem_seek R7(D2Launch, 00000, 00000, 9723, 1189B, 1797B, 16BCB, 18134);//6FA19721-6FA10000
mem_seek R7(D2Launch, 00000, 00000, 9723, 1189B, 1797B, 16BCB, 18134, 10AE4);//6FA19721-6FA10000
memt_byte( 0x8D, 0xE8 ); // CALL
MEMT_REF4( 0x8B102454 , caller_VersionChange_10);
memt_byte( 0xCF, 0x90 ); // NOP
@ -105,14 +108,17 @@ void Install_VersionChange()// BUG WITH 2MOD if D2Mod started before PlugY ????
//6FA56BCF |. 8BCF MOV ECX,EDI
//6FA58134 |. 8D5424 10 LEA EDX,DWORD PTR SS:[ESP+10]
//6FA58138 |. 8BCF MOV ECX,EDI
//6FA50AE4 |. 8D5424 10 LEA EDX,DWORD PTR SS:[ESP+10]
//6FA50AE8 |. 8BCF MOV ECX,EDI
} else {
mem_seek R7(D2Launch, 801B, 803B, 972A, 118A2, 17982, 16BD2, 1813B);
mem_seek R7(D2Launch, 801B, 803B, 972A, 118A2, 17982, 16BD2, 1813B, 10AEB);
MEMJ_REF4( D2PrintLineOnTextBox, versionChange);
//6FA19729 |. E8 88EB0000 CALL <JMP.&D2Win.#10046>
//6FA518A1 |. E8 267FFFFF CALL <JMP.&D2Win.#10061>
//6FA57981 |. E8 781EFFFF CALL <JMP.&D2Win.#10075>
//6FA56BD1 |. E8 EA2CFFFF CALL <JMP.&D2Win.#10015>
//6FA5813A |. E8 8F17FFFF CALL <JMP.&D2Win.#10022>
//6FA50AEA |. E8 DF8CFFFF CALL <JMP.&D2Win.#10051>
}
log_msg("\n");

250
PlugY/NewInterface_CubeListing.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Modified by L'Autour.
Cube Listing functions
@ -14,62 +15,98 @@
const char* CUBEFORMULA_FILE = "cube.txt";
const char * STRING_ERROR="***Error***";
const LPWSTR STRING_ERROR= L"***Error***";
#define BUF (&buf[strlen(buf)])
#define lenbuf 512
#define lenbufi 256
#define BUF &buf[cntbuf], lenbuf-cntbuf
bool InNoSocket; //~~~~~
/*
6FC9275F |. E8 ECCCFFFF |CALL D2Game.6FC8F450 ; \D2Game.6FC8F450
*/
void printOutput(CubeOutput* output, char* buf, BYTE* nbOutputs)
void printOutput(CubeOutput* output, WCHAR* buf, BYTE* nbOutputs)
{
if (!output->outputType)
return;
int cntbuf = wcslen(buf);
if (*nbOutputs)
sprintf(BUF," + ");
cntbuf += swprintf(BUF,L" + ");
*nbOutputs += 1;
if (output->outputType == 1) {
sprintf(BUF,"Cow Portal");
swprintf(BUF,getTranslatedString(STR_COW_PORTAL));
return;
} else if (output->outputType == 2) {
sprintf(BUF,"Pandemonium Portal");
swprintf(BUF,getTranslatedString(STR_PANDEMONIUM_PORTAL));
return;
} else if (output->outputType == 3) {
sprintf(BUF,"Pandemonium Final Portal");
swprintf(BUF,getTranslatedString(STR_PANDEMONIUM_FINAL_PORTAL));
return;
}
if ((output->quantityOrNbSockets>1) && !output->haveSockets)
sprintf(BUF,"%u ", output->quantityOrNbSockets);
{
if (output->quantityOrNbSockets == 255)
{cntbuf += swprintf(BUF,getTranslatedString(STR_FULL));}
else
{cntbuf += swprintf(BUF,L"%u ", output->quantityOrNbSockets);}
}
//-------------------------------------------------------------------------------
WCHAR itembuf[lenbufi];
LPWSTR itemstr = &itembuf[0];
if (!(output->isSpecificItem))
{
ItemsBIN* items; LPWSTR string;
switch (output->outputType)
{
case 0xFC:
items = D2GetItemsBIN(output->ID);
wcsncpy(itemstr, D2GetStringFromIndex(items->NameStr), lenbufi);
break;
case 0xFD:
getTypeUString(output->ID, itemstr, lenbufi);
break;
case 0xFE: wcsncpy(itemstr, getTranslatedString(STR_ITEM),lenbufi);break;
case 0xFF: wcsncpy(itemstr, getTranslatedString(STR_ITEM_SAME_TYPE),lenbufi);break;
default: swprintf(BUF,STRING_ERROR);return;
}
itemstr = cutStringGender(itemstr);
}
//-------------------------------------------------------------------------------
if (output->repair)
sprintf(BUF,"repair ");
cntbuf += wSprintStringLastGender(BUF, STR_REPAIR);
if ((output->repair)&&(output->recharge))
cntbuf += wSprintStringLastGender(BUF, STR_AND);
if (output->recharge)
sprintf(BUF,"recharge ");
cntbuf += wSprintStringLastGender(BUF, STR_RECHARGE);
if (output->isEthereal)
sprintf(BUF,"ethereal ");
cntbuf += wSprintStringLastGender(BUF, STR_ETHERAL);
if (output->destroysFillers)
sprintf(BUF,"destroys Fillers ");
cntbuf += wSprintStringLastGender(BUF, STR_DESTROY_FILLERS);
if (output->removeFillers)
sprintf(BUF,"remove Fillers ");
cntbuf += wSprintStringLastGender(BUF, STR_REMOVE_FILLERS);
if (output->regeneratesUnique)
sprintf(BUF,"regenerate ");
cntbuf += wSprintStringLastGender(BUF, STR_REGENERATE);
if (output->upgradeToExceptional)
sprintf(BUF,"exceptional ");
cntbuf += wSprintStringLastGender(BUF, STR_EXCEPTIONAL);
if (output->upgradeToElite)
sprintf(BUF,"elite ");
cntbuf += wSprintStringLastGender(BUF, STR_ELITE);
if (output->isSpecificItem) {
@ -77,131 +114,163 @@ void printOutput(CubeOutput* output, char* buf, BYTE* nbOutputs)
{
UniqueItemsBIN* uniqueItems = SgptDataTables->uniqueItems + output->specificID-1;
LPWSTR string = D2GetStringFromIndex(uniqueItems->uniqueNameId);
wcstombs(BUF, string, wcslen(string)+1);
cntbuf += swprintf(BUF,string);
} else if (output->quality == ITEMQUALITY_SET) {
SetItemsBIN* setItems = SgptDataTables->setItems + output->specificID-1;
LPWSTR string = D2GetStringFromIndex(setItems->setNameId);
wcstombs(BUF, string, wcslen(string)+1);
cntbuf += swprintf(BUF,string);
} else {
sprintf(BUF,STRING_ERROR);return;
swprintf(BUF,STRING_ERROR);return;
}
} else {
switch (output->quality)
{
case 1:sprintf(BUF,"Cracked ");break;
case 2:sprintf(BUF,"Normal ");break;
case 3:sprintf(BUF,"Superior ");break;
case 4:sprintf(BUF,"Magic ");break;
case 5:sprintf(BUF,"Set ");break;
case 6:sprintf(BUF,"Rare ");break;
case 7:sprintf(BUF,"Unique ");break;
case 8:sprintf(BUF,"Crafted ");break;
case 9:sprintf(BUF,"Tempered ");break;
}
ItemsBIN* items;LPWSTR string;
case 1:cntbuf += wSprintStringLastGender(BUF, STR_CRACKED);break;
case 2:cntbuf += wSprintStringLastGender(BUF, STR_NORMAL);break;
case 3:cntbuf += wSprintStringLastGender(BUF, STR_SUPERIOR);break;
case 4:cntbuf += wSprintStringLastGender(BUF, STR_MAGIC);break;
case 5:cntbuf += wSprintStringLastGender(BUF, STR_SET);break;
case 6:cntbuf += wSprintStringLastGender(BUF, STR_RARE);break;
case 7:cntbuf += wSprintStringLastGender(BUF, STR_UNIQUE);break;
case 8:cntbuf += wSprintStringLastGender(BUF, STR_CRAFTED);break;
case 9:cntbuf += wSprintStringLastGender(BUF, STR_TEMPERED);break;
} /*
ItemsBIN* items; LPWSTR string;
switch (output->outputType)
{
case 0xFC:
items = D2GetItemsBIN(output->ID);
string = D2GetStringFromIndex(items->NameStr);
wcstombs(BUF, string, wcslen(string)+1);
cntbuf += swprintf(BUF,string);
break;
case 0xFD:
getTypeAString(output->ID,BUF,50);
// WCHAR string[50];
// getTypeString(input->ID,string,50);
// wcstombs(BUF, string, wcslen(string)+1);
getTypeUString(output->ID,BUF);
break;
case 0xFE: sprintf(BUF,"Item");break;
case 0xFF: sprintf(BUF,"Item of the same type");break;
default: sprintf(BUF,STRING_ERROR);return;
case 0xFE: cntbuf += swprintf(BUF,getTranslatedString(STR_ITEM));break;
case 0xFF: cntbuf += swprintf(BUF,getTranslatedString(STR_ITEM_SAME_TYPE));break;
default: cntbuf += swprintf(BUF,STRING_ERROR);return;
} */
cntbuf += swprintf(BUF,setMonoString(itemstr));
}
if ((output->haveSockets==1)||InNoSocket)
{
if(output->quantityOrNbSockets>1)
{
swprintf(BUF,getTranslatedString(STR_WITH_N_SOCKETS), output->quantityOrNbSockets);
} else
{
swprintf(BUF,getTranslatedString(STR_WITH_SOCKET));
}
}
if ((output->quantityOrNbSockets>1) && (output->haveSockets==1))
sprintf(BUF," with %u sockets", output->quantityOrNbSockets);
}
void printInput(CubeInput* input, char* buf, BYTE* nbInputs)//maxsize)
void printInput(CubeInput* input, WCHAR* buf, BYTE* nbInputs)//maxsize)
{
if (!input->byItemID && !input->byItemTypeID)
return;
int cntbuf = wcslen(buf);
if (*nbInputs)
sprintf(BUF," + ");
cntbuf += swprintf(BUF,L" + ");
BYTE nb = input->quantity > 0 ? input->quantity : 1;
*nbInputs += nb;
if (nb>1)
sprintf(BUF,"%u ", nb);
cntbuf += swprintf(BUF,L"%u ", nb);
WCHAR itembuf[lenbufi];
LPWSTR itemstr = &itembuf[0];
//-------------------------------------------------------------------------------
if (!(input->isSpecificItem))
{
if (input->byItemTypeID) {
getTypeUString(input->ID, itemstr, lenbufi);
} else if (input->ID == 0xFFFF) {
wcsncpy(itemstr, getTranslatedString(STR_ITEM), lenbufi);
} else {
ItemsBIN* items = D2GetItemsBIN(input->ID);
wcsncpy(itemstr, D2GetStringFromIndex(items->NameStr), lenbufi);
}
itemstr = cutStringGender(itemstr);
}
//-------------------------------------------------------------------------------
if (input->isEthereal)
sprintf(BUF,"ethereal ");
cntbuf += wSprintStringLastGender(BUF, STR_ETHERAL);
if (input->isNotEthereal)
sprintf(BUF,"not ethereal ");
cntbuf += wSprintStringLastGender(BUF, STR_NOT_ETHERAL);
if (input->isNotRuneword)
sprintf(BUF,"not runeword ");
cntbuf += wSprintStringLastGender(BUF, STR_NOT_RUNEWORD);
if (input->isBasic)
sprintf(BUF,"basic ");
cntbuf += wSprintStringLastGender(BUF, STR_BASIC);
if (input->isExceptional)
sprintf(BUF,"exceptional ");
cntbuf += wSprintStringLastGender(BUF, STR_EXCEPTIONAL);
if (input->isElite)
sprintf(BUF,"elite ");
cntbuf += wSprintStringLastGender(BUF, STR_ELITE);
if (input->isSpecificItem) {
if (input->quality == ITEMQUALITY_UNIQUE)
{
UniqueItemsBIN* uniqueItems = SgptDataTables->uniqueItems + input->specificID-1;
LPWSTR string = D2GetStringFromIndex(uniqueItems->uniqueNameId);
wcstombs(BUF, string, wcslen(string)+1);
cntbuf += swprintf(BUF,string);
} else if (input->quality == ITEMQUALITY_SET) {
SetItemsBIN* setItems = SgptDataTables->setItems + input->specificID-1;
LPWSTR string = D2GetStringFromIndex(setItems->setNameId);
wcstombs(BUF, string, wcslen(string)+1);
cntbuf += swprintf(BUF,string);
} else {
sprintf(BUF,STRING_ERROR);return;
swprintf(BUF,STRING_ERROR);return;
}
} else {
switch (input->quality)
{
case 1:sprintf(BUF,"Cracked ");break;
case 2:sprintf(BUF,"Normal ");break;
case 3:sprintf(BUF,"Superior ");break;
case 4:sprintf(BUF,"Magic ");break;
case 5:sprintf(BUF,"Set ");break;
case 6:sprintf(BUF,"Rare ");break;
case 7:sprintf(BUF,"Unique ");break;
case 8:sprintf(BUF,"Crafted ");break;
case 9:sprintf(BUF,"Tempered ");break;
}
case 1:cntbuf += wSprintStringLastGender(BUF, STR_CRACKED);break;
case 2:cntbuf += wSprintStringLastGender(BUF, STR_NORMAL);break;
case 3:cntbuf += wSprintStringLastGender(BUF, STR_SUPERIOR);break;
case 4:cntbuf += wSprintStringLastGender(BUF, STR_MAGIC);break;
case 5:cntbuf += wSprintStringLastGender(BUF, STR_SET);break;
case 6:cntbuf += wSprintStringLastGender(BUF, STR_RARE);break;
case 7:cntbuf += wSprintStringLastGender(BUF, STR_UNIQUE);break;
case 8:cntbuf += wSprintStringLastGender(BUF, STR_CRAFTED);break;
case 9:cntbuf += wSprintStringLastGender(BUF, STR_TEMPERED);break;
}/*
if (input->byItemTypeID) {
getTypeAString(input->ID,BUF,50);
getTypeUString(input->ID,BUF);
} else if (input->ID == 0xFFFF) {
sprintf(BUF,"Item");
cntbuf += swprintf(BUF,getTranslatedString(STR_ITEM));
} else {
ItemsBIN* items = D2GetItemsBIN(input->ID);
LPWSTR string = D2GetStringFromIndex(items->NameStr);
wcstombs(BUF, string, wcslen(string)+1);
}
cntbuf += swprintf(BUF,string);
}*/
cntbuf += swprintf(BUF,itemstr);
}
if (input->includeUpgradedVersions && !input->isElite)
sprintf(BUF,"(or upgraded) ");
cntbuf += swprintf(BUF,getTranslatedString(STR_OR_UPGRADED));
if (input->haveNoSocket)
sprintf(BUF," with no socket");
{
cntbuf += swprintf(BUF,getTranslatedString(STR_WITHOUT_SOCKET));
InNoSocket = true;//~~~~~
}
if (input->haveSockets)
sprintf(BUF," with sockets");
swprintf(BUF,getTranslatedString(STR_WITH_SOCKET));
}
DWORD print(CubeMainBIN* curForm, char* buf, DWORD)//maxsize)
DWORD print(CubeMainBIN* curForm, WCHAR* buf, DWORD)//maxsize)
{
if (!buf || !curForm || !curForm->enabled) return 0;
InNoSocket = false; //~~~~~
BYTE realNbInputs=0;
printInput(&curForm->input1, buf, &realNbInputs);
printInput(&curForm->input2, buf, &realNbInputs);
@ -211,14 +280,15 @@ DWORD print(CubeMainBIN* curForm, char* buf, DWORD)//maxsize)
printInput(&curForm->input6, buf, &realNbInputs);
printInput(&curForm->input7, buf, &realNbInputs);
int cntbuf = wcslen(buf);
if (realNbInputs != curForm->numinputs)
{
sprintf(BUF," *** ERROR : numInputs(%d) != realNbInputs(%d) ***", curForm->numinputs, realNbInputs);
cntbuf += swprintf(BUF,L" *** ERROR : numInputs(%d) != realNbInputs(%d) ***", curForm->numinputs, realNbInputs);
return 1;
}
sprintf(BUF," => ");
cntbuf += swprintf(BUF,L" => ");
BYTE realNbOutputs=0;
printOutput(&curForm->output1, buf, &realNbOutputs);
printOutput(&curForm->output2, buf, &realNbOutputs);
@ -226,24 +296,24 @@ DWORD print(CubeMainBIN* curForm, char* buf, DWORD)//maxsize)
// if (curForm->ladder)
// sprintf(BUF," [ladder only]");
// cntbuf += swprintf(BUF," [ladder only]");
if (curForm->minDiff == 1)
sprintf(BUF," [Nightmare and Hell only]");
cntbuf += swprintf(BUF,getTranslatedString(STR_ONLY_N_H));
else if (curForm->minDiff == 2)
sprintf(BUF," [Hell only]");
cntbuf += swprintf(BUF,getTranslatedString(STR_ONLY_HELL));
if (curForm->playerClass != 0xFF)
{
CharStatsBIN* charStats = D2GetCharStatsBIN(curForm->playerClass);
sprintf(BUF, " [%s only]", charStats->name);
cntbuf += swprintf(BUF, getTranslatedString(STR_ONLY_CLASS), charStats->name);
}
if ((curForm->op>0) && (curForm->op!=28))
sprintf(BUF, " [op%d(%d,%d)]", curForm->op, curForm->param, curForm->value);
cntbuf += swprintf(BUF, L" [op%d(%d,%d)]", curForm->op, curForm->param, curForm->value);
// if (curForm->version == 100)
// sprintf(BUF, " [expansion only]");
// cntbuf += swprintf(BUF, " [expansion only]");
return 1;
}
@ -268,12 +338,24 @@ void listAllCubeFormula()
int nbLines = D2GetNbCubeMainBIN();//SgptDataTables->nbCubemain
log_msg("nbLines : %d\n",nbLines);
char buf[300];
WCHAR buf[lenbuf];
char bufa[lenbuf];
if (D2GetLang() != LNG_DEU)
{
bufa[0] = (char)0xEF;
bufa[1] = (char)0xBB;
bufa[2] = (char)0xBF;
bufa[3] = (char)0x00;
fprintf(file,"%s",bufa);
}
for (int i=0; i<nbLines; i++)
{
buf[0]=NULL;
DWORD res = print(D2GetCubeMainBIN(i), buf, 300);//SgptDataTables->cubemain + i;
if (res) fprintf(file,"%4u: %s\n",i,buf);
DWORD res = print(D2GetCubeMainBIN(i), buf, lenbuf);//SgptDataTables->cubemain + i;
UCS2toUTF8(&bufa[0], lenbuf, &buf[0], lenbuf);
if (res) fprintf(file,"%4u: %s\n",i,bufa);
if (res) fflush(file);
}

34
PlugY/NewInterfaces.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Interface functions
@ -69,6 +70,7 @@ void STDCALL printCustomPage()
DWORD STDCALL mouseCustomPageLeftDown(sWinMessage* msg)
{
if(onRealm) return -1;
if ( (selectedPage > 0) && (selectedPage<=lastPage) )
return mouseNewStatsPageTwoLeftDown(msg);
@ -310,7 +312,7 @@ void Install_NewInterfaces()
if ( version_D2Client >= V111 )
{
//Reset selectedPage variable on opening stats page
mem_seek R7(D2Client, 0000, 0000, 0000, 4B79E, 8F73E, 55E0E, 65F5E);
mem_seek R7(D2Client, 0000, 0000, 0000, 4B79E, 8F73E, 55E0E, 65F5E, C41FE);
memt_byte( 0x83, 0xE8 ); // CALL caller_resetSelectedPage
MEMT_REF4( 0x1F7426F8, caller_resetSelectedPageByToolBar);
//6FAFB79E > 83F8 26 CMP EAX,26
@ -321,8 +323,10 @@ void Install_NewInterfaces()
//6FB05E11 . 74 1F JE SHORT D2Client.6FB05E32
//6FB15F5E > 83F8 26 CMP EAX,26
//6FB15F61 . 74 1F JE SHORT D2Client.6FB15F82
//6FB741FE > 83F8 26 CMP EAX,26
//6FB74201 . 74 1F JE SHORT D2Client.6FB05E32
mem_seek R7(D2Client, 0000, 0000, 0000, 1E55A, 6A8FA, A31DA, 3C5EA);
mem_seek R7(D2Client, 0000, 0000, 0000, 1E55A, 6A8FA, A31DA, 3C5EA, 3E39A);
memt_byte( 0x55, 0xE8 ); // CALL caller_resetSelectedPage
MEMT_REF4( 0xD53BED33, caller_resetSelectedPageByKey);
//6FACE55A . 55 PUSH EBP
@ -337,7 +341,9 @@ void Install_NewInterfaces()
//6FAEC5EA . 55 PUSH EBP
//6FAEC5EB . 33ED XOR EBP,EBP
//6FAEC5ED . 3BD5 CMP EDX,EBP
//6FAEE39A . 55 PUSH EBP
//6FAEE39B . 33ED XOR EBP,EBP
//6FAEE39D . 3BD5 CMP EDX,EBP
//For Toggle fct : (not used for open the stat page)
// mem_seek R7(D2Client, 88B58, 87ED8, 83478, A1FBE, 6571E, 8EF8E, 0000);//((DWORD)D2TogglePage+0x218);
@ -355,7 +361,7 @@ void Install_NewInterfaces()
//6FB3EF92 |. 3928 CMP DWORD PTR DS:[EAX],EBP
} else {
//Reset selectedPage variable on opening stats page
mem_seek R7(D2Client, 88B58, 87ED8, 83478, A1FBE, 6571E, 8EF8E, 0000);//((DWORD)D2TogglePage+0x218);
mem_seek R7(D2Client, 88B58, 87ED8, 83478, A1FBE, 6571E, 8EF8E, 0000, 0000);//((DWORD)D2TogglePage+0x218);
memt_byte( 0x85, 0xE8 ); // CALL caller_resetSelectedPage
MEMT_REF4( 0xC2940FC0, caller_resetSelectedPage);
//6FB23478 |. 85C0 TEST EAX,EAX
@ -365,16 +371,17 @@ void Install_NewInterfaces()
}
// Print custom page
mem_seek R7(D2Client, 87697, 86A17, 81FAB, A3759, 66B59, 902B9, C3B49);
mem_seek R7(D2Client, 87697, 86A17, 81FAB, A3759, 66B59, 902B9, C3B49, 1D549);
MEMC_REF4( D2PrintStatsPage, printCustomPage);
//6FB21FAA . E8 B1DDFAFF CALL D2Client.6FACFD60
//6FB53758 . E8 43F1FDFF CALL D2Client.6FB328A0
//6FB16B58 |. E8 C3270200 CALL D2Client.6FB39320
//6FB402B8 |. E8 C3AFFDFF CALL D2Client.6FB1B280
//6FB73B48 |. E8 5393FFFF CALL D2Client.6FB6CEA0
//6FACD548 |. E8 F3200A00 CALL D2Client.6FB1B280
// Don't print Border
mem_seek R7(D2Client, 58EF6, 58EF6, 5F4C6, 2D366, B5A46, 82166, 271C6);
mem_seek R7(D2Client, 58EF6, 58EF6, 5F4C6, 2D366, B5A46, 82166, 271C6, 6D2B6);
memt_byte( 0xB9, 0xE8 ); // CALL caller_DontPrintBorder
MEMT_REF4( 0x00000012, version_D2Client >= V111 ? caller_DontPrintBorder_111 : caller_DontPrintBorder);
//6FAFF4C6 > B9 12000000 MOV ECX,12
@ -382,27 +389,30 @@ void Install_NewInterfaces()
//6FB65A46 |. B9 12000000 MOV ECX,12
//6FB32166 |. B9 12000000 MOV ECX,12
//6FAD71C6 |. B9 12000000 MOV ECX,12
//6FB1D2B6 |. B9 12000000 MOV ECX,12
// Manage mouse down (Play sound)
mem_seek R7(D2Client, 2A9DC, 2A9CC, 312A5, 82736, 891B6, 6B116, BCD36);
mem_seek R7(D2Client, 2A9DC, 2A9CC, 312A5, 82736, 891B6, 6B116, BCD36, BF4D6);
memt_byte( 0x8D, 0xE8 ); // CALL
MEMT_REF4( 0x00008088, version_D2Client >= V111 ? caller_mouseCustomPageLeftDown_111 : version_D2Client == V110 ? caller_mouseCustomPageLeftDown : caller_mouseCustomPageLeftDown_9);
memt_byte( 0x00, 0x90 ); // NOP
//6FAD12A5 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//6FB32736 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//6FB391B6 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//6FB1B116 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//6FB6CD36 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//6FB1B116 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//6FB6CD36 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//6FB6F4D6 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
// Manage mouse up
mem_seek R7(D2Client, 2ABBB, 2ABAB, 3148D, 836D9, 8A159, 6C0B9, BDCB9);
mem_seek R7(D2Client, 2ABBB, 2ABAB, 3148D, 836D9, 8A159, 6C0B9, BDCB9, C0459);
memt_byte( 0xA1, 0xE8 ); // CALL caller_mouseCustomPageLeftUp
MEMT_REF4( ptWindowStartX, version_D2Client >= V111 ? caller_mouseCustomPageLeftUp_111 : version_D2Client == V110 ? caller_mouseCustomPageLeftUp : caller_mouseCustomPageLeftUp_9);
//6FAD148D . A1 48A7BB6F MOV EAX,DWORD PTR DS:[6FBBA748]
//6FB336D9 . A1 24BDBC6F MOV EAX,DWORD PTR DS:[6FBCBD24]
//6FB3A159 . A1 F8BEBC6F MOV EAX,DWORD PTR DS:[6FBCBEF8]
//6FB1C0B9 . A1 28BDBC6F MOV EAX,DWORD PTR DS:[6FBCBD28]
//6FB6DCB9 . A1 A0B9BC6F MOV EAX,DWORD PTR DS:[6FBCB9A0]
//6FB1C0B9 . A1 28BDBC6F MOV EAX,DWORD PTR DS:[6FBCBD28]
//6FB6DCB9 . A1 A0B9BC6F MOV EAX,DWORD PTR DS:[6FBCB9A0]
//6FB70459 . A1 54D3BC6F MOV EAX,DWORD PTR DS:[6FBCD354]
// open page : 6FB23515 |> 892CB5 A8A6BB6>MOV DWORD PTR DS:[ESI*4+6FBBA6A8],EBP

40
PlugY/PlayerCustomData.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Adding custom data.
Save and load infinity & shared Stash
@ -270,18 +271,19 @@ void Install_PlayerCustomData()
log_msg("Patch D2Game & D2Client & D2Common for Player's custom data. (PlayerCustomData)\n");
// Initialize custom data.
mem_seek( version_D2Client == V113 ? offset_D2Common + 0x309BE : version_D2Client == V112 ? offset_D2Common + 0x585EE : version_D2Client == V111b ? offset_D2Common + 0x5BFCE : version_D2Common == V111 ? offset_D2Common + 0x4ED5E :(DWORD)D2InitPlayerData + 0x62 );
mem_seek( version_D2Client == V113d ? offset_D2Common + 0x170DE : version_D2Client == V113c ? offset_D2Common + 0x309BE : version_D2Client == V112 ? offset_D2Common + 0x585EE : version_D2Client == V111b ? offset_D2Common + 0x5BFCE : version_D2Common == V111 ? offset_D2Common + 0x4ED5E :(DWORD)D2InitPlayerData + 0x62 );
MEMJ_REF4( D2AllocMem, init_PlayerCustomData);
//01BD0381 |. E8 C03F0000 CALL <JMP.&Fog.#10045>
//6FD9ED5D |. E8 94A4FBFF CALL <JMP.&Fog.#10045>
//6FDABFCD |. E8 34D2FAFF CALL <JMP.&Fog.#10045>
//6FDA85ED |. E8 240CFBFF CALL <JMP.&Fog.#10045>
//6FD809BD |. E8 6088FDFF CALL <JMP.&Fog.#10045>
//6FD670DD |. E8 0C3EFFFF CALL <JMP.&Fog.#10045>
if ( version_D2Game >= V111 )
{
// update item
mem_seek R7(D2Game, 10933, 10C03, 1100D, 8BC71, C3C51, 5F2A1, 9BB91);
mem_seek R7(D2Game, 10933, 10C03, 1100D, 8BC71, C3C51, 5F2A1, 9BB91, 75C81);
memt_byte( 0x8B ,0xE8); // CALL
MEMT_REF4( 0x52182454, caller_updateItem_111);
//0200BC71 |> 8B5424 18 |MOV EDX,DWORD PTR SS:[ESP+18]
@ -292,8 +294,10 @@ void Install_PlayerCustomData()
//6FC7F2A5 |. 52 |PUSH EDX ; /Arg1
//6FCBBB91 |> 8B5424 18 |MOV EDX,DWORD PTR SS:[ESP+18]
//6FCBBB95 |. 52 |PUSH EDX
//6FC95C81 |> 8B5424 18 |MOV EDX,DWORD PTR SS:[ESP+18]
//6FC95C85 |. 52 |PUSH EDX
mem_seek R7(D2Game, 1097B, 10C4B, 11058, 8BCD1, C3CB1, 5F301, 9BBF1);
mem_seek R7(D2Game, 1097B, 10C4B, 11058, 8BCD1, C3CB1, 5F301, 9BBF1, 75CE1);
memt_byte( 0x8B ,0xE8); // CALL
MEMT_REF4( 0x52182454, caller_updateItemB_111);
//0200BCD1 |> 8B5424 18 ||MOV EDX,DWORD PTR SS:[ESP+18]
@ -304,19 +308,21 @@ void Install_PlayerCustomData()
//6FC7F305 |. 52 ||PUSH EDX ; /Arg1
//6FCBBBF1 |> 8B5424 18 ||MOV EDX,DWORD PTR SS:[ESP+18]
//6FCBBBF5 |. 52 ||PUSH EDX
//6FC95CE1 |> 8B5424 18 ||MOV EDX,DWORD PTR SS:[ESP+18]
//6FC95CE5 |. 52 ||PUSH EDX
} else {
// update item
mem_seek R7(D2Game, 10933, 10C03, 1100D, 8BC71, C3C51, 5F2A1, 0000);
mem_seek R7(D2Game, 10933, 10C03, 1100D, 8BC71, C3C51, 5F2A1, 0000, 0000);
MEMC_REF4( D2GameGetObject, version_D2Game == V110?caller_updateItem: caller_updateItem_9);
//6FC4100C |. E8 EFAA0700 |CALL D2Game.6FCBBB00
mem_seek R7(D2Game, 1097B, 10C4B, 11058, 8BCD1, C3CB1, 5F301, 0000);
mem_seek R7(D2Game, 1097B, 10C4B, 11058, 8BCD1, C3CB1, 5F301, 0000, 0000);
MEMC_REF4( D2GameGetObject, version_D2Game == V110?caller_updateItem: caller_updateItem_9);
//6FC41057 |. E8 A4AA0700 ||CALL D2Game.6FCBBB00
}
// Update client on loading
mem_seek R7(D2Game, 23EB, 2426, 25D4, 53482, C6A32, ED502, 4BF12);//6FC325D4-6FC30000
mem_seek R7(D2Game, 23EB, 2426, 25D4, 53482, C6A32, ED502, 4BF12, E7548);//6FC325D4-6FC30000
memt_byte( 0x5F ,0xE8); // CALL
MEMT_REF4( 0xC0335D5E , caller_updateClientPlayerOnLoading);
//6FC325D4 |> 5F POP EDI
@ -339,57 +345,65 @@ void Install_PlayerCustomData()
//6FC6BF13 |. 5E POP ESI
//6FC6BF14 |. 5D POP EBP
//6FC6BF15 |. 33C0 XOR EAX,EAX
//6FD07548 |> 5F POP EDI
//6FD07549 |. 5E POP ESI
//6FD0754A |. 5D POP EBP
//6FD0754B |. 33C0 XOR EAX,EAX
// Free custom data.
mem_seek R7(D2Common, 7055C, 7065C, 80483, 4F82D, 5C9CD, 5856D, 3093D);
mem_seek R7(D2Common, 7055C, 7065C, 80483, 4F82D, 5C9CD, 5856D, 3093D, 1705D);
MEMJ_REF4( D2FreeMem, free_PlayerCustomData);
//01BD0482 |. E8 C53E0000 CALL <JMP.&Fog.#10046>
//6FD9F82C |. E8 E399FBFF CALL <JMP.&Fog.#10046>
//6FDAC9CC |. E8 3BC8FAFF CALL <JMP.&Fog.#10046>
//6FDA856C |. E8 E70CFBFF CALL <JMP.&Fog.#10046>
//6FD8093C |. E8 E788FDFF CALL <JMP.&Fog.#10046>
//6FD6705C |. E8 CF3EFFFF CALL <JMP.&Fog.#10046>
// Free item in Stash (Server-side)
mem_seek R7(D2Game, 7D12B, 7D62B, 8D5A4, 99112, BFDB2, 94242, E1162);
mem_seek R7(D2Game, 7D12B, 7D62B, 8D5A4, 99112, BFDB2, 94242, E1162, 6F7C2);
MEMJ_REF4( D2UnitGetNextItem, version_D2Game >= V111 ? callerServer_getNextItemToFree_111 : version_D2Game == V110 ? callerServer_getNextItemToFree : callerServer_getNextItemToFree_9);//0x0005E204
//6FCBD5A3 . E8 04E20500 CALL <JMP.&D2Common.#10304>
//02019111 |. E8 5016F7FF |CALL <JMP.&D2Common.#10934>
//0202FDB1 |. E8 30AAF4FF |CALL <JMP.&D2Common.#11140>
//6FCB4241 |. E8 8862F7FF |CALL <JMP.&D2Common.#10770>
//6FD01161 |. E8 6693F2FF |CALL <JMP.&D2Common.#10464>
//6FC8F7C1 |. E8 44AEF9FF |CALL <JMP.&D2Common.#10879>
// Free item in Stash (Client-side)
mem_seek R7(D2Client, 8EF8F, 8E30F, 89B32, 26404, 4C264, 1F2D4, A5C94);//6FB29B31-6FAA0000
mem_seek R7(D2Client, 8EF8F, 8E30F, 89B32, 26404, 4C264, 1F2D4, A5C94, 621E4);//6FB29B31-6FAA0000
MEMJ_REF4( D2UnitGetNextItem, version_D2Game >= V111 ? callerClient_getNextItemToFree_111 : version_D2Game == V110 ? callerClient_getNextItemToFree : callerClient_getNextItemToFree_9);//0x00040F34
//6FB29B31 E8 340F0400 CALL <JMP.&D2Common.#10304>
//6FAD6403 |. E8 925DFEFF |CALL <JMP.&D2Common.#10934>
//6FAFC263 |. E8 38FFFBFF |CALL <JMP.&D2Common.#11140>
//6FACF2D3 |. E8 4CD1FEFF |CALL <JMP.&D2Common.#10770>
//6FB55C93 |. E8 D068F6FF |CALL <JMP.&D2Common.#10464>
//6FB121E3 |. E8 7AA1FAFF |CALL <JMP.&D2Common.#10879>
if ( version_D2Common >= V110 )
{
// Test if it's already removed from inventory
mem_seek R7(D2Common, 0000, 0000, 4E689, 26E33, 42133, 6AE93, 21B23);
mem_seek R7(D2Common, 0000, 0000, 4E689, 26E33, 42133, 6AE93, 21B23, 3B393);
memt_byte( 0x0D , 0x07);
//01D2E688 75 0D JNZ SHORT D2Common.01D2E697
//6FD76E32 |. 74 0D JE SHORT D2Common.6FD76E41
//6FD92132 |. 74 0D JE SHORT D2Common.6FD92141
//6FDBAE92 |. 74 0D JE SHORT D2Common.6FDBAEA1
//6FD71B22 |. 74 0D JE SHORT D2Common.6FD71B31
//6FD8B392 |. 74 0D JE SHORT D2Common.6FD8B3A1
} else {
mem_seek R7(D2Game, 7D176, 7D676, 0000, 0000, 0000, 0000, 0000);
mem_seek R7(D2Game, 7D176, 7D676, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0x74 , 0x90);//MOV EAX,EDI
memt_byte( 0x35 , 0x90);//NOP
//6FCAD176 |. 74 35 |JE SHORT D2Game.6FCAD1AD
mem_seek R7(D2Client, 8F0CA, 8E44A, 0000, 0000, 0000, 0000, 0000);
mem_seek R7(D2Client, 8F0CA, 8E44A, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0x0F , 0x90);//MOV EAX,EDI
memt_byte( 0x84 , 0x90);//NOP
memt_dword( 0x000000BF , 0x90909090);//NOP
//6FB2F0CA |. 0F84 BF000000 |JE D2Client.6FB2F18F
mem_seek R7(D2Client, 8F13C, 8E4BC, 0000, 0000, 0000, 0000, 0000);
mem_seek R7(D2Client, 8F13C, 8E4BC, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0x74 , 0x90);//MOV EAX,EDI
memt_byte( 0x6F , 0x90);//NOP
//6FB2F13C |. 74 6F |JE SHORT D2Client.6FB2F1AD

BIN
PlugY/PlugY.aps
View File

Binary file not shown.

9
PlugY/PlugY.rc
View File

@ -65,8 +65,8 @@ LANGUAGE LANG_FRENCH, SUBLANG_FRENCH
//
VS_VERSION_INFO VERSIONINFO
FILEVERSION 10,0,0,0
PRODUCTVERSION 10,0,0,0
FILEVERSION 11,0,0,0
PRODUCTVERSION 11,0,0,0
FILEFLAGSMASK 0x17L
#ifdef _DEBUG
FILEFLAGS 0x1L
@ -81,11 +81,12 @@ BEGIN
BEGIN
BLOCK "040004b0"
BEGIN
VALUE "Comments", "Modified by L'Autour"
VALUE "CompanyName", "Yohann Nicolas"
VALUE "FileVersion", "10.00"
VALUE "FileVersion", "11.00"
VALUE "OriginalFilename", "PlugY.dll"
VALUE "ProductName", "PlugY, The Survival Kit"
VALUE "ProductVersion", "10.00"
VALUE "ProductVersion", "11.00"
END
END
BLOCK "VarFileInfo"

BIN
PlugY/PlugY.suo
View File

Binary file not shown.

19
PlugY/PlugY.vcproj
View File

@ -152,6 +152,7 @@
<Tool
Name="VCLinkerTool"
AdditionalDependencies="opends60.lib"
OutputFile="$(OutDir)\$(ProjectName).dll"
LinkIncremental="1"
GenerateDebugInformation="false"
SubSystem="2"
@ -182,7 +183,7 @@
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="copy $(TargetPath) &quot;..\PlugYInstaller\PlugY.dll&quot;&#x0D;&#x0A;copy $(TargetPath) &quot;D:\Jeux\Blizzard\Diablo II\PlugY.dll&quot;&#x0D;&#x0A;copy $(TargetPath) &quot;D:\www\PlugY.dll&quot;&#x0D;&#x0A;"
CommandLine="copy $(TargetPath) &quot;..\PlugYInstaller\PlugY.dll&quot;&#x0D;&#x0A;copy $(TargetPath) &quot;D:\Games\Diablo II\PlugY.dll&quot;&#x0D;&#x0A;&#x0D;&#x0A;"
/>
</Configuration>
</Configurations>
@ -361,6 +362,14 @@
RelativePath="WorldEvent.cpp"
>
</File>
<Filter
Name="Coomons"
>
<File
RelativePath="..\Commons\VersionInfo.cpp"
>
</File>
</Filter>
</Filter>
<Filter
Name="Header Files"
@ -438,6 +447,10 @@
RelativePath="loadPlayerData.h"
>
</File>
<File
RelativePath=".\LocaleStrings.h"
>
</File>
<File
RelativePath="mainScreen.h"
>
@ -561,6 +574,10 @@
RelativePath="..\Commons\updatingConst.h"
>
</File>
<File
RelativePath="..\Commons\VersionInfo.h"
>
</File>
</Filter>
</Filter>
<Filter

16
PlugY/PlugYFiles.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Adding custom data.
Save and load infinity & shared Stash
@ -88,7 +89,7 @@ void Install_PlugYFiles()
log_msg("Patch Storm to found custom file. (PlugYFiles)\n");
// Try in Diablo II\PlugY\ if file not found
mem_seek R7(Storm, 192C6, 19296, 18677, 2CC69, 14259, 121E9, 28D89);//( (DWORD)D2Storm268 + V7(Storm, 01A8, 01A8, 01AB, 0429, 0429, 0429, 0000) );
mem_seek R7(Storm, 192C6, 19296, 18677, 2CC69, 14259, 121E9, 28D89, 2DA79);//( (DWORD)D2Storm268 + V7(Storm, 01A8, 01A8, 01AB, 0429, 0429, 0429, 0000) );
memt_byte( 0xFF ,0x90); // NOP
memt_byte( 0x15 ,0xE8); // CALL
MEMD_REF4( LeaveCriticalSection, version_Storm >= V111 ? caller_isModFile_111 : caller_isModFile);
@ -97,6 +98,7 @@ void Install_PlugYFiles()
//6FC04259 |. FF15 3832C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
//6FC021E9 |. FF15 4432C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
//6FC18D89 |. FF15 5832C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
//6FC1DA79 |. FF15 3C32C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
log_msg("\n" );
@ -170,7 +172,7 @@ void Install_PlugYImagesFiles()
log_msg("Patch D2Client to load/free custom images. (PlugYImagesFiles)\n");
// Load custom images
mem_seek R7(D2Client, 57E21, 57E21, 5E4B1, 2E101, B67E1, 82761, 27EAE);
mem_seek R7(D2Client, 57E21, 57E21, 5E4B1, 2E101, B67E1, 82761, 27EAE, 6E0BE);
memt_byte( 0xB9 ,0xE8);
MEMT_REF4( 0x0000000C , caller_loadCustomImages);
//6FAFE4B1 |. B9 0C000000 MOV ECX,0C
@ -178,9 +180,10 @@ void Install_PlugYImagesFiles()
//6FB667E1 |. B9 0C000000 MOV ECX,0C
//6FB32761 |. B9 0C000000 MOV ECX,0C
//6FAD7EAE |. B9 0C000000 MOV ECX,0C
//6FB1E0BE |. B9 0C000000 MOV ECX,0C
// Free custom images
mem_seek R7(D2Client, 57FA9, 57FA9, 5E639, 2D12D, B580D, 8158D, 26F8D);
mem_seek R7(D2Client, 57FA9, 57FA9, 5E639, 2D12D, B580D, 8158D, 26F8D, 6D07D);
memt_byte( 0xB9 ,0xE8);
MEMT_REF4( 0x0000000C , caller_freeCustomImages);
//6FAFE639 |> B9 0C000000 MOV ECX,0C
@ -188,6 +191,7 @@ void Install_PlugYImagesFiles()
//6FB6580D |> B9 0C000000 MOV ECX,0C
//6FB3158D |> B9 0C000000 MOV ECX,0C
//6FAD6F8D |> B9 0C000000 MOV ECX,0C
//6FB1D07D |> B9 0C000000 MOV ECX,0C
log_msg("\n" );
@ -243,7 +247,7 @@ void Install_PlugYTxtFiles()
// lookupItemStatCost = (void*)R7(D2Common, A1D70, A1D70, AA1D8, 0000, 0000, 0000, 0000);
// Load custom txt files
mem_seek R7(D2Common, 7F4B, 7F4B, 2F7D7, 76854, 37444, 81C44, 5D6E4);
mem_seek R7(D2Common, 7F4B, 7F4B, 2F7D7, 76854, 37444, 81C44, 5D6E4, 855E4);
MEMC_REF4( D2LoadSuperuniques, version_D2Common >= V111 ? caller_loadTxtFiles_111 : caller_loadTxtFiles );
//6FD47F4A |. E8 B1750100 CALL D2Common.6FD5F500
//6FD47F4A |. E8 C1750100 CALL D2Common.6FD5F510
@ -252,9 +256,10 @@ void Install_PlugYTxtFiles()
//6FD87443 |. E8 58B6FFFF CALL D2Common.6FD82AA0 ; \D2Common.6FD82AA0
//6FDD1C43 |. E8 58B6FFFF CALL D2Common.6FDCD2A0 ; \D2Common.6FDCD2A0
//6FDAD6E3 |. E8 88C1FFFF CALL D2Common.6FDA9870 ; \D2Common.6FDA9870
//6FDD55E3 |. E8 58B6FFFF CALL D2Common.6FDD0C40 ; \D2Common.6FDD0C40
// Free custom txt files
mem_seek R7(D2Common, 79EC, 79EC, 10186, 332B3, 15AB3, 44E13, 5E8B3);
mem_seek R7(D2Common, 79EC, 79EC, 10186, 332B3, 15AB3, 44E13, 5E8B3, FAA3);
MEMJ_REF4( D2Fog10212, caller_freeTxtFiles );
//6FD479EB . E8 C8C00600 CALL <JMP.&Fog.#10212>
//6FD479EB . E8 C8C00600 CALL <JMP.&Fog.#10212>
@ -263,6 +268,7 @@ void Install_PlugYTxtFiles()
//6FD65AB2 |. E8 B537FFFF CALL <JMP.&Fog.#10212>
//6FD94E12 |. E8 1744FCFF CALL <JMP.&Fog.#10212>
//6FDAE8B2 |. E8 8FA9FAFF CALL <JMP.&Fog.#10212>
//6FD5FAA2 |. E8 5FB4FFFF CALL <JMP.&Fog.#10212>
log_msg("\n" );

12
PlugY/SavePath.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Changing the current save path.
@ -123,7 +124,7 @@ void Install_ChangingSavePath()
if (version_Fog >= V111)
{
// Appel de notre fct d'ajout d'un sous-répertoire
mem_seek R7(Fog, 000, 000, 000, 185F6, 1C106, 1F086, 17F86);
mem_seek R7(Fog, 000, 000, 000, 185F6, 1C106, 1F086, 17F86, 1E146);
memt_byte( 0x83 ,0xE8); // CALL changeSavePath
MEMT_REF4( 0x0575FFF8, changeSavePath_111);
//6FF685F6 . 83F8 FF CMP EAX,-1
@ -134,18 +135,21 @@ void Install_ChangingSavePath()
//6FF6F089 . 75 05 JNZ SHORT Fog.6FF6F090
//6FF67F86 . 83F8 FF CMP EAX,-1
//6FF67F89 . 75 05 JNZ SHORT Fog.6FF67F90
//6FF6E146 . 83F8 FF CMP EAX,-1
//6FF6E149 . 75 05 JNZ SHORT Fog.6FF50F64
// Pour créer le bon chemin de sauvegarde
mem_seek R7(Fog, 000, 000, 000, 18616, 1C126, 1F0A6, 17FA6);
mem_seek R7(Fog, 000, 000, 000, 18616, 1C126, 1F0A6, 17FA6, 1E166);
MEMJ_REF4( D2Storm503, forCreateSavePath);
//6FF68615 . E8 A246FFFF CALL <JMP.&Storm.#503>
//6FF6C125 . E8 C20BFFFF CALL <JMP.&Storm.#503>
//6FF6F0A5 . E8 34DDFEFF CALL <JMP.&Storm.#503>
//6FF67FA5 . E8 504EFFFF CALL <JMP.&Storm.#503>
//6FF6E165 . E8 6AEBFEFF CALL <JMP.&Storm.#503>
// Remove registry update
mem_seek R7(Fog, 000, 000, 000, 1861A, 1C12A, 1F0AA, 17FAA);
mem_seek R7(Fog, 000, 000, 000, 1861A, 1C12A, 1F0AA, 17FAA, 1E16A);
memt_byte( 0x56 ,0xEB); // JMP SHORT fog.6FF6862C
memt_byte( 0x6A ,0x10); //
memt_byte( 0x00 ,0x90); // NOP
@ -166,6 +170,8 @@ void Install_ChangingSavePath()
//6FF6F0B7 . E8 58DDFEFF CALL <JMP.&Storm.#425>
//6FF67FAA . 56 PUSH ESI
//6FF67FAB . 6A 00 PUSH 0
//6FF6E16A . 56 PUSH ESI
//6FF6E16B . 6A 00 PUSH 0
} else {

21
PlugY/SavePlayerData.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Save Player Custom Data.
@ -521,16 +522,17 @@ void Install_SavePlayerData()
log_msg("Patch D2Game & D2Client for save Player's custom data. (SavePlayerData)\n");
//Save single player custom data.
mem_seek R7(D2Game, 4DF04, 4E304, 5A624, B9365, 25475, 44165, 53F35);
mem_seek R7(D2Game, 4DF04, 4E304, 5A624, B9365, 25475, 44165, 53F35, 39835);
MEMJ_REF4( D2FogGetSavePath, version_D2Game >= V111 ? caller_SaveSPPlayerCustomData_111 : version_D2Game != V109b ? caller_SaveSPPlayerCustomData : caller_SaveSPPlayerCustomData_9);
//6FC8A623 E8 3E210900 CALL <JMP.&Fog.#10115>
//02039364 |. E8 3B0FF5FF CALL <JMP.&Fog.#10115>
//01F95474 |. E8 C34EFEFF CALL <JMP.&Fog.#10115>
//6FC64164 |. E8 EB61FCFF CALL <JMP.&Fog.#10115>
//6FC73F34 |. E8 DD63FBFF CALL <JMP.&Fog.#10115>
//6FC59834 |. E8 FB0AFDFF CALL <JMP.&Fog.#10115>
//Send SaveFiles
mem_seek R7(D2Game, 4DFFA, 4E3FA, 5A720, B92DB, 253EB, 440DB, 53EAB);
mem_seek R7(D2Game, 4DFFA, 4E3FA, 5A720, B92DB, 253EB, 440DB, 53EAB, 397AB);
memt_byte( 0x8B ,0x90); // NOP
memt_byte( version_D2Game >= V111 ? 0x44 : version_D2Game != V109b ? 0x7C : 0x74 ,0xE8); // CALL
MEMT_REF4( version_D2Game >= V111 ? 0xC0850424 : version_D2Game != V109b ? 0xFF851024 : 0xF6851024, version_D2Game >= V111 ? caller_SendSaveFilesToSave_111 : version_D2Game != V109b ? caller_SendSaveFilesToSave : caller_SendSaveFilesToSave_9);
@ -544,8 +546,10 @@ void Install_SavePlayerData()
//6FC640DF |. 85C0 TEST EAX,EAX
//6FC73EAB |. 8B4424 04 MOV EAX,DWORD PTR SS:[ESP+4]
//6FC73EAF |. 85C0 TEST EAX,EAX
//6FC597AB |. 8B4424 04 MOV EAX,DWORD PTR SS:[ESP+4]
//6FC597AF |. 85C0 TEST EAX,EAX
mem_seek R7(D2Game, 7993, 7A13, 7BBB, E2943, E6D83, A89D3, 2D173);
mem_seek R7(D2Game, 7993, 7A13, 7BBB, E2943, E6D83, A89D3, 2D173, BEDD3);
memt_byte( 0x8B ,0x90); // NOP
memt_byte( version_D2Game >= V110 ? 0x8E : 0x86 ,0xE8); // CALL
MEMT_REF4( version_D2Game >= V110 ? 0x0000017C : version_D2Game == V109d ? 0x0000174 : 0x00000150, version_D2Game >= V110 ? caller_ManageNextPacketToSend : version_D2Game == V109d ? caller_ManageNextPacketToSend_9d : caller_ManageNextPacketToSend_9);
@ -554,6 +558,7 @@ void Install_SavePlayerData()
//02056D83 |. 8B8E 7C010000 MOV ECX,DWORD PTR DS:[ESI+17C]
//6FCC89D3 |. 8B8E 7C010000 MOV ECX,DWORD PTR DS:[ESI+17C]
//6FC4D173 |. 8B8E 7C010000 MOV ECX,DWORD PTR DS:[ESI+17C]
//6FCDEDD3 |. 8B8E 7C010000 MOV ECX,DWORD PTR DS:[ESI+17C]
// mem_seek R7(D2Game, 7B82, 7C05, 7DCF, 0000, 0000, 0000, 0000);//117FC, 117EC, 11DBC
// memt_byte( 0x8B ,0xE8); // CALL
@ -565,16 +570,17 @@ void Install_SavePlayerData()
if ( version_D2Game >= V111 )
{
//Received SaveFiles
mem_seek R7(D2Client, 116F0, 116E0, 11CB0, 89246, 32076, 7BCD6, 43946);
mem_seek R7(D2Client, 116F0, 116E0, 11CB0, 89246, 32076, 7BCD6, 43946, 448E6);
memt_byte( 0x0F ,0xE8);
MEMT_REF4( 0x0C2444B6, caller_ReceivedSaveFilesToSave_111);
//6FB39246 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C]
//6FAE2076 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C]
//6FB2BCD6 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C]
//6FAF3946 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C]
//6FAF48E6 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C]
// Save multiplayer player custom data.
mem_seek R7(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, AC572);
mem_seek R7(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, AC572, 829C2);
memt_byte( 0x81 ,0xE8); // CALL
MEMT_REF4( 0x55AA55F9, caller_SaveMPPlayerCustomData_111);
memt_byte( 0xAA ,0x90); // CALL
@ -582,16 +588,17 @@ void Install_SavePlayerData()
//6FB6D7F2 |. 81F9 55AA55AA CMP ECX,AA55AA55
//6FB14A22 |. 81F9 55AA55AA CMP ECX,AA55AA55
//6FB5C572 |. 81F9 55AA55AA CMP ECX,AA55AA55
//6FB329C2 |. 81F9 55AA55AA CMP ECX,AA55AA55
} else {
//Received SaveFiles
mem_seek R7(D2Client, 116F0, 116E0, 11CB0, 89246, 32076, 7BCD6, 0000);
mem_seek R7(D2Client, 116F0, 116E0, 11CB0, 89246, 32076, 7BCD6, 0000, 0000);
memt_byte( 0x81 ,0x90); // NOP
memt_byte( 0xEC ,0xE8); // CALL
MEMT_REF4( 0x000005F4, caller_ReceivedSaveFilesToSave);
//6FAB1CB0 |$ 81EC F4050000 SUB ESP,5F4
// Save multiplayer player custom data.
mem_seek R7(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, 0000);
mem_seek R7(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, 0000, 0000);
memt_byte( 0x8B ,0xE8); // CALL
MEMT_REF4( 0x04518B01, caller_SaveMPPlayerCustomData);
//6FAB1DBC |. 8B01 MOV EAX,DWORD PTR DS:[ECX]

5
PlugY/SkillPerLevelUp.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Change Skill win per level up.
@ -36,14 +37,14 @@ void Install_SkillPerLevelUp()
log_msg("Patch D2Game for change Skill points win per level up. (SkillPerLevelUp)\n");
mem_seek R7(D2Game, 42261, 42651, 4ED60, D7AE5, 79695, AA455, EB1E5);
mem_seek R7(D2Game, 42261, 42651, 4ED60, D7AE5, 79695, AA455, EB1E5, EDCA5);
MEMJ_REF4( V2AddPlayerStat, version_D2Game >= V111 ? caller_changeSkillPerLevelUp_111 : caller_changeSkillPerLevelUp);
//6FC7ED5F |. E8 56CB0900 CALL <JMP.&D2Common.#10518>
//02057AE4 |. E8 9F28F3FF CALL <JMP.&D2Common.#10109>
//01FE9694 |. E8 1B0DF9FF CALL <JMP.&D2Common.#10627>
//6FCCA454 |. E8 5F01F6FF CALL <JMP.&D2Common.#10762>
//6FD0B1E4 |. E8 E9F2F1FF CALL <JMP.&D2Common.#10551>
//6FD0DCA4 |. E8 FDC6F1FF CALL <JMP.&D2Common.#10645>
log_msg("\n");

4
PlugY/StatPerLevelUp.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Change Stat win per level up.
@ -34,13 +35,14 @@ void Install_StatPerLevelUp()
log_msg("Patch D2Game for change Stat points win per level up. (StatPerLevelUp)\n");
mem_seek R7(D2Game, 42258, 42648, 4ED55, D7ADA, 7968A, AA44A, EB1DA);
mem_seek R7(D2Game, 42258, 42648, 4ED55, D7ADA, 7968A, AA44A, EB1DA, EDC9A);
MEMJ_REF4( V2AddPlayerStat, version_D2Game >= V111 ? caller_changeStatPerLevelUp_111 : caller_changeStatPerLevelUp);
//6FC7ED54 |. E8 61CB0900 CALL <JMP.&D2Common.#10518>
//02057AD9 |. E8 AA28F3FF CALL <JMP.&D2Common.#10109>
//01FE9689 |. E8 260DF9FF CALL <JMP.&D2Common.#10627>
//6FCCA449 |. E8 6A01F6FF CALL <JMP.&D2Common.#10762>
//6FD0B1D9 |. E8 F4F2F1FF CALL <JMP.&D2Common.#10551>
//6FD0DC99 |. E8 08C7F1FF CALL <JMP.&D2Common.#10645>
log_msg("\n");

43
PlugY/StatsPoints.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Unassign Stats Point for futher re-assignment.
@ -331,39 +332,42 @@ void Install_StatsPoints()
//if ( version_D2Client < V113 )
{
// Always print stat button images.
mem_seek R7(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5);
mem_seek R7(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5, BF955);
memt_byte( 0x8B, 0xEB ); // JMP SHORT D2Client.6FAD0088
memt_byte( 0x4C, V7(D2Client, 12, 12, 13, 13, 13, 13, 13) );
memt_byte( 0x4C, V7(D2Client, 12, 12, 13, 13, 13, 13, 13, 13) );
memt_byte( 0x24, 0x90 ); // NOP
memt_byte( V7(D2Client, 20, 20, 14, 1C, 1C, 1C, 1C), 0x90 ); // NOP (V109d:0x20 , V110:0x14
memt_byte( V7(D2Client, 20, 20, 14, 1C, 1C, 1C, 1C, 1C), 0x90 ); // NOP (V109d:0x20 , V110:0x14
//6FAD0073 8B4C24 14 MOV ECX,DWORD PTR SS:[ESP+14]
//6FB32BBA > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB3963A > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB1B59A > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB6D1B5 |> 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB6F955 > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//print our buttons
mem_seek R7(D2Client, 29B9D, 29B8D, 300FD, 82C54, 896D4, 6B637, BD23E);
mem_seek R7(D2Client, 29B9D, 29B8D, 300FD, 82C54, 896D4, 6B637, BD23E, BF9DE);
MEMJ_REF4( D2PrintImage, caller_printUnassignStatsBtn);
//6FB32C53 . E8 82A3F8FF CALL <JMP.&D2gfx.#10047>
//6FB396D3 . E8 D238F8FF CALL <JMP.&D2gfx.#10044>
//6FB1B636 . E8 431AFAFF CALL <JMP.&D2gfx.#10024>
//6FB6D23D . E8 54FEF4FF CALL <JMP.&D2gfx.#10041>
//6FB6F9DD . E8 ECD5F4FF CALL <JMP.&D2gfx.#10042>
// Always manage push down.
mem_seek R7(D2Client, 2AA7B, 2AA6B, 3134D, 827D9, 89259, 6B1B9, BCDD9);
mem_seek R7(D2Client, 2AA7B, 2AA6B, 3134D, 827D9, 89259, 6B1B9, BCDD9, BF579);
memt_byte( 0x74, 0x90 ); // NOP
memt_byte( 0x4E, 0x90 ); // NOP
//6FAD134D 74 4E JE SHORT D2Client.6FAD139D
//6FAD134D 74 4E JE SHORT D2Client.6FAD139D
//6FB327D9 . 74 4E JE SHORT D2Client.6FB32829
//6FB39259 . 74 4E JE SHORT D2Client.6FB392A9
//6FB1B1B9 74 4E JE SHORT D2Client.6FB1B209
//6FB1B1B9 74 4E JE SHORT D2Client.6FB1B209
//6FB6CDD9 . 74 4E JE SHORT D2Client.6FB6CE29
//6FB6F579 . 74 4E JE SHORT D2Client.6FB6F5C9
if ( version_D2Client >= V111 )
{
// On Push down.
mem_seek R7(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 6B224, BCE44);
mem_seek R7(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 6B224, BCE44, BF5E4);
memt_byte( 0x6B, 0xE8 );
MEMT_REF4( 0x01BF0ED2, caller_pushDown_111);
memt_byte( 0x00, 0x6B ); // IMUL EDX,EDX,0E
@ -377,10 +381,12 @@ void Install_StatsPoints()
//6FB1B227 BF 01000000 MOV EDI,1
//6FB6CE44 > 6BD2 0E IMUL EDX,EDX,0E
//6FB6CE47 . BF 01000000 MOV EDI,1
//6FB6F5E4 > 6BD2 0E IMUL EDX,EDX,0E
//6FB6F5E7 . BF 01000000 MOV EDI,1
} else {
// On Push down.
mem_seek R7(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 0000, 0000);
mem_seek R7(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 0000, 0000, 0000);
memt_byte( 0x8D, 0xE8 ); // CALL
MEMT_REF4( 0x0000D504, caller_pushDown);
memt_byte( 0x00, 0x90 ); // NOP
@ -392,17 +398,18 @@ void Install_StatsPoints()
if ( version_D2Client >= V110 )
{
// Always manage push up.
mem_seek R7(D2Client, 0000, 0000, 3152E, 83869, 8A2E9, 6C249, BDE49);
mem_seek R7(D2Client, 0000, 0000, 3152E, 83869, 8A2E9, 6C249, BDE49, C05E9);
memt_byte( 0x74, 0x90 ); // NOP
memt_byte( version_D2Client >= V111 ? 0x65 : 0x68, 0x90 ); // NOP
//6FAD152E 74 68 JE SHORT D2Client.6FAD1598
//6FB33869 . 74 65 JE SHORT D2Client.6FB338D0
//6FB3A2E9 . 74 65 JE SHORT D2Client.6FB3A350
//6FB1C249 74 65 JE SHORT D2Client.6FB1C2B0
//6FB1C249 74 65 JE SHORT D2Client.6FB1C2B0
//6FB6DE49 . 74 65 JE SHORT D2Client.6FB6DEB0
//6FB705E9 . 74 65 JE SHORT D2Client.6FB70650
// Unassign stats point when ctrl is push.
mem_seek R7(D2Client, 0000, 0000, 315D3, 8391B, 8A39B, 6C2FB, BDEFB);
mem_seek R7(D2Client, 0000, 0000, 315D3, 8391B, 8A39B, 6C2FB, BDEFB, C069B);
memt_byte( 0x66, 0xE8 ); // CALL
MEMT_REF4( 0x077CC085, caller_UnassignStats);
//6FAD15D3 . 66:85C0 TEST AX,AX
@ -415,23 +422,25 @@ void Install_StatsPoints()
//6FB1C2FE . 7C 07 JL SHORT D2Client.6FB1C307
//6FB6DEFB . 66:85C0 TEST AX,AX
//6FB6DEFE . 7C 07 JL SHORT D2Client.6FB6DF07
//6FB7069B . 66:85C0 TEST AX,AX
//6FB7069E . 7C 07 JL SHORT D2Client.6FB706A7
} else {
// Always manage push up.
mem_seek R7(D2Client, 2AC55, 2AC45, 0000, 0000, 0000, 0000, 0000);
mem_seek R7(D2Client, 2AC55, 2AC45, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0x0F, 0x90 ); // NOP
memt_byte( 0x84, 0x90 ); // NOP
memt_dword( 0x000000AE, 0x90909090 ); // NOP NOP NOP NOP
//6FACAC45 . 0F84 AE000000 JE D2Client.6FACACF9
// Unassign stats point when ctrl is push.
mem_seek R7(D2Client, 2ACD9, 2ACC9, 0000, 0000, 0000, 0000, 0000);
mem_seek R7(D2Client, 2ACD9, 2ACC9, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0xB8, 0xE8 ); // CALL
MEMT_REF4( 0x00000001, caller_UnassignStats_9);
//6FACACC9 . B8 01000000 MOV EAX,1
}
// Set the id for the calling function.
mem_seek R7(D2Client, 2AD02, 2ACF2, 31611, 8395E, 8A3DE, 6C33E, BDF3E);
mem_seek R7(D2Client, 2AD02, 2ACF2, 31611, 8395E, 8A3DE, 6C33E, BDF3E, C06DE);
if ( version_D2Client >= V111 ) {
memt_byte( 0x66, 0xE8 ); // CALL
MEMT_REF4( 0x15244C89, caller_setValue_111);
@ -439,6 +448,7 @@ void Install_StatsPoints()
//6FB3A3DE . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX
//6FB1C33E . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX ; |
//6FB6DF3E . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX ; |
//6FB706DE . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX ; |
} else {
MEMC_REF4( D2SendToServer3, caller_setValue);
//6FAD1610 . E8 7BC3FDFF CALL D2Client.6FAAD990
@ -475,7 +485,7 @@ void Install_StatsLimitShiftClick()
log_msg("Patch D2Client for limit the assigment of stat points when shift is used. (LimitShift)\n");
// Limit the assigment of stat points.
mem_seek R7(D2Client, 2ACD0, 2ACC0, 315CD, 83915, 8A395, 6C2F5, BDEF5);
mem_seek R7(D2Client, 2ACD0, 2ACC0, 315CD, 83915, 8A395, 6C2F5, BDEF5, C0695);
memt_byte( 0xFF, 0x90 ); // NOP
memt_byte( 0x15, 0xE8 ); // CALL
MEMD_REF4( GetKeyState, version_D2Client >= V111 ? caller_LimitShift_111 : caller_LimitShift);
@ -484,6 +494,7 @@ void Install_StatsLimitShiftClick()
//6FB3A395 . FF15 08F1B76F CALL DWORD PTR DS:[<&USER32.GetKeyState>]
//6FB1C2F5 . FF15 10F1B76F CALL DWORD PTR DS:[<&USER32.GetKeyState>>; \GetKeyState
//6FB6DEF5 . FF15 04F1B76F CALL DWORD PTR DS:[<&USER32.GetKeyState>>; \GetKeyState
//6FB70695 . FF15 2001B86F CALL DWORD PTR DS:[<&USER32.GetKeyState>>; \GetKeyState
log_msg("\n");

22
PlugY/UberQuest.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Uber Quest Management.
@ -327,42 +328,45 @@ void Install_UberQuest()
DWORD oldProtection;
// open Red Portal
VirtualProtect((LPVOID)R7(D2Game,0,0,0,FA480,FA7B8, FA228, FA5F0), 8, PAGE_EXECUTE_READWRITE, &oldProtection);
mem_seek R7(D2Game, 0000, 0000, 0000, FA480, FA7B8, FA228, FA5F0);
VirtualProtect((LPVOID)R7(D2Game,0,0,0,FA480,FA7B8, FA228, FA5F0, FA2C4), 8, PAGE_EXECUTE_READWRITE, &oldProtection);
mem_seek R7(D2Game, 0000, 0000, 0000, FA480, FA7B8, FA228, FA5F0, FA2C4);
MEMT_DWORD( D2OpenPandPortal , openPandPortal);
MEMT_DWORD( D2OpenPandFinalPortal , openPandFinalPortal);
//0201E357 |. FFD0 |CALL EAX
//01FA77E7 |. FFD0 |CALL EAX
//6FCF3CC7 |. FFD0 |CALL EAX
//6FC92437 |. FFD0 |CALL EAX
VirtualProtect((LPVOID)R7(D2Game,0,0,0,FA480,FA7B8, FA228, FA5F0), 8, oldProtection, &oldProtection);
//6FCB7127 |. FFD0 |CALL EAX
VirtualProtect((LPVOID)R7(D2Game,0,0,0,FA480,FA7B8, FA228, FA5F0, FA2C4), 8, oldProtection, &oldProtection);
// manage uberIA (fct table at 0209E7E8)
VirtualProtect((LPVOID)(R7(D2Game,0,0,0,10E7E8,10ECD0,10EF58,10E788) + 145*0x10), 0x30, PAGE_EXECUTE_READWRITE, &oldProtection);
mem_seek R7(D2Game, 0000, 0000, 0000, 10F100, 10F5E8, 10F870, 10F0A0);
VirtualProtect((LPVOID)(R7(D2Game,0,0,0,10E7E8,10ECD0,10EF58,10E788, 10ED00) + 145*0x10), 0x30, PAGE_EXECUTE_READWRITE, &oldProtection);
mem_seek R7(D2Game, 0000, 0000, 0000, 10F100, 10F5E8, 10F870, 10F0A0, 10F618);
MEMT_DWORD( D2UberBaalIA , uberBaalIA);
mem_seek R7(D2Game, 0000, 0000, 0000, 10F110, 10F5F8, 10F880, 10F0B0);
mem_seek R7(D2Game, 0000, 0000, 0000, 10F110, 10F5F8, 10F880, 10F0B0, 10F628);
MEMT_DWORD( D2UberMephIA , uberMephIA);
mem_seek R7(D2Game, 0000, 0000, 0000, 10F120, 10F608, 10F890, 10F0C0);
mem_seek R7(D2Game, 0000, 0000, 0000, 10F120, 10F608, 10F890, 10F0C0, 10F638);
MEMT_DWORD( D2UberDiabloIA , uberDiabloIA);
VirtualProtect((LPVOID)(R7(D2Game,0,0,0,10E7E8,10ECD0,10EF58,10E788) + 145*0x10), 0x30, oldProtection, &oldProtection);
VirtualProtect((LPVOID)(R7(D2Game,0,0,0,10E7E8,10ECD0,10EF58,10E788, 10ED00) + 145*0x10), 0x30, oldProtection, &oldProtection);
//0202ADA7 |> B8 E8E70902 MOV EAX,D2Game.0209E7E8
//01FD2BE7 |> B8 D0EC0702 MOV EAX,D2Game.0207ECD0
//6FC3B597 |> B8 58EFD26F MOV EAX,D2Game.6FD2EF58
//6FCBD157 |> B8 88E7D26F MOV EAX,D2Game.6FD2E788
//6FC5C617 |> B8 00EDD26F MOV EAX,D2Game.6FD2ED00
// spawn Uber
// mem_seek R7(D2Game, 0000, 0000, 0000, 98DAD, 0000, 0000, 0000);
// MEMJ_REF4( D2WarpPlayer , spawnUber);
//02028DAC |. E8 491CF7FF CALL <JMP.&D2Common.#10872>
mem_seek R7(D2Game, 0000, 0000, 0000, E26E2, E6B52, A850B, 2CCAB);
mem_seek R7(D2Game, 0000, 0000, 0000, E26E2, E6B52, A850B, 2CCAB, BE9AB);
MEMC_REF4( D2Game235C0 , spawnUber);
//020726E1 |. E8 2A46FFFF ||CALL D2Game.02066D10
//02056B51 |. E8 6ACAF3FF ||CALL D2Game.01F935C0
//6FCC850A |. E8 014FF6FF ||CALL D2Game.6FC2D410
//6FC4CCAA |. E8 3134FFFF ||CALL D2Game.6FC400E0
//6FCDE9AA |. E8 D1AFF9FF ||CALL D2Game.6FC79980
log_msg("\n");

4
PlugY/UpdateClient.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Updating client.
@ -74,13 +75,14 @@ void Install_UpdateClient()
log_msg("Patch D2Client for received Item packet. (UpdateClient)\n");
// execute if it's our packet else continue
mem_seek R7(D2Client, 14236, 14226, 145B6, 9C6B6, BFE86, 66E06, AE896);
mem_seek R7(D2Client, 14236, 14226, 145B6, 9C6B6, BFE86, 66E06, AE896, 84D96);
MEMT_REF4( version_D2Client >= V111 ? 0x000000CF : 0x000000D6, version_D2Client >= V111 ? caller_handleClientUpdate_111 : caller_handleClientUpdate);
//6FAB45B4 |. 0F87 D6000000 JA D2Client.6FAB4690
//6FB4C6B4 |. 0F87 CF000000 JA D2Client.6FB4C789
//6FB6FE84 |. 0F87 CF000000 JA D2Client.6FB6FF59
//6FB16E04 |. 0F87 CF000000 JA D2Client.6FB16ED9
//6FB5E894 |. 0F87 CF000000 JA D2Client.6FB5E969
//6FB34D94 |. 0F87 CF000000 JA D2Client.6FB34E69
log_msg("\n");

3
PlugY/UpdateServer.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Updating server.
@ -100,7 +101,7 @@ void Install_UpdateServer()
log_msg("Patch D2Game for received button click message. (UpdateServer)\n");
// manage button click message from Client.
mem_seek R7(D2Game, 4A702, 4AAC2, 56EA2, 54AE3, 2C773, 975C3, CC983);
mem_seek R7(D2Game, 4A702, 4AAC2, 56EA2, 54AE3, 2C773, 975C3, CC983, 676C3);
if (version_D2Game >= V111) {
memt_byte( 0xC1, 0x57 ); // PUSH EDI
memt_byte( 0xEE, 0xE8 ); // CALL caller_handleServerUpdate

13
PlugY/WorldEvent.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
World Event Management.
@ -231,40 +232,44 @@ void Install_WorldEvent()
log_msg("Patch D2Game for active World Event. (WorldEvent)\n");
// spawn DClone
mem_seek R7(D2Game, 0000, 0000, 3F720, 4BCB1, ECF10, 41570, 25280);
mem_seek R7(D2Game, 0000, 0000, 3F720, 4BCB1, ECF10, 41570, 25280, CFBD0);
MEMC_REF4( V2SpawnMonster , version_D2Game >= V111b ? (DWORD)caller_spawnDClone_111b : version_D2Game == V111 ? (DWORD)caller_spawnDClone_111 : (DWORD)spawnDClone);
//6FC6F71F |. E8 FCFAFFFF CALL D2Game.6FC6F220
//01FCBCB0 |. E8 2BEFFFFF CALL D2Game.01FCABE0 ; \D2Game.01FCABE0
//0205CF0F |. E8 CCF8FFFF CALL D2Game.0205C7E0 ; \D2Game.0205C7E0
//6FC6156F |. E8 1CF6FFFF CALL D2Game.6FC60B90 ; \D2Game.6FC60B90
//6FC4527F |. E8 CCF6FFFF CALL D2Game.6FC44950 ; \D2Game.6FC44950
//6FCEFBCF |. E8 4CE2FFFF CALL D2Game.6FCEDE20 ; \D2Game.6FCEDE20
// verify if the item sold is a trigger of WE
mem_seek R7(D2Game, 0000, 0000, 977D0, 8E799, 92859, 84499, BFB29);
mem_seek R7(D2Game, 0000, 0000, 977D0, 8E799, 92859, 84499, BFB29, 72BE9);
MEMJ_REF4( D2TestFlags , verifIfWEItem);
//6FCC77CF |. E8 32400500 CALL <JMP.&D2Common.#10707>
//0200E798 |. E8 E9BDF7FF CALL <JMP.&D2Common.#10911>
//02002858 |. E8 E57DF7FF CALL <JMP.&D2Common.#10303>
//6FCA4498 |. E8 3B62F8FF CALL <JMP.&D2Common.#10989>
//6FCDFB28 |. E8 77ADF4FF CALL <JMP.&D2Common.#10202>
//6FC92BE8 |. E8 DD7AF9FF CALL <JMP.&D2Common.#10458>
// management of the WorldEvent
mem_seek R7(D2Game, 0000, 0000, 3CE0, 51F01, C5681, EBF41, 4A791);
mem_seek R7(D2Game, 0000, 0000, 3CE0, 51F01, C5681, EBF41, 4A791, E5F51);
MEMC_REF4( V2GetGameByClientID , version_D2Game >= V111 ? (DWORD)WEManagement : (DWORD)caller_WEManagement_1XX);
//6FC33CDF . E8 FC570000 CALL D2Game.6FC394E0
//01FD1F00 |. E8 1BE60800 CALL D2Game.02060520
//02035680 |. E8 1BF30100 CALL D2Game.020549A0
//6FD0BF40 |. E8 1BA4FBFF CALL D2Game.6FCC6360
//6FC6A790 |. E8 4B03FEFF CALL D2Game.6FC4AAE0
//6FD05F50 |. E8 AB67FDFF CALL D2Game.6FCDC700
// add client for the WorldEvent
mem_seek R7(D2Game, 0000, 0000, 1AEF, 3786A, 7055A, 6265F, CB0BF);
mem_seek R7(D2Game, 0000, 0000, 1AEF, 3786A, 7055A, 6265F, CB0BF, D556F);
MEMC_REF4( D2AddClient , version_D2Game >= V111 ? caller_addClientForWE_111 : caller_addClientForWE);
//6FC31AEE |. E8 6D510000 CALL D2Game.6FC36C60
//01FB7869 |. E8 32C50A00 CALL D2Game.02063DA0
//01FE0559 |. E8 B27C0700 CALL D2Game.02058210
//6FC8265E |. E8 FD890800 CALL D2Game.6FD0B060
//6FCEB0BE |. E8 6DE8F7FF CALL D2Game.6FC69930
//6FCF556E |. E8 FDFA0000 CALL D2Game.6FD05070
log_msg("\n");

60
PlugY/common.h
View File

@ -1,5 +1,6 @@
/*==============================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
this file implements some common and useful
function related to some Diablo II mechanisms.
@ -54,8 +55,8 @@ extern s_shifting shifting;
#define PCPY ((PYPlayerData*)((DWORD)PCPlayerData+shifting.ptPYPlayerData)) //->ptPYPlayerData
#define PCSkills (*(Skills**)((DWORD)(ptChar)+shifting.ptSkills)) //->ptSkills
#define R7(Z,A,B,C,D,E,F,G) (offset_##Z + (version_##Z == V113? 0x##G : (version_##Z == V112? 0x##F : (version_##Z == V111b? 0x##E : (version_##Z == V111? 0x##D : (version_##Z == V110? 0x##C : (version_##Z == V109d? 0x##B : 0x##A)))))))
#define V7(Z,A,B,C,D,E,F,G) (version_##Z == V113? 0x##G : (version_##Z == V112? 0x##F : (version_##Z == V111b? 0x##E : (version_##Z == V111? 0x##D : (version_##Z == V110? 0x##C : (version_##Z == V109d? 0x##B : 0x##A))))))
#define R7(Z,A,B,C,D,E,F,G,H) (offset_##Z + (version_##Z == V113d? 0x##H : (version_##Z == V113c? 0x##G : (version_##Z == V112? 0x##F : (version_##Z == V111b? 0x##E : (version_##Z == V111? 0x##D : (version_##Z == V110? 0x##C : (version_##Z == V109d? 0x##B : 0x##A))))))))
#define V7(Z,A,B,C,D,E,F,G,H) (version_##Z == V113d? 0x##H : (version_##Z == V113c? 0x##G : (version_##Z == V112? 0x##F : (version_##Z == V111b? 0x##E : (version_##Z == V111? 0x##D : (version_##Z == V110? 0x##C : (version_##Z == V109d? 0x##B : 0x##A)))))))
// Convert 4 char code in a DWORD code
@ -74,7 +75,9 @@ enum eFileVersion
V111,
V111b,
V112,
V113
V113c,
V113d,
V114a
};
extern int version_SmackW32;
@ -118,7 +121,19 @@ extern DWORD offset_Storm;
extern const char* S_CloneBattles;
extern const char* S_DarkAlliance;
int UCS2toUTF8(char* dst, int maxdst, LPWSTR src, int lensrc);
int UTF8toUCS2(LPWSTR dst, int maxdst, char* src, int lensrc);
bool initLocaleStrings();
void freeLocaleStrings();
const LPWSTR getTypeString (DWORD code, char** IdxStr);
LPWSTR getTranslatedString(int stringID);
int wSprintStringLastGender(LPWSTR buf, int lenbuf,int stringID);
LPWSTR cutStringGender(LPWSTR str);
LPWSTR setMonoString(LPWSTR str);
enum eStringList
{
STR_STATS_UNASSIGN_WITH_LIMIT=0,
@ -138,12 +153,47 @@ enum eStringList
STR_TAKE_GOLD,
STR_SHARED_GOLD_QUANTITY,
STR_PREVIOUS_PAGE,
STR_NEXT_PAGE
STR_NEXT_PAGE,
STR_ITEM_LEVEL,
STR_COW_PORTAL,
STR_PANDEMONIUM_PORTAL,
STR_PANDEMONIUM_FINAL_PORTAL,
STR_FULL,
STR_REPAIR,
STR_AND,
STR_RECHARGE,
STR_DESTROY_FILLERS,
STR_REMOVE_FILLERS,
STR_REGENERATE,
STR_WITH_N_SOCKETS,
STR_ETHERAL,
STR_NOT_ETHERAL,
STR_NOT_RUNEWORD,
STR_BASIC,
STR_EXCEPTIONAL,
STR_ELITE,
STR_CRACKED,
STR_NORMAL,
STR_SUPERIOR,
STR_MAGIC,
STR_SET,
STR_RARE,
STR_UNIQUE,
STR_CRAFTED,
STR_TEMPERED,
STR_ITEM,
STR_ITEM_SAME_TYPE,
STR_OR_UPGRADED,
STR_WITHOUT_SOCKET,
STR_WITH_SOCKET,
STR_ONLY_N_H,
STR_ONLY_HELL,
STR_ONLY_CLASS
};
bool isOnRect(DWORD x, DWORD y, DWORD x0, DWORD y0, DWORD l, DWORD h);
void freeMessage(sWinMessage* msg);
LPWSTR getTypeUString (WORD id, LPWSTR lpText, DWORD size);
char* getTypeAString (WORD id, char* lpText, DWORD size);
//char* getTypeAString (WORD id, char* lpText, DWORD size);
/*================================= END OF FILE =================================*/

7
PlugY/d2functions.h
View File

@ -1,5 +1,6 @@
/*================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
This file implements some common and useful
function related to some Diablo II mechanisms.
@ -15,9 +16,9 @@
#define E2S(F, A, R, N, P) typedef R (STDCALL *T##N) P; extern T##N N;
#define E2F(F, A, R, N, P) typedef R (FASTCALL *T##N) P; extern T##N N;
#define E2C(F, A, T, N) extern T* pt##N;
#define F7(X, Z, A,B,C,D,E,F,G, R, N, P) typedef R (X##CALL *T##N) P; extern T##N N;
#define A7(X, Z, A,B,C,D,E,F,G, R, N, P) typedef R (X##CALL *T##N) P; extern T##N N;
#define C7(Z, A,B,C,D,E,F,G, T, N) extern T* pt##N;
#define F7(X, Z, A,B,C,D,E,F,G,H, R, N, P) typedef R (X##CALL *T##N) P; extern T##N N;
#define A7(X, Z, A,B,C,D,E,F,G,H, R, N, P) typedef R (X##CALL *T##N) P; extern T##N N;
#define C7(Z, A,B,C,D,E,F,G,H, T, N) extern T* pt##N;
#include "../Commons/D2Funcs.h"
extern DataTables* SgptDataTables;

3
PlugY/parameters.h
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Modified by 1.13d by L'Autour.
Loading parameters from ini file.
@ -7,7 +8,7 @@
#pragma once
#define PLUGY_VERSION "10.00"
#define PLUGY_VERSION "11.00"
#define LOG_FILE "PlugY.log"

BIN
PlugYInstall/PlugYInstall.aps
View File

Binary file not shown.

67
PlugYInstall/PlugYInstall.cpp
View File

@ -1,5 +1,6 @@
/*=================================================================
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Patch D2gfx.dll to install PlugY.
@ -7,41 +8,46 @@
#include <windows.h>
#include <stdio.h>
#include "../Commons/VersionInfo.h"
const char* boxNameInstall = "Installation of PlugY, The Survival Kit Installation";
const char* boxNameUnInstall = "Uninstall PlugY, The Survival Kit ";
int CALL_LOAD[7] = {0x389B,0x389B,0x3870,0x8B23,0xB423,0x8F63,0xB423};
BYTE callNewLoad[7][6]={{0xE8,0x60,0x85,0x00,0x00,0x90},// JMP 6FA7BE00-6FA738A0 ;install loadlibrary
int CALL_LOAD[8] = {0x389B,0x389B,0x3870,0x8B23,0xB423,0x8F63,0xB423,0xAA03};
BYTE callNewLoad[8][6]={{0xE8,0x60,0x85,0x00,0x00,0x90},// JMP 6FA7BE00-6FA738A0 ;install loadlibrary
{0xE8,0x60,0x85,0x00,0x00,0x90},// JMP 6FA7BE00-6FA738A0 ;install loadlibrary
{0xE8,0x8B,0x85,0x00,0x00,0x90},// JMP 6FA7BE00-6FA73875 ;install loadlibrary
{0xE8,0xD8,0x42,0x00,0x00,0x90},// JMP 6FA8CE00-6FA88B28 ;install loadlibrary
{0xE8,0xD8,0x19,0x00,0x00,0x90},// JMP 6FA8CE00-6FA8B428 ;install loadlibrary
{0xE8,0x98,0x3E,0x00,0x00,0x90},// JMP 6FA8CE00-6FA88F68 ;install loadlibrary
{0xE8,0xD8,0x19,0x00,0x00,0x90}};// JMP 6FA8CE00-6FA8B428 ;install loadlibrary
BYTE callOldLoad[7][6]={{0xFF,0x15,0x3C,0xC0,0xA7,0x6F},
{0xE8,0xD8,0x19,0x00,0x00,0x90},// JMP 6FA8CE00-6FA8B428 ;install loadlibrary
{0xE8,0xF8,0x23,0x00,0x00,0x90}};// JMP 6FA8CE00-6FA8B428 ;install loadlibrary
BYTE callOldLoad[8][6]={{0xFF,0x15,0x3C,0xC0,0xA7,0x6F},
{0xFF,0x15,0x3C,0xC0,0xA7,0x6F},
{0xFF,0x15,0x40,0xC0,0xA7,0x6F},
{0xFF,0x15,0x1C,0xD1,0xA8,0x6F},
{0xFF,0x15,0x1C,0xD1,0xA8,0x6F},
{0xFF,0x15,0x1C,0xD1,0xA8,0x6F},
{0xFF,0x15,0x1C,0xD1,0xA8,0x6F},
{0xFF,0x15,0x1C,0xD1,0xA8,0x6F}};
int CALL_FREE[7] = {0x3A8C,0x3A8C,0x3A6D,0x8ACA,0xB3CA,0x8F0A,0xB3CA};
BYTE callNewFree[7][6]={{0xE8,0xAF,0x83,0x00,0x00,0x90}, // JMP 6FA7BE40-6FA73A91 ;install freelibrary
int CALL_FREE[8] = {0x3A8C,0x3A8C,0x3A6D,0x8ACA,0xB3CA,0x8F0A,0xB3CA,0xA9AA};
BYTE callNewFree[8][6]={{0xE8,0xAF,0x83,0x00,0x00,0x90}, // JMP 6FA7BE40-6FA73A91 ;install freelibrary
{0xE8,0xAF,0x83,0x00,0x00,0x90}, // JMP 6FA7BE40-6FA73A91 ;install freelibrary
{0xE8,0xD2,0x83,0x00,0x00,0x90}, // JMP 6FA7BE44-6FA73A72 ;install freelibrary
{0xE8,0x75,0x43,0x00,0x00,0x90}, // JMP 6FA8CE44-6FA88ACF ;install freelibrary
{0xE8,0x75,0x1A,0x00,0x00,0x90}, // JMP 6FA8CE44-6FA8B3CF ;install freelibrary
{0xE8,0x35,0x3F,0x00,0x00,0x90}, // JMP 6FA8CE44-6FA88F0F ;install freelibrary
{0xE8,0x75,0x1A,0x00,0x00,0x90}};// JMP 6FA8CE44-6FA8B3CF ;install freelibrary
BYTE callOldFree[7][6]={{0xFF,0x15,0x44,0xC0,0xA7,0x6F}, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{0xE8,0x75,0x1A,0x00,0x00,0x90}, // JMP 6FA8CE44-6FA8B3CF ;install freelibrary
{0xE8,0x95,0x24,0x00,0x00,0x90}};// JMP 6FA8CE44-6FA8B3CF ;install freelibrary
BYTE callOldFree[8][6]={{0xFF,0x15,0x44,0xC0,0xA7,0x6F}, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{0xFF,0x15,0x44,0xC0,0xA7,0x6F}, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{0xFF,0x15,0x48,0xC0,0xA7,0x6F}, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{0xFF,0x15,0x2C,0xD1,0xA8,0x6F}, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{0xFF,0x15,0x2C,0xD1,0xA8,0x6F}, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{0xFF,0x15,0x2C,0xD1,0xA8,0x6F}, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{0xFF,0x15,0x2C,0xD1,0xA8,0x6F}};// CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{0xFF,0x15,0x2C,0xD1,0xA8,0x6F}, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{0xFF,0x15,0x24,0xD1,0xA8,0x6F}};// CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
int CALLER_LOADPLUGY = 0xBE00;//6FA7BE00-6FA70000
BYTE caller_LoadPlugY[]={
@ -108,9 +114,9 @@ enum eFileVersion
V111b,
V112,
V113c,
UNKNOW
V113d
};
/*
int getVersion(FILE *dll)
{
int ver;
@ -143,7 +149,7 @@ int getVersion(FILE *dll)
ver = UNKNOW;
return ver;
}
*/
void updateData(int version)
{
@ -164,6 +170,7 @@ void updateData(int version)
case V111b:
case V112:
case V113c:
case V113d:
CALLER_LOADPLUGY += 0x1000;
CALLER_FREEPLUGY += 0x1000;
S_INIT += 0x1000;
@ -172,9 +179,16 @@ void updateData(int version)
*(DWORD*)(&caller_LoadPlugY[6]) = 0x6FA8D11C;
*(DWORD*)(&caller_LoadPlugY[18]) = 0x6FA8D11C;
*(DWORD*)(&caller_LoadPlugY[39]) = 0x6FA8D120;
*(DWORD*)(&caller_FreePlugY[6]) = 0x6FA8D12C;
if (version == V113d)
{
*(DWORD*)(&caller_FreePlugY[6]) = 0x6FA8D124;
*(DWORD*)(&caller_FreePlugY[48]) = 0x6FA8D124;
} else
{
*(DWORD*)(&caller_FreePlugY[6]) = 0x6FA8D12C;
*(DWORD*)(&caller_FreePlugY[48]) = 0x6FA8D12C;
}
*(DWORD*)(&caller_FreePlugY[36]) = 0x6FA8D120;
*(DWORD*)(&caller_FreePlugY[48]) = 0x6FA8D12C;
caller_LoadPlugY[13] += 0x10;
caller_LoadPlugY[14]++;
caller_LoadPlugY[25]++;
@ -192,6 +206,18 @@ void updateData(int version)
////////////////////////////// EXPORTED FUNCTIONS //////////////////////////////
int GetD2Ver()
{
char currentpath[MAX_PATH];
if (! GetD2Path(currentpath, MAX_PATH))
{
MessageBox(0,"Can't find path to Game.exe.",
boxNameInstall, MB_OK|MB_ICONEXCLAMATION);
exit(0);;
}
return GetD2Version(currentpath);
}
void Patch()
{
if (MessageBox(0,"This programm will modify the D2gfx.dll file of the current directory.\n"
@ -215,9 +241,12 @@ void Patch()
exit(0);
}
int version = getVersion(dll);
//int version = getVersion(dll);
int version = GetD2Ver();
if (version == UNKNOW)
//if (version == UNKNOW)
if (version == -1)
{
MessageBox(0,"Bad version of D2gfx.dll.\n"
"You can try to uninstall any previous version of PlugY, The Survival Kit then retry.\n"
@ -341,9 +370,11 @@ void Unpatch()
exit(0);
}
int version = getVersion(dll);
//int version = getVersion(dll);
int version = GetD2Ver();
if (version == UNKNOW)
//if (version == UNKNOW)
if (version == -1)
{
MessageBox(0,"Bad version of D2gfx.dll.\n"
"You can try to uninstall any previous version of PlugY, The Survival Kit then retry.\n"

8
PlugYInstall/PlugYInstall.rc
View File

@ -65,8 +65,8 @@ LANGUAGE LANG_FRENCH, SUBLANG_FRENCH
//
VS_VERSION_INFO VERSIONINFO
FILEVERSION 1,0,4,0
PRODUCTVERSION 1,0,4,0
FILEVERSION 1,0,5,0
PRODUCTVERSION 1,0,5,0
FILEFLAGSMASK 0x17L
#ifdef _DEBUG
FILEFLAGS 0x1L
@ -81,10 +81,10 @@ BEGIN
BEGIN
BLOCK "040c04b0"
BEGIN
VALUE "FileVersion", "1.04"
VALUE "FileVersion", "1.05"
VALUE "OriginalFilename", "PlugY_Install.exe"
VALUE "ProductName", "PlugY Installation"
VALUE "ProductVersion", "1.04"
VALUE "ProductVersion", "1.05"
END
END
BLOCK "VarFileInfo"

BIN
PlugYInstall/PlugYInstall.suo
View File

Binary file not shown.

16
PlugYInstall/PlugYInstall.vcproj
View File

@ -269,6 +269,14 @@
RelativePath="PlugYInstall.cpp"
>
</File>
<Filter
Name="Commons"
>
<File
RelativePath="..\Commons\VersionInfo.cpp"
>
</File>
</Filter>
</Filter>
<Filter
Name="Header Files"
@ -278,6 +286,14 @@
RelativePath="resource.h"
>
</File>
<Filter
Name="Commons"
>
<File
RelativePath="..\Commons\VersionInfo.h"
>
</File>
</Filter>
</Filter>
<Filter
Name="Resource Files"

43
PlugYInstaller/PlugY.nsi
View File

@ -1,8 +1,8 @@
; File created by Yohann NICOLAS.
!include "LogicLib.nsh"
; Modified by L'Autour.
!include "MUI2.nsh"
!define VERSION "10.00"
!define VERSION "11.00"
!define D2FILES "."
!define NAME "PlugY, The Survival Kit"
!define MOD_DIR "Mod PlugY"
@ -12,9 +12,10 @@
!define MUI_COMPONENTSPAGE_SMALLDESC
!define MUI_HEADERIMAGE
!define MUI_HEADERIMAGE_BITMAP "PlugYInstallerHeader.bmp"
!define MUI_LANGDLL_REGISTRY_ROOT HKLM
!define MUI_LANGDLL_REGISTRY_KEY "SOFTWARE\${NAME}"
!define MUI_LANGDLL_REGISTRY_VALUENAME "Installer Language"
;!define MUI_LANGDLL_REGISTRY_ROOT "HKLM"
;!define MUI_LANGDLL_REGISTRY_KEY "SOFTWARE\${NAME}"
;!define MUI_LANGDLL_REGISTRY_VALUENAME "Installer Language"
!define MUI_FINISHPAGE_NOAUTOCLOSE
!define MUI_UNFINISHPAGE_NOAUTOCLOSE
!define MUI_FINISHPAGE_SHOWREADME "$(README_FILENAME)"
@ -26,7 +27,7 @@
Name "${NAME} v${VERSION}"
OutFile "PlugY_The_Survival_Kit_v${VERSION}.exe"
InstallDirRegKey HKLM "${REGKEY}" "InstallPath"
InstallDirRegKey HKCU "${REGKEY}" "InstallPath"
;--------------------------------
; Pages
@ -46,47 +47,65 @@ InstallDirRegKey HKLM "${REGKEY}" "InstallPath"
; Languages
!insertmacro MUI_LANGUAGE "English"
!insertmacro MUI_LANGUAGE "French"
!insertmacro MUI_LANGUAGE "Russian"
LangString DESC_CORE ${LANG_ENGLISH} "Core files.$\nPlugY.dll will be installed in Diablo II directory."
LangString DESC_CORE ${LANG_FRENCH} "Fichiers nécessaires.$\nPlugY.dll sera installé dans le répertoire de Diablo II."
LangString DESC_CORE ${LANG_RUSSIAN} "Îñíîâíûå ôàéëû.$\nPlugY.dll äîëæåí áûòü óñòàíîâëåí â êàòàëîã Diablo II."
LangString DESC_DESKTOP_SHORTCUTS ${LANG_ENGLISH} "Add shortcut on Desktop to launch Diablo II with ${NAME}."
LangString DESC_DESKTOP_SHORTCUTS ${LANG_FRENCH} "Ajoute un raccourci pour démarrer Diablo II avec ${NAME}."
LangString DESC_DESKTOP_SHORTCUTS ${LANG_RUSSIAN} "Äîáàâèòü ÿðëûê íà ðàáî÷èé ñòîë äëÿ çàïóñêà Diablo II ñ ${NAME}."
LangString DESC_MENU_SHORTCUTS ${LANG_ENGLISH} "Add shortcuts in start menu."
LangString DESC_MENU_SHORTCUTS ${LANG_FRENCH} "Ajoute des raccourcis dans le menu démarrer."
LangString DESC_MENU_SHORTCUTS ${LANG_RUSSIAN} "Äîáàâèòü ÿðëûêè â ãëàâíîå ìåíþ."
LangString DESC_UNINSTALLER ${LANG_ENGLISH} "Create a Windows uninstall program.$\nAdding registry keys in Windows."
LangString DESC_UNINSTALLER ${LANG_FRENCH} "Crée un programme Windows de désinstallation.$\nAjoute des clés de registres dans Windows."
LangString DESC_UNINSTALLER ${LANG_RUSSIAN} "Ñîçäàòü â Windows äåèíñòëëÿòîð ïðîãðàììû.$\nÄîáàâëÿåò êëþ÷è ðååñòðà â Windows."
LangString DESC_PATCH_D2GFX ${LANG_ENGLISH} "D2gfx.dll patcher to run PlugY without PlugY.exe. Before use it, you MUST read the readme."
LangString DESC_PATCH_D2GFX ${LANG_FRENCH} "D2gfx.dll patcheur pour lancer PlugY sans PlugY.exe. Avant de l'utiliser, vous DEVEZ lire le LISEZ-MOI."
LangString DESC_PATCH_D2GFX ${LANG_RUSSIAN} "Ïðèìåíèòü ïàò÷ ê D2gfx.dll äëÿ çàïóñêà PlugY áåç PlugY.exe. Ïîäðîáíåå ñìîòðåòü â ôàéëå Readme."
LangString SECTION_NAME_CORE ${LANG_ENGLISH} "${NAME} (required)"
LangString SECTION_NAME_CORE ${LANG_FRENCH} "${NAME} (nécessaire)"
LangString SECTION_NAME_CORE ${LANG_RUSSIAN} "${NAME} (òðåáóåòñÿ)"
LangString SECTION_NAME_DESKTOP_SHORTCUT ${LANG_ENGLISH} "Desktop Shortcut"
LangString SECTION_NAME_DESKTOP_SHORTCUT ${LANG_FRENCH} "Raccourci sur le bureau"
LangString SECTION_NAME_DESKTOP_SHORTCUT ${LANG_RUSSIAN} "ßðëûê íà ðàáî÷åì ñòîëå"
LangString SECTION_NAME_STARTMENU_SHORTCUTS ${LANG_ENGLISH} "Start menu Shortcuts"
LangString SECTION_NAME_STARTMENU_SHORTCUTS ${LANG_FRENCH} "Raccourcis dans le Menu démarrer"
LangString SECTION_NAME_STARTMENU_SHORTCUTS ${LANG_RUSSIAN} "ßðëûêè â â ãëàâíîì ìåíþ"
LangString SECTION_NAME_UNINSTALLER ${LANG_ENGLISH} "Uninstaller (add keys registers)"
LangString SECTION_NAME_UNINSTALLER ${LANG_FRENCH} "Dé-installeur (ajoute clés de registre)"
LangString SECTION_NAME_UNINSTALLER ${LANG_RUSSIAN} "Äåèíñòàëëÿòîð (äîáàâëÿåò êëþ÷è ðååñòðà)"
LangString SECTION_PATCH_D2GFX ${LANG_ENGLISH} "D2gfx.dll Patcher (advanced user only)"
LangString SECTION_PATCH_D2GFX ${LANG_FRENCH} "Patcheur de D2gfx.dll (utilisateur avancé uniquement)"
LangString SECTION_PATCH_D2GFX ${LANG_RUSSIAN} "Ïàò÷ äëÿ D2gfx.dll Patcher (äëÿ îïûòíûõ ïîëüçîâàòåëåé)"
LangString README_FILENAME ${LANG_ENGLISH} "PlugY_The_Survival_Kit_-_Readme.txt"
LangString README_FILENAME ${LANG_FRENCH} "PlugY_The_Survival_Kit_-_LisezMoi.txt"
LangString README_FILENAME ${LANG_RUSSIAN} "PlugY_The_Survival_Kit_-_Readme.txt"
LangString ERROR_NO_D2_DIRECTORY_FOUND ${LANG_ENGLISH} "Error : Diablo II install directory not found.$\nPlease re-install your copy of Diablo II - Lord of Destruction."
LangString ERROR_NO_D2_DIRECTORY_FOUND ${LANG_FRENCH} "Erreur : Le répertoire d'installation de Diablo II n'a pas été trouvé.$\nVeuillez ré-installer votre copie de Diablo II - Lord of Destruction."
LangString ERROR_NO_D2_DIRECTORY_FOUND ${LANG_RUSSIAN} "Îøèáêà : êàòàëîã ñ óñòàíîâëåííîé èãðîé Diablo II íå íàéäåí.$\nÏîæàëóéñòà ïåðåóñòàíîâèòå âàøó êîïèþ Diablo II - Lord of Destruction."
;!insertmacro MUI_RESERVEFILE_LANGDLL
Var D2Path
;--------------------------------
; Initialisation
Function .onInit
!define MUI_LANGDLL_WINDOWTITLE "${NAME} v${VERSION}"
!define MUI_LANGDLL_INFO "Select your language:$\nChoisissez votre langue:"
!define MUI_LANGDLL_INFO "Select your language:$\nChoisissez votre langue:$\nÂûáåðèòå âàø ÿçûê:"
!insertmacro MUI_LANGDLL_DISPLAY
!undef MUI_LANGDLL_WINDOWTITLE
!undef MUI_LANGDLL_INFO
ReadRegStr $D2Path HKLM "SOFTWARE\Blizzard Entertainment\Diablo II" "InstallPath"
${If} $D2Path == ""
MessageBox MB_OK $(ERROR_NO_D2_DIRECTORY_FOUND)
Abort
ReadRegStr $D2Path HKCU "SOFTWARE\Blizzard Entertainment\Diablo II" "InstallPath"
${If} $D2Path == ""
MessageBox MB_OK $(ERROR_NO_D2_DIRECTORY_FOUND)
Abort
${EndIf}
${EndIf}
${If} $INSTDIR == ""
@ -151,6 +170,7 @@ Section "!$(SECTION_NAME_CORE)" Core
File "${D2FILES}\PlugY_The_Survival_Kit_-_Readme.txt"
File "${D2FILES}\PlugY_The_Survival_Kit_-_LisezMoi.txt"
File "${D2FILES}\PlugY_The_Survival_Kit_-_Liesmich.txt"
;File "${D2FILES}\PlugY_The_Survival_Kit_-_Îïèñàíèå.txt"
CreateDirectory "$D2Path\PlugY"
setOutPath "$D2Path\PlugY"
File "${D2FILES}\PlugY\EmptyPage.dc6"
@ -163,6 +183,8 @@ Section "!$(SECTION_NAME_CORE)" Core
File "${D2FILES}\PlugY\TradeStash.dc6"
File "${D2FILES}\PlugY\UnassignSkillsBtns.dc6"
File "${D2FILES}\PlugY\UnassignStatsBtns.dc6"
File "${D2FILES}\PlugY\PlugYLocal.dll"
File "${D2FILES}\PlugY\PlugYLocal.ini"
SectionEnd
Section "$(SECTION_NAME_DESKTOP_SHORTCUT)" DesktopShortcuts
@ -228,6 +250,7 @@ Section "Uninstall" Uninstall
Delete "$INSTDIR\PlugY_The_Survival_Kit_-_Readme.txt"
Delete "$INSTDIR\PlugY_The_Survival_Kit_-_LisezMoi.txt"
Delete "$INSTDIR\PlugY_The_Survival_Kit_-_Liesmich.txt"
;Delete "$INSTDIR\PlugY_The_Survival_Kit_-_Îïèñàíèå.txt"
Delete "$INSTDIR\PlugY\EmptyPage.dc6"
Delete "$INSTDIR\PlugY\PlugYDefault.ini"
Delete "$INSTDIR\PlugY\PlugYFixed.ini"
@ -238,6 +261,8 @@ Section "Uninstall" Uninstall
Delete "$INSTDIR\PlugY\TradeStash.dc6"
Delete "$INSTDIR\PlugY\UnassignSkillsBtns.dc6"
Delete "$INSTDIR\PlugY\UnassignStatsBtns.dc6"
Delete "$INSTDIR\PlugY\PlugYLocal.dll"
Delete "$INSTDIR\PlugY\PlugYLocal.ini"
RMDir "$INSTDIR\PlugY"
Delete "$INSTDIR\${UNINSTALL_FILE}"
RMDir "$INSTDIR"

1655
PlugYInstaller/PlugY/PlugYLocal.ini Normal file
View File

File diff suppressed because it is too large Load Diff

34
PlugYInstaller/PlugY_The_Survival_Kit_-_Liesmich.txt
View File

@ -3,8 +3,8 @@
; "PlugY, The Survival Kit" ;
; ;
; von Yohann Nicolas ;
; ;
; version 10.00 ;
; (Modifizierung durch L'Autour) ;
; version 11.00 ;
; ;
;--------------------------------------------------------------------------------------;
@ -13,15 +13,13 @@ You can make a donation if you want.
WARNUNG:
- Dieses Plug-In ist NUR für LOD 1.09 zu 1.13c !
- Dieses Plug-In ist NUR für LOD 1.09 zu 1.13d !
- Dieses Plug-In ist NICHT das closed Battle.net!
- Alle Dateien können sich seit der letzten Version verändert haben, benutzt keine alten Dateien!
- Bitte benutzt eine neue D2gfx.dll bevor ihr das PlugY benutzt (Kann man auf http://d2mods.com downloaden)
- PlugY.ini wurde stark verändert, bitte nehmt die Neue!
- Vergesst nicht den Teil: "Kommentare zur Konfigurations-Datei" zu lesen.
- Bitte lest im PlugY-Forum:
http://phrozenkeep.planetdiablo.gamespy.com/forum/viewforum.php?f=133
- Bitte lest im PlugY-Forum: http://d2mods.info/forum/viewforum.php?f=133
******** ALLE FUNKTIONEN ********
- Disable access to Battle.net via main menu button.
@ -42,7 +40,13 @@ WARNUNG:
- Man kann das "SAVE" Verzeichnis ändern.
- Man kann die Versionsanzeige im Hauptbildschirm anpassen.
- Diablo kann nun auf Text-Dateien laden die von Microsoft Excel geöffnet sind.
- Lokalisiert in Englisch, Französisch, Deutsch, Italienisch, Spanisch, Polnisch.
- Lokalisiert in Englisch, Franzosisch, Deutsch, Italienisch, Spanisch, Polnisch, *Portugiesisch, Japanisch, Koreanisch, Chinesisch, Polnisch, *Russisch.
(* - hat informelle Lokalisierung des Spiels verlangt.)
v11.00 Änderungen :
- PlugY funktioniert nun auch mit LoD 1.13d Versionen.
- Voller support fur verschiedene sprachen im spiel.
v10.00 Änderungen :
@ -323,6 +327,8 @@ v1.00 Funktionen (es k
- PlugY.exe
- PlugY.dll (in Diablo II directory)
- PlugY.ini
- Plugy\PlugYLocal.dll
- Plugy\PlugYLocal.ini
- PlugY\PlugYFixed.ini
- PlugY\PlugYDefault.ini
- PlugY\EmptyPage.dc6
@ -342,7 +348,7 @@ v1.00 Funktionen (es k
******** INSTALLATION ********
- The officials sites are :
http://djaftal.chez-alice.fr/
http://phrozenkeep.18v.biz/dload.php?action=category&cat_id=128
http://d2mods.info/forum/viewforum.php?f=133
http://diablo2.judgehype.com/index.php?page=telechargements
Installation :
@ -356,6 +362,8 @@ Du hast LoD in folgendem Verzeichnis installiert : C:\Games\Diablo II\
Der Mod und PlugY befindet sich hier : D:\D2Mod\MyMod\
Dann müssen die Einstellungen wie folgt lauten :
C:\Games\Diablo II\PlugY.dll
C:\Games\Diablo II\PlugY\PlugYLocal.dll
C:\Games\Diablo II\PlugY\PlugYLocal.ini
C:\Games\Diablo II\PlugY\EmptyPage.dc6
C:\Games\Diablo II\PlugY\SharedGoldBtns.dc6
C:\Games\Diablo II\PlugY\StashBtns.dc6
@ -751,6 +759,10 @@ Zur Korrektur der deutschen
* Deutch : ChaosEnergy, TheMasterCaster.
* Italienisch : ItalianPlayer
* Spanish : Acrerune
* Polnisch : Serdel
~~~~~~~~~~~~
* Polnisch : Serdel + https://translate.google.com
* Russisch: L'Autour.
* Portugiesisch: https://translate.google.com
* Japanisch: https://translate.google.com
* Koreanisch: https://translate.google.com
* Chinesisch: https://translate.google.com
~~~~~~~~~~~~.

26
PlugYInstaller/PlugY_The_Survival_Kit_-_LisezMoi.txt
View File

@ -3,8 +3,8 @@
; "PlugY, The Survival Kit" ;
; ;
; par Yohann Nicolas ;
; ;
; version 10.00 ;
; (modification par L'Autour) ;
; version 11.00 ;
; ;
;--------------------------------------------------------------------------------------;
@ -14,7 +14,7 @@ Vous pouvez y faire un don si vous le souhaitez.
******** ATTENTION ********
- Ce plugin fonctionne sur LoD version 1.09 à 1.13c et sur leurs mods.
- Ce plugin fonctionne sur LoD version 1.09 à 1.13d et sur leurs mods.
- Ce plugin ne fonctionne pas sur les royaumes (Battle.net ou privé).
- Tous les fichiers ont changés depuis les versions précédentes, donc déinstaller toutes les versions précédentes.
- S'il vous plait, utilisé le D2gfx.dll non modifié avant de rapporter une erreur.
@ -23,7 +23,7 @@ Vous pouvez y faire un don si vous le souhaitez.
- Les moddeurs devraient lire la version anglaise de ce readme.
- N'oubliez pas de lire les forums :
http://forum.judgehype.com/judgehype/ModsetModding/liste_sujet-1.htm
http://phrozenkeep.planetdiablo.gamespy.com/forum/viewforum.php?f=133 (anglais)
http://d2mods.info/forum/viewforum.php?f=133 (anglais)
******** CARACTERISTIQUES ********
@ -47,6 +47,9 @@ Vous pouvez y faire un don si vous le souhaitez.
- Affiche la valeur courante des caracs (sans les bonus magiques).
- Localisé en français, anglais, allemand, italien, espagnol et polonais.
Changements apportés par la v11.00 :
- PlugY fonctionne aussi la version 1.13c de LOD.
- Plein soutien en faveur d'autres langues dans le jeu.
Changements apportés par la v10.00 :
- Désactive l'accès à Battle.net par le bouton du menu principal.
@ -276,6 +279,8 @@ Changements apport
- PlugY.exe
- PlugY.dll (in Diablo II directory)
- PlugY.ini
- Plugy\PlugYLocal.dll
- Plugy\PlugYLocal.ini
- PlugY\PlugYFixed.ini
- PlugY\PlugYDefault.ini
- PlugY\EmptyPage.dc6
@ -295,7 +300,7 @@ Changements apport
******** INSTALLATION ********
Les sites de téléchargement officiel sont :
http://djaftal.chez-alice.fr/
http://phrozenkeep.18v.biz/dload.php?action=category&cat_id=128
http://d2mods.info/forum/viewforum.php?f=133
http://diablo2.judgehype.com/index.php?page=telechargements
@ -318,6 +323,8 @@ Et que le mod cibl
Et que un second mod se trouve là : D:\D2Mod\MyMod2\
Alors la configuration classique est ceci :
C:\Jeux\Diablo II\PlugY.dll
D:\D2Mod\MyMod\Plugy\PlugYLocal.dll
D:\D2Mod\MyMod\Plugy\PlugYLocal.ini
D:\D2Mod\MyMod\PlugY\SharedGoldBtns.dc6
D:\D2Mod\MyMod\PlugY\PlugYFixed.ini
D:\D2Mod\MyMod\PlugY\PlugYDefault.ini
@ -701,5 +708,10 @@ PS : D
* Allemand : ChaosEnergy, TheMasterCaster.
* Italien : ItalianPlayer
* Espagnol : Acrerune
* Polonais : Serdel
~~~~~~~~~~~~
* Polonais : Serdel + https://translate.google.com
* Russian: Around.
* Portuguese: https://translate.google.com
* Japanese: https://translate.google.com
* Korean: https://translate.google.com
* Chinese: https://translate.google.com
~~~~~~~~~~~~

39
PlugYInstaller/PlugY_The_Survival_Kit_-_Readme.txt
View File

@ -3,25 +3,23 @@
; "PlugY, The Survival Kit" ;
; ;
; by Yohann Nicolas ;
; ;
; version 10.00 ;
; (modification by L'Autour) ;
; version 11.00 ;
; ;
;--------------------------------------------------------------------------------------;
Official website : http://plugy.free.fr
Official website for version 10.00: http://plugy.free.fr
You can make a donation if you want.
******** WARNING ********
- This plug-in works with LoD version 1.09 to 1.13c and mods based on.
- This plug-in works with LoD version 1.09 to 1.13d and mods based on.
- This plug-in doesn't work on realms (Battle.net or private).
- All files may be changed since previous version, so uninstall any previous version.
- Please, use a clean D2dfx.dll before report any crash on starting LoD.
- PlugY.ini has changed since previous version, use the one in this package.
- Don't forget to read the part named "COMMENTS ON THE CONFIGURATION FILE".
- Don't forget to read the PlugY forum at :
http://phrozenkeep.planetdiablo.gamespy.com/forum/viewforum.php?f=133
- Don't forget to read the PlugY forum at : http://d2mods.info/forum/viewforum.php?f=133
******** FEATURES ********
- Disable access to Battle.net.
@ -42,7 +40,13 @@ You can make a donation if you want.
- Always display Mana and Life values above the globes.
- D2 can load all files, even those opened with Microsoft Excel (disabled by default).
- Display the stats current value (without magical bonus) like Magic/gold find or maximum resistances.
- PlugY is localized in English, French, German, Italian, Spanish, Polish.
- PlugY is localized in English, French, German, Italian, Spanish, Polish, *Portuguese, Japanese, Korean, Chinese, Polish, *Russian.
(* - required informal localization of the game.)
v11.00 changes :
- PlugY works for 1.13d version of LoD too.
- A complete support of all languages in game.
v10.00 changes :
@ -329,13 +333,15 @@ v1.00 features (can all be easily enabled or disabled) :
******** CONTENTS ********
19 files, 1 folder :
21 files, 1 folder :
- PlugY_The_Survival_Kit_-_Readme.txt
- PlugY_The_Survival_Kit_-_LisezMoi.txt
- PlugY_The_Survival_Kit_-_Liesmich.txt
- PlugY.exe
- PlugY.dll (in Diablo II directory)
- PlugY.ini
- Plugy\PlugYLocal.dll
- Plugy\PlugYLocal.ini
- PlugY\PlugYFixed.ini
- PlugY\PlugYDefault.ini
- PlugY\EmptyPage.dc6
@ -355,7 +361,7 @@ v1.00 features (can all be easily enabled or disabled) :
******** INSTALLATION ********
- The officials sites are :
http://djaftal.chez-alice.fr/
http://phrozenkeep.18v.biz/dload.php?action=category&cat_id=128
http://d2mods.info/forum/viewforum.php?f=133
http://diablo2.judgehype.com/index.php?page=telechargements
@ -377,6 +383,8 @@ And the mod to add this plug-in is here : D:\D2Mod\MyMod\
And the second mod to add this plug-in is here : D:\D2Mod\MyMod2\
So the new installation is :
C:\Games\Diablo II\PlugY.dll
D:\D2Mod\MyMod\Plugy\PlugYLocal.dll
D:\D2Mod\MyMod\Plugy\PlugYLocal.ini
D:\D2Mod\MyMod\PlugY\SharedGoldBtns.dc6
D:\D2Mod\MyMod\PlugY\PlugYFixed.ini
D:\D2Mod\MyMod\PlugY\PlugYDefault.ini
@ -781,9 +789,14 @@ PS : Sorry for english faults ;)
- PhrozenKeep team for all stuff they shared for us (including mine ;)
- Translation :
* English : Yohann, Jurica.
* French : Yohann
* French : Yohann.
* German : ChaosEnergy, TheMasterCaster.
* Italian : ItalianPlayer
* Italian : ItalianPlayer
* Spanish : Acrerune
* Polish : Serdel
* Polish : Serdel + https://translate.google.com
* Russian: L'Autour.
* Portuguese: https://translate.google.com
* Japanese: https://translate.google.com
* Korean: https://translate.google.com
* Chinese: https://translate.google.com
~~~~~~~~~~~~

36
PlugYLocal/PlugYLocal.cfg Normal file
View File

@ -0,0 +1,36 @@
-$A8
-$B-
-$C+
-$D+
-$E-
-$F-
-$G+
-$H+
-$I+
-$J-
-$K-
-$L+
-$M-
-$N+
-$O+
-$P+
-$Q-
-$R-
-$S-
-$T-
-$U-
-$V+
-$W-
-$X+
-$YD
-$Z1
-cg
-AWinTypes=Windows;WinProcs=Windows;DbiTypes=BDE;DbiProcs=BDE;DbiErrs=BDE;
-H+
-W+
-M
-$M16384,1048576
-K$00400000
-LE"c:\program files\borland\delphi7\Projects\Bpl"
-LN"c:\program files\borland\delphi7\Projects\Bpl"
-DKOL_MCK

143
PlugYLocal/PlugYLocal.dof Normal file
View File

@ -0,0 +1,143 @@
[FileVersion]
Version=7.0
[Compiler]
A=8
B=0
C=1
D=1
E=0
F=0
G=1
H=1
I=1
J=0
K=0
L=1
M=0
N=1
O=1
P=1
Q=0
R=0
S=0
T=0
U=0
V=1
W=0
X=1
Y=1
Z=1
ShowHints=1
ShowWarnings=1
UnitAliases=WinTypes=Windows;WinProcs=Windows;DbiTypes=BDE;DbiProcs=BDE;DbiErrs=BDE;
NamespacePrefix=
SymbolDeprecated=1
SymbolLibrary=1
SymbolPlatform=1
UnitLibrary=1
UnitPlatform=1
UnitDeprecated=1
HResultCompat=1
HidingMember=1
HiddenVirtual=1
Garbage=1
BoundsError=1
ZeroNilCompat=1
StringConstTruncated=1
ForLoopVarVarPar=1
TypedConstVarPar=1
AsgToTypedConst=1
CaseLabelRange=1
ForVariable=1
ConstructingAbstract=1
ComparisonFalse=1
ComparisonTrue=1
ComparingSignedUnsigned=1
CombiningSignedUnsigned=1
UnsupportedConstruct=1
FileOpen=1
FileOpenUnitSrc=1
BadGlobalSymbol=1
DuplicateConstructorDestructor=1
InvalidDirective=1
PackageNoLink=1
PackageThreadVar=1
ImplicitImport=1
HPPEMITIgnored=1
NoRetVal=1
UseBeforeDef=1
ForLoopVarUndef=1
UnitNameMismatch=1
NoCFGFileFound=1
MessageDirective=1
ImplicitVariants=1
UnicodeToLocale=1
LocaleToUnicode=1
ImagebaseMultiple=1
SuspiciousTypecast=1
PrivatePropAccessor=1
UnsafeType=1
UnsafeCode=1
UnsafeCast=1
[Linker]
MapFile=0
OutputObjs=0
ConsoleApp=1
DebugInfo=0
RemoteSymbols=0
MinStackSize=16384
MaxStackSize=1048576
ImageBase=4194304
ExeDescription=
[Directories]
OutputDir=
UnitOutputDir=
PackageDLLOutputDir=
PackageDCPOutputDir=
SearchPath=
Packages=vcl;rtl;vclx;vclactnband
Conditionals=KOL_MCK
DebugSourceDirs=D:\Games\Diablo II\PlugY
UsePackages=0
[Parameters]
RunParams=
HostApplication=D:\Games\Diablo II\Game.exe
Launcher=
UseLauncher=0
DebugCWD=D:\Games\Diablo II
[Version Info]
IncludeVerInfo=1
AutoIncBuild=0
MajorVer=1
MinorVer=0
Release=0
Build=0
Debug=0
PreRelease=0
Special=0
Private=0
DLL=0
Locale=1033
CodePage=1252
[Version Info Keys]
CompanyName=
FileDescription=
FileVersion=1.0.0.0
InternalName=
LegalCopyright=
LegalTrademarks=
OriginalFilename=PlugYLocal.dll
ProductName=PlugyLocal for PlugY
ProductVersion=11.0.0.0
[HistoryLists\hlDebugSourcePath]
Count=1
Item0=D:\Games\Diablo II\PlugY
[HistoryLists\hlConditionals]
Count=1
Item0=KOL_MCK
[HistoryLists\hlUnitAliases]
Count=1
Item0=WinTypes=Windows;WinProcs=Windows;DbiTypes=BDE;DbiProcs=BDE;DbiErrs=BDE;
[HistoryLists\hlOutputDirectorry]
Count=1
Item0=D:\Games\Diablo II\PlugY

823
PlugYLocal/PlugYLocal.dpr Normal file
View File

@ -0,0 +1,823 @@
library PlugYLocal;
//Created by L'Autour
{ Important note about DLL memory management: ShareMem must be the
first unit in your library's USES clause AND your project's (select
Project-View Source) USES clause if your DLL exports any procedures or
functions that pass strings as parameters or function results. This
applies to all strings passed to and from your DLL--even those that
are nested in records and classes. ShareMem is the interface unit to
the BORLNDMM.DLL shared memory manager, which must be deployed along
with your DLL. To avoid using BORLNDMM.DLL, pass string information
using PChar or ShortString parameters. }
uses
KOL;
//SysUtils,
//Classes;
{$R *.res}
type
TLocalStr = record
name: AnsiString;
value: WideString;
end;
TStrType = record
k: AnsiString;
s: WideString;
case Byte of
0: (dw: Cardinal);
1: (c: array[0..3] of AnsiChar);
end;
const
NamePlugyLocal = 'Plugy\PlugYLocal.ini';
MaxStr = 52;
MaxLng = 11;
MaxType = 97;
MaxIdxType = 41;
sLng: array[0..MaxLng] of AnsiString =
('ENG','ESP','DEU','FRA','POR','ITA','JPN','KOR','SIN','CHI','POL','RUS');
var
Gender: WideString = '';
StrTypes: array[0..MaxType + 1] of TStrType = (
(k: ''; s: 'Shield (Not Class Specific)'; c: ('s','h','i','e')),
(k: ''; s: 'Body Armor'; c: ('t','o','r','s')),
(k: 'Gold'; s: 'Gold'; c: ('g','o','l','d')),
(k: 'aqv'; s: 'Arrows'; c: ('b','o','w','q')),
(k: 'cqv'; s: 'Bolts'; c: ('x','b','o','q')),
(k: 'ear'; s: 'Ear'; c: ('p','l','a','y')),
(k: 'hrb'; s: 'Herb'; c: ('h','e','r','b')),
(k: ''; s: 'Potion'; c: ('p','o','t','i')),
(k: 'rin'; s: 'Ring'; c: ('r','i','n','g')),
(k: 'elx'; s: 'Elixir'; c: ('e','l','i','x')),
(k: 'amu'; s: 'Amulet'; c: ('a','m','u','l')),
(k: ''; s: 'Charm'; c: ('c','h','a','r')),
(k: 'lbt'; s: 'Boots'; c: ('b','o','o','t')),
(k: ''; s: 'Gloves'; c: ('g','l','o','v')),
(k: ''; s: 'Book'; c: ('b','o','o','k')),
(k: 'mbl'; s: 'Belt'; c: ('b','e','l','t')),
(k: ''; s: 'Gem'; c: ('g','e','m',' ')),
(k: 'tch'; s: 'Torch'; c: ('t','o','r','c')),
(k: ''; s: 'Scroll'; c: ('s','c','r','o')),
(k: 'scp'; s: 'Scepter'; c: ('s','c','e','p')),
(k: 'wnd'; s: 'Wand'; c: ('w','a','n','d')),
(k: ''; s: 'Staff'; c: ('s','t','a','f')),
(k: ''; s: 'Bow'; c: ('b','o','w',' ')),
(k: 'axe'; s: 'Axe'; c: ('a','x','e',' ')),
(k: 'clb'; s: 'Club'; c: ('c','l','u','b')),
(k: ''; s: 'Sword'; c: ('s','w','o','r')),
(k: ''; s: 'Hammer'; c: ('h','a','m','m')),
(k: ''; s: 'Knife'; c: ('k','n','i','f')),
(k: 'spr'; s: 'Spear'; c: ('s','p','e','a')),
(k: ''; s: 'Polearm'; c: ('p','o','l','e')),
(k: 'mxb'; s: 'Crossbow'; c: ('x','b','o','w')),
(k: 'mac'; s: 'Mace'; c: ('m','a','c','e')),
(k: 'hlm'; s: 'Helm'; c: ('h','e','l','m')),
(k: ''; s: 'Missile Potion'; c: ('t','p','o','t')),
(k: ''; s: 'Quest Item'; c: ('q','u','e','s')),
(k: ''; s: 'Body Part'; c: ('b','o','d','y')),
(k: 'key'; s: 'Key'; c: ('k','e','y',' ')),
(k: 'tkf'; s: 'Throwing Knife'; c: ('t','k','n','i')),
(k: 'tax'; s: 'Throwing Axe'; c: ('t','a','x','e')),
(k: 'jav'; s: 'Javelin'; c: ('j','a','v','e')),
(k: ''; s: 'Weapon'; c: ('w','e','a','p')),
(k: ''; s: 'Melee Weapon'; c: ('m','e','l','e')),
(k: ''; s: 'Missile Weapon'; c: ('m','i','s','s')),
(k: ''; s: 'Throwing Weapon'; c: ('t','h','r','o')),
(k: ''; s: 'Combo Weapon'; c: ('c','o','m','b')),
(k: ''; s: 'Armor'; c: ('a','r','m','o')),
(k: ''; s: 'Any Shield'; c: ('s','h','l','d')),
(k: ''; s: 'Miscellaneous'; c: ('m','i','s','c')),
(k: ''; s: 'Socket Filler'; c: ('s','o','c','k')),
(k: ''; s: 'Second Hand Item'; c: ('s','e','c','o')),
(k: ''; s: 'Staves And Rods'; c: ('r','o','d',' ')),
(k: ''; s: 'Missile'; c: ('m','i','s','l')),
(k: ''; s: 'Blunt'; c: ('b','l','u','n')),
(k: 'jew'; s: 'Jewel'; c: ('j','e','w','l')),
(k: ''; s: 'Class Specific'; c: ('c','l','a','s')),
(k: ''; s: 'Amazon Item'; c: ('a','m','a','z')),
(k: ''; s: 'Barbarian Item'; c: ('b','a','r','b')),
(k: ''; s: 'Necromancer Item'; c: ('n','e','c','r')),
(k: ''; s: 'Paladin Item'; c: ('p','a','l','a')),
(k: ''; s: 'Sorceress Item'; c: ('s','o','r','c')),
(k: ''; s: 'Assassin Item'; c: ('a','s','s','n')),
(k: ''; s: 'Druid Item'; c: ('d','r','u','i')),
(k: ''; s: 'Claw'; c: ('h','2','h',' ')),
(k: ''; s: 'Assassin Claw'; c: ('h','2','h','2')),
(k: ''; s: 'Orb'; c: ('o','r','b',' ')),
(k: ''; s: 'Voodoo Heads'; c: ('h','e','a','d')),
(k: ''; s: 'Paladin Shield'; c: ('a','s','h','d')),
(k: ''; s: 'Barbarian Helm'; c: ('p','h','l','m')),
(k: ''; s: 'Druid Helm'; c: ('p','e','l','t')),
(k: 'cloak'; s: 'Cloak'; c: ('c','l','o','a')),
(k: ''; s: 'Rune'; c: ('r','u','n','e')),
(k: 'circlet'; s: 'Circlet'; c: ('c','i','r','c')),
(k: 'hp3'; s: 'Healing Potion'; c: ('h','p','o','t')),
(k: 'mp3'; s: 'Mana Potion'; c: ('m','p','o','t')),
(k: 'rvs'; s: 'Rejuvenation potion'; c: ('r','p','o','t')),
(k: 'vps'; s: 'Stamina Potion'; c: ('s','p','o','t')),
(k: 'yps'; s: 'Antidote Potion'; c: ('a','p','o','t')),
(k: 'wms'; s: 'Thawing Potion'; c: ('w','p','o','t')),
(k: 'cm1'; s: 'Small Charm'; c: ('s','c','h','a')),
(k: 'cm2'; s: 'Large Charm'; c: ('m','c','h','a')),
(k: 'cm3'; s: 'Grand Charm'; c: ('l','c','h','a')),
(k: ''; s: 'Amazon Bow'; c: ('a','b','o','w')),
(k: ''; s: 'Amazon Spear'; c: ('a','s','p','e')),
(k: ''; s: 'Amazon Javelin'; c: ('a','j','a','v')),
(k: ''; s: 'Magic Arrows'; c: ('m','b','o','q')),
(k: ''; s: 'Magic Bolts'; c: ('m','x','b','q')),
(k: ''; s: 'Chipped Gem'; c: ('g','e','m','0')),
(k: ''; s: 'Flawed Gem'; c: ('g','e','m','1')),
(k: ''; s: 'Normal Gem'; c: ('g','e','m','2')),
(k: ''; s: 'Flawless Gem'; c: ('g','e','m','3')),
(k: ''; s: 'Perfect Gem'; c: ('g','e','m','4')),
(k: 'gsv'; s: 'Amethyst'; c: ('g','e','m','a')),
(k: 'gsw'; s: 'Diamond'; c: ('g','e','m','d')),
(k: 'gsg'; s: 'Emerald'; c: ('g','e','m','e')),
(k: 'gsr'; s: 'Ruby'; c: ('g','e','m','r')),
(k: 'gsb'; s: 'Sapphire'; c: ('g','e','m','s')),
(k: 'gsy'; s: 'Topaz'; c: ('g','e','m','t')),
(k: 'sku'; s: 'Skull'; c: ('g','e','m','z')),
(k: ''; s: '???'; dw: 0));
LocalStrings: array[0..MaxStr + 1] of TLocalStr = (
(name: 'STR_STATS_UNASSIGN_WITH_LIMIT'; value: '+Alt: Unassign, +Shift: by %d points'),
(name: 'STR_STATS_UNASSIGN_WITHOUT_LIMIT'; value: '+Alt: Unassign, +Shift: all remaining points'),
(name: 'STR_STATS_BASE_MIN'; value: 'Base: %d (Min: %d)'),
(name: 'STR_SKILLS_UNASSIGN'; value: 'Un-allocate all skills points'),
(name: 'STR_STASH_PREVIOUS_PAGE'; value: 'Previous Page (+shift: First Page)'),
(name: 'STR_STASH_NEXT_PAGE'; value: 'Next Page (+shift: Last not empty Page'),
(name: 'STR_TOGGLE_TO_PERSONAL'; value: 'Toggle to Personal Stash'),
(name: 'STR_TOGGLE_TO_SHARED'; value: 'Toggle to Shared Stash'),
(name: 'STR_STASH_PREVIOUS_INDEX'; value: 'Previous Index : by %d Pages (+Shift: %d)'),
(name: 'STR_STASH_NEXT_INDEX'; value: 'Next Index : by %d Pages (+shift: %d)'),
(name: 'STR_PERSONAL_PAGE_NUMBER'; value: 'Personal Page n°%u'),
(name: 'STR_SHARED_PAGE_NUMBER'; value: 'Shared Page n°%u'),
(name: 'STR_NO_SELECTED_PAGE'; value: 'No selected page'),
(name: 'STR_PUT_GOLD'; value: 'Put Gold'),
(name: 'STR_TAKE_GOLD'; value: 'Take Gold'),
(name: 'STR_SHARED_GOLD_QUANTITY'; value: 'Shared Gold : %u'),
(name: 'STR_PREVIOUS_PAGE'; value: 'Previous Page'),
(name: 'STR_NEXT_PAGE'; value: 'Next Page'),
(name: 'STR_ITEM_LEVEL'; value: 'Item Level: %u'),
(name: 'STR_COW_PORTAL'; value: 'Cow Portal'),
(name: 'STR_PANDEMONIUM_PORTAL'; value: 'Pandemonium Portal'),
(name: 'STR_PANDEMONIUM_FINAL_PORTAL'; value: 'Pandemonium Final Portal'),
(name: 'STR_FULL'; value: 'Fully '),
(name: 'STR_REPAIR'; value: 'Repair '),
(name: 'STR_AND'; value: 'and '),
(name: 'STR_RECHARGE'; value: 'Recharge '),
(name: 'STR_DESTROY_FILLERS'; value: 'Destroys Fillers '),
(name: 'STR_REMOVE_FILLERS'; value: 'Remove Fillers '),
(name: 'STR_REGENERATE'; value: 'Regenerate '),
(name: 'STR_WITH_N_SOCKETS'; value: ' with %u Sockets'),
(name: 'STR_ETHERAL'; value: 'Ethereal '),
(name: 'STR_NOT_ETHERAL'; value: 'Not Ethereal '),
(name: 'STR_NOT_RUNEWORD'; value: 'Not Runeword '),
(name: 'STR_BASIC'; value: 'Basic '),
(name: 'STR_EXCEPTIONAL'; value: 'Exceptional '),
(name: 'STR_ELITE'; value: 'Elite '),
(name: 'STR_CRACKED'; value: 'Cracked '),
(name: 'STR_NORMAL'; value: 'Normal '),
(name: 'STR_SUPERIOR'; value: 'Superior '),
(name: 'STR_MAGIC'; value: 'Magic '),
(name: 'STR_SET'; value: 'Set '),
(name: 'STR_RARE'; value: 'Rare '),
(name: 'STR_UNIQUE'; value: 'Unique '),
(name: 'STR_CRAFTED'; value: 'Crafted '),
(name: 'STR_TEMPERED'; value: 'Tempered '),
(name: 'STR_ITEM'; value: 'Item'),
(name: 'STR_ITEM_SAME_TYPE'; value: 'Item of the same type'),
(name: 'STR_OR_UPGRADED'; value: ' (or upgraded)'),
(name: 'STR_WITHOUT_SOCKET'; value: ' without Sockets'),
(name: 'STR_WITH_SOCKET'; value: ' with Sockets'),
(name: 'STR_ONLY_N_H'; value: ' (Nightmare and Hell only)'),
(name: 'STR_ONLY_HELL'; value: ' (Hell only)'),
(name: 'STR_ONLY_CLASS'; value: ' (%s only)'),
(name: ''; value: '<unknown string>')
);
IniName: AnsiString;
//MS C++__fastcall(ecx,edx) vs Delphi register(eax,edx,ecx) - :(
function InitTranslatedString(_EAX: Integer;_EDX: Integer; iLng: Integer): Boolean; register;
var
IniFile: PIniFile;
CurLng: AnsiString;
S: UTF8String;
i: Integer;
begin
Result := False;
if not FileExists(IniName) then Exit;
if (iLng < 0)or(iLng > MaxLng) then iLng := 0;
CurLng := sLng[iLng];
IniFile := OpenIniFile(IniName);
IniFile.Mode := ifmRead;
for i := 0 to MaxStr do
begin
IniFile.Section := LocalStrings[i].name;
S := IniFile.ValueString(CurLng, '');
if S <> '' then LocalStrings[i].value := UTF8Decode(S);
end;
for i := 0 to MaxType do
begin
IniFile.Section := StrTypes[i].c;
S := IniFile.ValueString(CurLng, '');
if S <> '' then
begin
StrTypes[i].s := UTF8Decode(S);
StrTypes[i].k := '';
end;
end;
Result := True;
end;
//MS C++__fastcall(ecx,edx) vs Delphi register(eax,edx,ecx) - :(
function GetTranslatedString(_EAX: Integer;_EDX: Integer; Idx: Integer): PWideChar; register;
begin
if (Idx < 0)or(Idx > MaxStr) then Idx := MaxStr + 1;
Result := @LocalStrings[Idx].Value[1];
end;
//MS C++__fastcall(ecx,edx) vs Delphi register(eax,edx,ecx) - :(
function GetTypeString(_EAX: Integer;out IdxStr: PAnsiChar; Code: Cardinal): PWideChar; register;
var
i: Integer;
begin
i := 0;
while i <= MaxType do
begin
if Code = StrTypes[i].dw then Break;
Inc(i);
end;
if StrTypes[i].k = '' then
IdxStr := nil
else
IdxStr := PAnsiChar(StrTypes[i].k);
Result := PWideChar(StrTypes[i].s);
end;
function WSprintStringLastGender(buf: PWideChar; lenbuf: Integer; Idx: Integer): Integer; stdcall;
var
i, p, L: Integer;
S: WideString;
begin
S := GetTranslatedString(0,0,Idx);
if Gender <> '' then
begin
p := Pos(Gender, S);
if p <> 0 then
begin
L := Length(S);
p := p + Length(Gender);
for i := p to L do
if S[i] = '[' then Break;
S := Copy(S, p, i - p);
end;
end;
Result := Min(lenbuf - 1, Length(S));
for i := 1 to Result do
buf[i-1] := S[i];
buf[Result + 1] := #$0000;
end;
//MS C++__fastcall(ecx,edx) vs Delphi register(eax,edx,ecx) - :(
function SetMonoString(_EAX: Integer;_EDX: Integer; InStr: PWideChar): PWideChar; register;
var
StrList: PWStrList;
i: Integer;
S: WideString;
begin
Result := InStr;
if Result = nil then Exit;
StrList := NewWStrList;
StrList.Text := InStr;
i := Strlist.Count - 1;
if i = 0 then Exit;
S := StrList.Items[i];
while i > 0 do
begin
Dec(i);
S := S + '. ' + StrList.Items[i];
end;
Move(S[1], InStr[0], Length(S) shl 1);
end;
//MS C++__fastcall(ecx,edx) vs Delphi register(eax,edx,ecx) - :(
function CutStringGender(_EAX: Integer;_EDX: Integer; InStr: PWideChar): PWideChar; register;
var
i, j: Integer;
begin
Result := InStr;
Gender := '';
if (InStr = nil)or(InStr[0] <> '[') then Exit;
i := 1;
while (InStr[i] <> #$0000) do
begin
if InStr[i] = ']' then
begin
if (i < 2)or(InStr[i+1] = #$0000) then Exit;
SetLength(Gender, i + 1);
for j := 0 to i do
Gender[j+1] := InStr[j];
Result := @InStr[i+1];
Exit;
end;
Inc(i);
end;
end;
{
const
NcColor = 14;
LenCode = 9;
type
TTextColor = array[0..LenCode - 1] of AnsiChar;
const
cColor: array[0..NcColor - 1] of TTextColor = (
('\','w','h','i','t','e',';',#00,#00),
('\','g','r','e','y',';',#00,#00,#00),
('\','r','e','d',';',#00,#00,#00,#00),
('\','g','r','e','e','n',';',#00,#00),
('\','b','l','u','e',';',#00,#00,#00),
('\','g','o','l','d',';',#00,#00,#00),
('\','d','g','r','e','y',';',#00,#00),
('\','b','l','a','c','k',';',#00,#00),
('\','t','a','n',';',#00,#00,#00,#00),
('\','o','r','a','n','g','e',';',#00),
('\','y','e','l','l','o','w',';',#00),
('\','d','g','r','e','e','n',';',#00),
('\','p','u','r','p','l','e',';',#00),
('\','c','o','l','o','r',';',#00,#00));
//lengths of strings in cColor table, without '\'
cColLength: array[0..NcColor-1] of Byte = (6,5,4,6,5,5,6,6,4,7,7,7,7,6);
pColor: PAnsiChar = @cColor[NcColor-1][1];
var
SaveToTbl: Byte = 0;
//ANSI convert ColorApi to ColorCode
//optional UCS2 convert '\n' to $0A
function ColorApi2ColorCode(Src: PAnsiChar; Dst: PAnsiChar;
SourceChars: Integer): Integer;
//EAX: Src
//EDX: Dst
//ECX: Length Src
//Result: OutLength -> EAX
asm
//backup
PUSHF
CLD //èíêðåìåíò äëÿ ñòðîêîâûõ êîìàíä
PUSH ESI
PUSH EDI
PUSH EBX
PUSH EBP
PUSH EDX //ñîõðàíÿåì íà÷àëüíûé àäðåñ ïðèåìíèêà
MOV EDI, Dst
TEST Src, Src //ïðîâåðêà íà ïóñòóþ ñòðîêó
JZ @Exit
MOV ESI, Src
// â ECX õðàíèòñÿ êîëè÷åñòâî îñòàâøèõñÿ ñèìâîëîâ èç Src
@NextChar:
//çàãðóçêà î÷åðåäíîãî ñèìâîëà â EAX
XOR EAX, EAX
LODSB //MOV AL, [ESI]+
//ïðîâåðêà íà íóëåâîé ñèìâîë (êîíåö ñòðîêè)
TEST AL, AL
JZ @Exit
//ïðîâåðêà íà ñèìâîë '\'
CMP AL, '\'
JE @Slash
@CopyChar:
//normal chars
STOSB //MOV [EDI]+, AL
//óìåíüøåíèå ñ÷åò÷èêà íåîáðàáîòàííûõ áàéòîâ è ïåðåä â íà÷àëî öèêëà
@Loop:
LOOP @NextChar
@Exit:
MOV BYTE PTR [EDI], $00 //íóëåâîé ñèìâîë â êîíöå âûõîäíîé ñòðîêè
POP EAX //âîññòàíàâëèâàåì íà÷àëüíûé àäðåñ ïðèåìíèêà
XCHG EAX, EDI
//get length of Dst
SUB EAX, EDI
//restore
POP EBP
POP EBX
POP EDI
POP ESI
POPF
RET
@Slash:
//ïðîâåðêà íà íàëè÷èå ñëåäóþùåãî ñèìâîëà
CMP ECX, 1
JB @CopyChar // if ECX < 1
//çàãðóçêà ñëåäóþùåãî ñèìâîëà
LODSB //MOV AL, [ESI]+
//ïðîâåðêà ñèìâîëà íà êîä ïåðåâîäà ñòðîêè
CMP AL, 'n'
JNZ @TestColor
//ïîïðàâêà ECX
DEC ECX
//test Save2Tbl
CMP SaveToTbl, 0
JNZ @UnixReturn
//save '\n'
MOV AL, '\'
STOSB //MOV [EDI]+, AL
MOV AL, 'n'
JMP @CopyChar
@UnixReturn:
//save UnixNewLine
MOV AL, $0A
JMP @CopyChar
//ïðîâåðêà íà ñòðîêè óñòàíîâêè öâåòà øðèôòà:
@TestColor:
//ïðîâåðêà íà èñïîëüçîâàíèå ìàêðî îïðåäåëåíèé öâåòà øðèôòà
//CMP MacroColorView, $00
//JE @StoreSlash
//backup
PUSH ECX
PUSH EDI
//âîññòàíîâëåíèå ESI
DEC ESI
//ñîõðàíåíèå èñòî÷íêà
MOV EBX, ESI
//çàãðóçêà êîëè÷åñòâà ñðàâíèâàåìûõ ñòðîê
MOV EAX, NcColor
//çàãðóçêà àäðåñà ïîñëåäíåé ñòðîêè èç ìàññèâà ñòðîê
//óñòàíîâêè öâåòà øðèôòà (áåç '')
MOV EBP, pColor
//çàãðóçêà àäðåñà ìàññèâà äëèí ñòðîê áåç '\' è
//(-1, ò.ê. áóäåò ïðèáàâëÿòñÿ EAX)
LEA EDX, [cColLength - 1]
@CmpStr:
//çàãðóçêà àäðåñà ñòðîêè ïðèåìíèêà
MOV EDI, EBP
//çàãðóçêà ñ÷åò÷èêà ñèìâîëîâ ñòðîêè
MOVZX ECX, BYTE PTR [EDX + EAX]
//ñðàâíåíèå ñòðîê
//(ïðåðûâàíèå, åñëè íå ðàâíû, ò.å. äëèíó Src ìîæíî íå ïðîâåðÿòü)
REPE CMPSB
//ïðîâåðêà ðåçóëüòàòà ñðàâíåíèÿ ñòðîê
JZ @ColorCode
//âîññòàíîâëåíèå àäðåñà ñòðîêè èñòî÷íèêà
MOV ESI, EBX
//ñäâèã àäðåñà ñòðîêè ïðèåìíèêà íà ñëåäóþùóþ ñòðîêó
SUB EBP, LenCode
//äåêðåìåíò ñ÷åò÷èêà ñòðîê
DEC EAX
//ïðîâåðêà íà ïîâòîð öèêëà ñðàâíåíèÿ ñòðîê
JA @CmpStr //if EAX > 0
//ñèìâîë '\' áûë ïðîñòî ñèìâîëîì
//restore
POP EDI
POP ECX
@StoreSlash:
//çàïèñü êîäà ñèìâîëà '\'
MOV AL, '\'
JMP @CopyChar
//çàïèñü êîäà ñìåíû èçâåñòíîãî öâåòà øðèôòà
//â AL íîìåð ñòðîêè èç cColor
@ColorCode:
//restore
POP EDI
//äîáàâêà êîäà öâåòà ê ColorCode
MOVZX EDX, BYTE PTR [EDX + EAX]//çàãðóçêà ñ÷åò÷èêà ñèìâîëîâ ñòðîêè
ADD AL, $2E //1..14 + $2E = $2F..$3C
//backup EAX
MOV ECX, EAX
//save ColorCode
MOV AX, $63FF
STOSW //MOVD [EDI]+, AX
//restore EAX
MOV EAX, ECX
//test \color;
CMP AL, $3C
JE @FullColorCode
//add number to ColorCode
STOSB //MOVD [EDI]+, AL
@FullColorCode:
//restore ECX
POP ECX
SUB ECX, EDX //êîððåêöèÿ ECX íà äëèíó ñòðîêè
JZ @Exit //êîíåö ñòðîêè èñòî÷íèêà
//ESI ïîñëå ñðàâíåíèÿ óæå óêàçûâàåò íà ñëåäóþùèé ñèìâîë
JMP @NextChar //ECX >= 1
end;
//MS C++__fastcall(ecx,edx) vs Delphi register(eax,edx,ecx) - :(
procedure ReplaceColorCode(_EAX: Integer;_EDX: Integer; Str: PAnsiChar); register;
var
i, L, n: Integer;
begin
L := Length(Str);
n := ColorApi2ColorCode(Str, Str, L);
Dec(L);
for i := n to L do
begin
//Str[i] := ' ';
end;
//MsgOK(Str);
end;
}
//Decode string from UCS2 to UTF8
//WideCharToMultiByte not support CP_UTF8 in Windows 95
function UCS2ToUTF8(Dest: PAnsiChar; MaxDestBytes: Integer;
Source: PWideChar; SourceChars: Integer): Integer;
//EAX: @Dest
//EDX: MaxDestBytes
//ECX: @Source
//(ESP): SourceChars;
//Result: DestChars of @Dest -> EAX
asm
//backup
PUSHF
CLD //set (ESI)+
PUSH EBX
PUSH ESI
PUSH EDI
PUSH Dest //backup @Dst
MOV EDI, Dest
TEST Source, Source //test NULL string
JZ @Exit
MOV ESI, Source
MOV ECX, SourceChars
@NextChar:
//test length of Dst
DEC EDX
JLE @Exit
//get next char to EAX
XOR EAX, EAX
LODSW //MOV AX, [ESI]+
//test NULL char (end of string)
TEST EAX, EAX
JZ @Exit
//decode UCS2 to UTF8
@Ucs2ToUtf8:
//test UCS2-char in $0000..$007F
CMP AX, $007F
JA @11xxxxxx //if AX > $7F
//UTF8-char: 0xxxxxxx
//AH = 00000000; AL = 0xxxxxxx
@0xxxxxxx:
//save UTF8-char
STOSB //MOVB [EDI]+, AL
//end Loop
@Loop:
LOOP @NextChar
JMP @Exit
@11xxxxxx:
//test length of Dst
DEC EDX
JLE @Exit
//test UCS2-char in $0080..$07FF
CMP AX, $07FF
JA @1110xxxx //if AX > $07FF
//UTF8-char: 110xxxxx 10xxxxxx
//AH = 00000xxx; AL = xxxxxxxx
//get first byte UTF8-char to AL
ROR AX, 6 //AH = xxxxxx00; AL = 000xxxxx
//get second byte UTF8-char to AH
SHR AH, 2 //AH = 00xxxxxx
OR AX, $80C0 //AH = 10xxxxxx; AL = 110xxxxx
//save UTF8-char
STOSW //MOVW [EDI]+, AX
JMP @Loop
//UTF8-char: 1110xxxx 10xxxxxx 10xxxxxx
@1110xxxx:
//test length of Dst
DEC EDX
JLE @Exit
//save lobyte of UCS2-char
MOV BL, AL
//AH = xxxxxxxx; AL = xxxxxxxx
//get first byte UTF8-char UTF8 to AL
ROL AX, 4 //AL = ????xxxx; AH = xxxxxx??
AND AL, $0F //AL = 0000xxxx
//get second byte UTF8-char to AH
SHR AH, 2 //AH = 00xxxxxx
OR AX, $80E0 //AH = 10xxxxxx; AL = 1110xxxx
//save first bytes UTF8-char
STOSW //MOVW [EDI]+, AX
//get second byte UTF8-char to AL
XCHG EAX, EBX //??xxxxxx
AND AL, $3F //00xxxxxx
OR AL, $80 //10xxxxxx
//save third byte UTF8-char
JMP @0xxxxxxx
@Exit:
MOV BYTE PTR [EDI], $00 //set end-char of Dst
POP EAX //restore @Dst
XCHG EAX, EDI
//get length of Dst to Result
SUB EAX, EDI
//restore
POP EDI
POP ESI
POP EBX
POPF
end;
function _UCS2ToUTF8(Dest: PAnsiChar; MaxDestBytes: Integer;
Source: PWideChar; SourceChars: Integer): Integer; stdcall;
begin
Result := UCS2ToUTF8(Dest, MaxDestBytes, Source, SourceChars);
end;
//Decode string from UTF8 to UCS2
function UTF8ToUCS2(Dest: PWideChar; MaxDestBytes: Integer;
Source: PAnsiChar; SourceChars: Integer): Integer;
//EAX: @Dest
//EDX: MaxDestBytes
//ECX: @Source
//(ESP): SourceChars;
//Result: DestChars of @Dest -> EAX
//if errors then
//Result: -(DestChars of @Dest) -> EAX
asm
//backup
PUSHF
CLD //set (ESI)+
PUSH EBX
PUSH ESI
PUSH EDI
PUSH Dest //backup @Dst
MOV EDI, Dest
TEST Source, Source //test NULL string
JZ @Exit
MOV ESI, Source
MOV ECX, SourceChars
@NextChar:
//test length of Dst
SUB EDX, 2
JLE @Exit
//get next char to EAX
XOR EAX, EAX
LODSB //MOV AL, [ESI]+
//test NULL char (end of string)
TEST AL, AL
JZ @Exit
//decode UTF8 to UCS2
@Utf8ToUcs2:
//test first byte UTF8 = 0xxxxxxx
TEST AL, $80
JNZ @1xxxxxxx
//UTF8: 0xxxxxxx (AH = 0)
@SaveU16:
STOSW //MOVW [EDI]+, EAX
@Loop:
LOOP @NextChar
JMP @Exit
@1xxxxxxx:
//test first byte UTF8 = 10xxxxxx
TEST AL, $40 //01000000
JZ @Exit //Error UTF8: 10xxxxxx
//test first byte UTF8 = 1111xxxx
CMP AL, $F0 //11110000
JAE @Exit //Error UTF8 to UCS2: 1111xxxx ( if AL >= $F0)
//test exist second byte UTF8
JECXZ @Exit // DEC ECX; if ECX = 0
//backup first byte UTF8
MOV AH, AL //11xxxxxx
//load second byte UTF8
LODSB //MOV AL, [ESI]+
//test second byte UTF8 = 10xxxxxx
TEST AL, $40 //01000000
JNE @Exit //Error UTF8: 10xxxxxx
//test second byte UTF8 = 110xxxxx
TEST AH, $20 //00100000
JNZ @1110xxxx //third byte UTF8
//UTF8: 110xxxxx 10xxxxxx
//backup first byte UTF8
MOV BL, AH //110xxxxx
//get high byte UCS2
SHR AH, 2 //00110xxx
AND AX, $073F //AH: 00000xxx; AL: 00xxxxxx
//get low byte USC2
SHL BL, 6 //xx000000
OR AL, BL //xxxxxxxx
//AX: 00000xxx:xxxxxxxx
JMP @SaveU16
@1110xxxx:
//test exist third byte UTF8
JeCXZ @Exit // DEC ECX; if ECX = 0
//backup second byte UTF8
MOV BL, AL //10xxxxxx
//load third byte UTF8
LODSB //MOV AL, [ESI]+
//test third byte UTF8 = 10xxxxxx
CMP AL, $C0 //11000000
JAE @Exit //Error UTF8: 11xxxxxx ( if AL >= $C0)
//UTF8: 1110xxxx 10xxxxxx 10xxxxxx
//get bytes UCS2 íà: xx00000:0000xxxx
AND BX, $003F //DX := 00000000:00xxxxxx
ROR BX, 2 //BL := 0000xxxx; BH := xx000000
//get low byte UTF8
AND AL, $3F //00xxxxxx
OR AL, BH //xxxxxxxx
//get high byte UCS2
SHL AH, 4 //xxxx0000
OR AH, BL //xxxxxxxx
JMP @SaveU16
@Exit:
XOR EAX, EAX
MOV [EDI],AX //set end-char of Dst
POP EAX //restore @Dst
XCHG EAX, EDI
//get length of Dst to Result
SUB EAX, EDI
SHR EAX, 1
//restore
POP EDI
POP ESI
POP EBX
POPF
end ; //asm
function _UTF8ToUCS2(Dest: PWideChar; MaxDestBytes: Integer;
Source: PAnsiChar; SourceChars: Integer): Integer; stdcall;
begin
Result := UTF8ToUCS2(Dest, MaxDestBytes, Source, SourceChars);
end;
exports
_UCS2ToUTF8 name '__stdcall UCS2toUTF8',
_UTF8ToUCS2 name '__stdcall UTF8toUCS2',
//ReplaceColorCode name 'replaceColorCode',
SetMonoString name '__fastcall setMonoString',
WSprintStringLastGender name '__stdcall wSprintStringLastGender',
CutStringGender name '__fastcall cutStringGender',
GetTypeString name '__fastcall getTypeString',
GetTranslatedString name '__fastcall getTranslatedString',
InitTranslatedString name '__fastcall initTranslatedString';
var
i, j: Integer;
S: UTF8String;
b: Boolean;
begin
IniName := GetStartDir + NamePlugyLocal;
if FileExists(IniName) then Exit;
S := #$EF#$BB#$BF';UTF8';
for i := 0 to MaxStr do
begin
S := S + #$0D#$0A'[' + LocalStrings[i].name + ']'#$0D#$0A + sLng[0] + '="'
+ LocalStrings[i].value + '"'#$0D#$0A;
for j := 1 to MaxLng do
S := S + sLng[j] + '='#$0D#$0A;
end;
for i := 0 to MaxType do
begin
S := S + #$0D#$0A;
b := (StrTypes[i].k <> '');
if b then
S := S + ';';
S := S + '[' + StrTypes[i].c + ']'#$0D#$0A;
if b then
S := S + ';';
S := S + sLng[0] + '="' + StrTypes[i].s + '"'#$0D#$0A;
if not b then
begin
for j := 1 to MaxLng do
S := S + sLng[j] + '='#$0D#$0A;
end;
end;
StrSaveToFile(IniName, S);
end.

1655
PlugYLocal/PlugYLocal.ini Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
PlugYLocal/PlugYLocal.res Normal file
View File

Binary file not shown.

BIN
PlugYRun/PlugYRun.aps
View File

Binary file not shown.

103
PlugYRun/PlugYRun.cpp
View File

@ -1,9 +1,11 @@
/*
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
*/
#include <windows.h>
#include <stdio.h>
#include <Psapi.h>
#include "../Commons/VersionInfo.h"
//#using <mscorlib.dll>
//#using <System.dll>
//using namespace EnvDTE;
@ -32,13 +34,14 @@ $+40 >CD AB BA DC 00 00 00 00 ͫ
*/
#define SUBKEY "Software\\Blizzard Entertainment\\Diablo II"
#define GAMEFILE "\\Game.exe "
#define GAMEFILE "\\Game.exe"
#define INIFILE "\\PlugY.ini"
#define LAUNCHING "LAUNCHING"
#define LOD_VERSION "LodVersionFolder"
#define PARAM "Param"
#define LIBRARY_NAME "Library"
BYTE loadDll[]={
0xFF,0x74,0x24,0x04, //PUSH DWORD PTR SS:[ESP+4]
0xFF,0x15,0x40,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.LoadLibraryA>] ; kernel32.LoadLibraryA
@ -101,6 +104,7 @@ BYTE freeDll[]={
//LPCSTR dllName = "PlugY.dll";
LPCSTR initFctName = "_Init@4";
LPCSTR releaseFctName = "_Release@0";
static bool versionXP;
typedef int (__stdcall* tDebugActiveProcessStop)(DWORD);
@ -113,24 +117,27 @@ void assertion(LPCSTR msg)
exit(1);
}
bool installPlugY(HANDLE h, DWORD addr, char* libraryName, int isAdd)
bool installPlugY(HANDLE h, DWORD addr, char* libraryName, int isAdd, int ver)
{
BYTE buf[200];
DWORD pos=0;
SIZE_T nb=0;
DWORD version;
SIZE_T nb2=0;
//DWORD version;
int res;
// Get Version and needed addresses.
res = ReadProcessMemory(h,(LPVOID)(addr+0x110),&version,4,&nb);//0x80
if (!res || (nb!=4)) assertion("Read to get current d2gfx version in memory failed");
// Get Version and needed addresses.
/* res = ReadProcessMemory(h,(LPVOID)(addr+0x110),&version,4,&nb);//0x80
if (!res || (nb!=4)) assertion("Read to get current d2gfx version in memory failed");
*/
DWORD loadCallerAddr = addr;
DWORD freeCallerAddr = addr;
DWORD loadLibraryAddr = addr;
DWORD freeLibraryAddr = addr;
DWORD getProcAddressAddr = addr;
// GET_VERSION(D2gfx, 110, 000054EB, 00001000, 0000C000, 42E6C22A, 43028B19);//110
/*
switch (version)
{
case 0x000054EB://1.09b 0x00949FA8:
@ -169,7 +176,7 @@ bool installPlugY(HANDLE h, DWORD addr, char* libraryName, int isAdd)
freeLibraryAddr += 0xD12C;
getProcAddressAddr += 0xD120;
break;
case 0x00000000://1.13c
case 0x00000000://1.13
loadCallerAddr += 0xB423;
freeCallerAddr += 0xB3CA;
loadLibraryAddr += 0xD11C;
@ -178,8 +185,67 @@ bool installPlugY(HANDLE h, DWORD addr, char* libraryName, int isAdd)
break;
default:
assertion("Wrong version of the library D2gfx.dll");
}*/
switch (ver)
{
case v109b:
case v109d:
loadCallerAddr += 0x389B;
freeCallerAddr += 0x3A8C;
loadLibraryAddr += 0xC03C;
freeLibraryAddr += 0xC044;
getProcAddressAddr += 0xC038;
break;
case v110:
loadCallerAddr += 0x3870;
freeCallerAddr += 0x3A6D;
loadLibraryAddr += 0xC040;
freeLibraryAddr += 0xC048;
getProcAddressAddr += 0xC03C;
break;
case v111:
loadCallerAddr += 0x8B23;
freeCallerAddr += 0x8ACA;
loadLibraryAddr += 0xD11C;
freeLibraryAddr += 0xD12C;
getProcAddressAddr += 0xD120;
break;
case v111b:
loadCallerAddr += 0xB423;
freeCallerAddr += 0xB3CA;
loadLibraryAddr += 0xD11C;
freeLibraryAddr += 0xD12C;
getProcAddressAddr += 0xD120;
break;
case v112:
loadCallerAddr += 0x8F63;
freeCallerAddr += 0x8F0A;
loadLibraryAddr += 0xD11C;
freeLibraryAddr += 0xD12C;
getProcAddressAddr += 0xD120;
break;
case v113c:
loadCallerAddr += 0xB423;
freeCallerAddr += 0xB3CA;
loadLibraryAddr += 0xD11C;
freeLibraryAddr += 0xD12C;
getProcAddressAddr += 0xD120;
break;
case v113d:
loadCallerAddr += 0xAA03;
freeCallerAddr += 0xA9AA;
loadLibraryAddr += 0xD11C;
freeLibraryAddr += 0xD124;
getProcAddressAddr += 0xD120;
break;
default:
return false;//assertion("Wrong version of the Game.exe");
}
//const char sD2Ver[8][7] = {{"v1.09b"},{"v1.09d"},{"v1.10 "},{"v1.11 "},{"v1.11b"},{"v1.12 "},{"v1.13c"},{"v1.13d"}};
//assertion(sD2Ver[version]);
//Verify if memory are ok.
bool alreadyInstalled = false;
res = ReadProcessMemory(h,(LPVOID)loadCallerAddr,buf,6,&nb);
@ -360,7 +426,7 @@ bool launchNormal(char* command, char* currentDirectory)
return success?true:false;
}
bool launchGame98(char* command, char* currentDirectory, char* libraryName)
bool launchGame98(char* command, char* currentDirectory, char* libraryName, int ver)
{
// MessageBox(0, "LAUNCH 98", "PlugYRun", MB_OK|MB_ICONASTERISK);
STARTUPINFO si;
@ -383,14 +449,14 @@ bool launchGame98(char* command, char* currentDirectory, char* libraryName)
if (isD2gfx(pi.hProcess,(LPVOID)0x6FA80000))
{
// MessageBox(0, "INSTALL 98", "PlugYRun", MB_OK|MB_ICONASTERISK);
installPlugY(pi.hProcess, 0x6FA80000, libraryName, 1);
installPlugY(pi.hProcess, 0x6FA80000, libraryName, 1, ver);
ResumeThread(pi.hThread);
return true;
}
if (isD2gfx(pi.hProcess,(LPVOID)0x6FA70000))
{
// MessageBox(0, "INSTALL 98", "PlugYRun", MB_OK|MB_ICONASTERISK);
installPlugY(pi.hProcess, 0x6FA70000, libraryName, 0);
installPlugY(pi.hProcess, 0x6FA70000, libraryName, 0, ver);
ResumeThread(pi.hThread);
return true;
}
@ -401,7 +467,7 @@ bool launchGame98(char* command, char* currentDirectory, char* libraryName)
}
bool launchGameXP(char* command, char* currentDirectory, char* libraryName)
bool launchGameXP(char* command, char* currentDirectory, char* libraryName, int ver)
{
// MessageBox(0, "LAUNCH XP", "PlugYRun", MB_OK|MB_ICONASTERISK);
STARTUPINFO si;
@ -442,7 +508,7 @@ bool launchGameXP(char* command, char* currentDirectory, char* libraryName)
if(isD2gfx(pi.hProcess, DebugEvent.u.LoadDll.lpBaseOfDll))
{
// MessageBox(0, "INSTALL XP", "PlugYRun", MB_OK|MB_ICONASTERISK);
installPlugY(pi.hProcess, (DWORD)DebugEvent.u.LoadDll.lpBaseOfDll, libraryName, (DWORD)DebugEvent.u.LoadDll.lpBaseOfDll == 0x6FA8000);
installPlugY(pi.hProcess, (DWORD)DebugEvent.u.LoadDll.lpBaseOfDll, libraryName, (DWORD)DebugEvent.u.LoadDll.lpBaseOfDll == 0x6FA8000, ver);
CloseHandle(DebugEvent.u.LoadDll.hFile);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
@ -465,6 +531,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
char currrentDirectory[MAX_PATH];
char iniFileName[MAX_PATH];
char command[MAX_PATH+50];
int ver;
// MessageBox(NULL,"START","PlugYRun",MB_OK);
//Get Current Directory.
@ -489,6 +556,10 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
if (!getWinReg(command, MAX_PATH+50))
return 1;
ver = GetD2Version(command);
if (ver == -1) assertion("Wrong version of the Game.exe");
strcat(command, " ");
//Add params.
strcat(command,lpCmdLine);
len = strlen(command);
@ -496,7 +567,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
//copyLodVersionFiles();
char libraryName[50];
char libraryName[50];
if (!GetPrivateProfileString(LAUNCHING,LIBRARY_NAME,"",libraryName,50,iniFileName) || !libraryName[0])
return !launchNormal(command, currrentDirectory);
@ -506,9 +577,9 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
{
debugActiveProcessStop = (tDebugActiveProcessStop) GetProcAddress(module,"DebugActiveProcessStop");
if (debugActiveProcessStop)
return !launchGameXP(command, currrentDirectory, libraryName);
return !launchGameXP(command, currrentDirectory, libraryName, ver);
}
return !launchGame98(command, currrentDirectory, libraryName);
return !launchGame98(command, currrentDirectory, libraryName, ver);
}

9
PlugYRun/PlugYRun.rc
View File

@ -65,8 +65,8 @@ LANGUAGE LANG_FRENCH, SUBLANG_FRENCH
//
VS_VERSION_INFO VERSIONINFO
FILEVERSION 1,0,3,0
PRODUCTVERSION 1,0,3,0
FILEVERSION 1,0,5,0
PRODUCTVERSION 1,0,5,0
FILEFLAGSMASK 0x17L
#ifdef _DEBUG
FILEFLAGS 0x1L
@ -81,11 +81,12 @@ BEGIN
BEGIN
BLOCK "040c04b0"
BEGIN
VALUE "Comments", "Modified by L'Autour"
VALUE "CompanyName", "Yohann NICOLAS"
VALUE "FileVersion", "1.03"
VALUE "FileVersion", "1.05"
VALUE "OriginalFilename", "PlugY.exe"
VALUE "ProductName", "PlugY launcher."
VALUE "ProductVersion", "1.03"
VALUE "ProductVersion", "1.05"
END
END
BLOCK "VarFileInfo"

BIN
PlugYRun/PlugYRun.suo
View File

Binary file not shown.

18
PlugYRun/PlugYRun.vcproj
View File

@ -174,7 +174,7 @@
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="copy $(TargetPath) &quot;..\PlugYInstaller\PlugY.exe&quot;"
CommandLine="copy $(TargetPath) &quot;..\PlugYInstaller\PlugY.exe&quot;&#x0D;&#x0A;copy $(TargetPath) &quot;D:\Games\Diablo II\Mod PlugY\PlugY.exe&quot;&#x0D;&#x0A;&#x0D;&#x0A;"
/>
</Configuration>
</Configurations>
@ -189,6 +189,14 @@
RelativePath="PlugYRun.cpp"
>
</File>
<Filter
Name="Commons"
>
<File
RelativePath="..\Commons\VersionInfo.cpp"
>
</File>
</Filter>
</Filter>
<Filter
Name="Header Files"
@ -198,6 +206,14 @@
RelativePath="resource.h"
>
</File>
<Filter
Name="Commons"
>
<File
RelativePath="..\Commons\VersionInfo.h"
>
</File>
</Filter>
</Filter>
<Filter
Name="Resource Files"