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.01 by Yohann

Browse Source
This commit is contained in:
ChaosMarc 2017-01-23 20:34:12 +01:00
parent 1f35a1a5a8
commit 3f60030fbb
140 changed files with 4042 additions and 8138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

221
Commons/D2Funcs.h
View File

@ -148,59 +148,59 @@
//F7(STD, D2Common,00000,00000,00000,00000,10001,00000,00000, DWORD, D2GetActIDFromLevel, (DWORD levelID));
//F7(STD, D2Common,00000,00000,00000,00000,10001,00000,00000,00000, DWORD, D2GetActIDFromLevel, (DWORD levelID));
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,10149,10149,10149,00000,00000,00000,00000,00000, Inventory*, D2GetInventory, (Unit* ptUnit));
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,10257,10257,10257,00000,00000,00000,00000,00000, Unit*, D2GetItemFromBodyLoc, (Inventory* ptInventory, DWORD bodyloc));
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,10321,10321,10321,00000,00000,00000,00000,00000, SkillData*, D2GetLeftSkill, (Unit* ptChar));
//F7(STD, D2Common,10322,10322,10322,00000,00000,00000,00000,00000, SkillData*, D2GetRightSkill, (Unit* ptChar));
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,10328,10328,10328,00000,00000,00000,00000,00000, void, D2SetPosX, (Unit* ptUnit, DWORD pos));
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,10331,10331,10331,00000,00000,00000,00000,00000, void, D2SetPosY, (Unit* ptUnit, DWORD pos));
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,10348,10348,10348,00000,00000,00000,00000,00000, void, D2SetUnitMode, (Unit* ptUnit, DWORD mode));
//F7(STD, D2Common,10394,10394,10394,00000,00000,00000,00000,00000, ObjectsBIN*,D2GetObjectsBIN, (Unit* ptObject));
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,10421,10421,10421,10914,10329,00000,00000,00000, DWORD, D2FreePlayerData, (DWORD game1C, Unit* ptChar));
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,10463,10463,10463,00000,00000,00000,00000,00000, DWORD, D2SetStatWithNoTest, ( Stats* ptStats, DWORD statID, DWORD statValue, DWORD statIndex));
//F7(STD, D2Common,10464,10464,10464,00000,00000,00000,00000,00000, void, D2AddStat, (Stats* ptStats, DWORD statID, DWORD statValue, DWORD statIndex));
//F7(STD, D2Common,10465,10465,10465,00000,00000,00000,00000,00000, DWORD, D2SetStat, (Stats* ptStats, DWORD statID, DWORD statValue, DWORD statIndex));
//F7(STD, D2Common,10466,10466,10466,00000,00000,00000,00000,00000, int, D2GetStat, (Stats* ptStats, DWORD statID, DWORD statIndex));
//F7(STD, D2Common,10470,10470,10470,00000,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,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,10471,10471,10471,00000,00000,00000,00000,00000, DWORD, D2Common10471, (void*));
//F7(STD, D2Common,10472,10472,10472,00000,00000,00000,00000,00000, DWORD, D2Common10472, (void*));
//F7(STD, D2Common,10475,10475,10475,00000,00000,00000,00000,00000, void, D2UpdateDisabledStat, (Stats* ptCharStats, Stats* ptStats, DWORD one));
//F7(STD, D2Common,10481,10481,10481,00000,00000,00000,00000,00000, void*, D2Common10481, (Unit* ptUnit, DWORD flags));
//F7(STD, D2Common,10484,10484,10484,00000,00000,00000,00000,00000, Stats*, D2GetAffixStats, (Unit* ptItem, DWORD, DWORD));
//F7(STD, D2Common,10485,10485,10485,00000,00000,00000,00000,00000, void, D2FreeStats, (Stats* ptStats));
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,10517,10517,10517,00000,00000,00000,00000,00000, void, D2SetPlayerStat, (Unit* ptChar, DWORD statID, int amount, DWORD index));
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,10520,10520,10520,00000,00000,00000,00000,00000, int, D2GetPlayerStat20, (Unit* ptChar, DWORD statID, DWORD index));
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,10527,10527,10527,00000,00000,00000,00000,00000, DWORD, D2Common10527, (Unit* ptUnit));
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));
@ -211,78 +211,78 @@ F7(STD, D2Common,10547,10547,10547,00000,00000,00000,00000,00000, DWORD, D2hav
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));
//F7(STD, D2Common,10574,10574,10574,00000,00000,00000,00000, void*, D2SetEnabledStat, (Unit* ptItem, DWORD statId, DWORD disabled));
//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,10552,10552,10552,00000,00000,00000,00000,00000, DWORD, D2Common10552, (Unit* ptUnit));
//F7(STD, D2Common,10567,10567,10567,00000,00000,00000,00000,00000, DWORD, D2CanBeBroken, (Unit* ptItem));
//F7(STD, D2Common,10573,10573,10573,00000,00000,00000,00000,00000, void, D2CopyStats, (Stats* ptDestStats, Stats* ptSrcStats));
//F7(STD, D2Common,10574,10574,10574,00000,00000,00000,00000,00000, void*, D2SetEnabledStat, (Unit* ptItem, DWORD statId, DWORD disabled));
//F7(STD, D2Common,10575,10575,10575,00000,00000,00000,00000,00000, void, D2FreeBinFiles, ());
//F7(STD, D2Common,10576,10576,10576,00000,00000,00000,00000,00000, void, D2LoadBinFiles, (DWORD zero1, DWORD zero2, bool));
//F7(STD, D2Common,00000,00000,00000,10651,10651,00000,00000,00000, DWORD, D2CheckQuestState, (void* ptQuest, DWORD index, DWORD value));
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,10601,10601,10601,00000,00000,00000,00000,00000, ItemsBIN*, D2GetByCodeItemStatsBIN, (DWORD code, DWORD* itemID));
//F7(STD, D2Common,10604,10604,10604,00000,00000,00000,00000,00000, AffixBIN*, D2GetAffixBIN, (int affixID));
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,10737,10737,10737,00000,00000,00000,00000,00000, LevelsBIN*, D2GetLevelsBIN, (DWORD levelID));
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,10659,10659,10659,00000,00000,00000,00000,00000, TreasureClassBIN*, D2GetTreasureClassBIN, (WORD id, DWORD uk));
//F7(STD, D2Common,10668,10668,10668,10450,10953,00000,00000,00000, SuperUniqueBIN*, D2GetSuperUniqueBIN, (WORD id));
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,10708,10708,10708,00000,00000,00000,00000,00000, void, D2SetFlags, (Unit* ptUnit, DWORD flags, DWORD bitNewValue));
//F7(STD, D2Common,10709,10709,10709,00000,00000,00000,00000,00000, DWORD, D2GetFlags, (Unit* ptUnit));
//F7(STD, D2Common,10711,10711,10711,00000,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,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,10749,10749,10749,00000,00000,00000,00000,00000, void, D2GetWidthHeight, (Unit* ptItem, BYTE* Width, BYTE* Height);
//F7(STD, D2Common,10751,10751,10751,00000,00000,00000,00000,00000, DWORD, D2GetItemType, (Unit* ptUnit));
//F7(STD, D2Common,10757,10757,10757,00000,00000,00000,00000,00000, DWORD, D2GetItemLevelReq, (Unit* ptChar, Unit* ptItem));
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));
//F7(STD, D2Common,10816,10816,10816,10816,11085,00000,00000, DWORD, D2GetNbSocket, (Unit* ptItem));
//F7(STD, D2Common,10840,10840,10840,00000,00000,00000,00000, DWORD, D2Common10840, (Unit* ptItem, Unit* ptChar));
//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,10792,10792,10792,00000,00000,00000,00000,00000, DWORD, D2CanBeRare, (Unit* ptItem));
//F7(STD, D2Common,10810,10810,10810,00000,00000,00000,00000,00000, BYTE, D2CheckHasInv, (Unit* ptItem));
//F7(STD, D2Common,10813,10813,10813,00000,00000,00000,00000,00000, DWORD, D2GetStaffMods, (Unit* ptItem));
//F7(STD, D2Common,10816,10816,10816,10816,11085,00000,00000,00000, DWORD, D2GetNbSocket, (Unit* ptItem));
//F7(STD, D2Common,10840,10840,10840,00000,00000,00000,00000,00000, DWORD, D2Common10840, (Unit* ptItem, Unit* ptChar));
//F7(STD, D2Common,10855,10855,10855,00000,00000,00000,00000,00000, void, D2AddAffix, (DWORD, DWORD, Unit* ptItem, AffixBIN* ptAffix, DWORD, DWORD));
//F7(STD, D2Common,10872,10872,10872,00000,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,00000, WORD, D2GetItemVersion, (Unit* ptItem));
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,10916,10916,10916,00000,00000,00000,00000,00000, void, DoNothing916, ());
//F7(STD, D2Common,10940,10940,10940,10027,10105,10953,00000,00000, void, D2Common10027, (Unit* ptChar, DWORD skillID));
//F7(STD, D2Common,10950,10950,10950,00000,00000,00000,00000,00000, SkillData*, D2GetSkillPointer, (Unit* ptChar, WORD SkillID));
//F7(STD, D2Common,10952,10952,10952,10950,10256,10858,00000,00000, SkillData*, D2IncSkillBaseLevel, (Unit* ptChar, DWORD skillID));
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,10963,10963,10963,00000,00000,00000,00000,00000, DWORD, D2GetSkillID, (SkillData* ptSkill, const char* file, DWORD line));
//F7(FAST, D2Common,10966,10966,10966,00000,00000,00000,00000,00000, SkillsBIN*, D2GetSkillsBIN, (SkillData* ptSkill));
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,11023,11023,11023,00000,00000,00000,00000,00000, DWORD, D2GetCriticalStrikeFromMasteries, (Unit* ptChar, Unit* ptItem, DWORD zero, DWORD two));
//F7(STD, D2Common,11007,11007,11007,00000,00000,00000,00000,00000, bool, D2TestQuestState, (void* ptQuest, DWORD QuestID, DWORD QuestState));
//F7(STD, D2Common,11041,11041,11041,00000,00000,00000,00000,00000, int, D2GetPlayerSkillID, (DWORD playerID, DWORD skillNumber));
//F7(STD, D2Common,11042,11042,11042,00000,00000,00000,00000,00000, int, D2GetNbSkillsPerPlayer, (DWORD playerID));
//F7(STD, D2Common,11269,11269,11269,00000,00000,00000,00000,00000, DWORD, D2GetAllIndexFromStat, (Stats* ptStats, DWORD statID, D2Stat* allIndex, DWORD maxIndex));
//F7(STD, D2Common,11270,11270,11270,00000,00000,00000,00000,00000, DWORD, D2GetAllIndexFromStatID, (Unit* ptItem, DWORD statID, D2Stat* allIndex, DWORD));
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,62FD0,00000,00000,00000,00000,00000, void, D2EncodeValueCheckMax, (saveBitField* data, DWORD value, DWORD bitSize));
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,00000,00000,764A0,00000,00000,00000,00000,00000, void*, D2Common764A0, (Stats* ptStats, DWORD stat, ItemStatCostBIN* itemStatCost ,DWORD));
//A7(STD, D2Common,00000,00000,76E30,00000,00000,00000,00000,00000, void, D2PreUpdateDisabledStat, (Stats* ptStats));
//A7(FAST, D2Common,00000,00000,76C10,00000,00000,00000,00000,00000, void, D2ApplyStat,(Stats* ptCharStats, DWORD statId, DWORD value, Unit* ptItem));
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(FAST, D2Common,00000,00000, 94D0,00000,00000,00000,00000,00000, void*, D2GetStringIDForTxtFile,(const char * string));
A7(STD, D2Common,1F500,1F510,29FA0,71EB0,32AA0,7D2A0,59870,80C40, void, D2LoadSuperuniques,(DWORD mempool));//FASCALL UNTIL 1.10
@ -311,22 +311,22 @@ A7(STD, D2Common,1F500,1F510,29FA0,71EB0,32AA0,7D2A0,59870,80C40, void, D2Loa
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,00000, int, D2GetAvgChanceMonsterWillHitYou, ());//6FAB5A80
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,00000,00000,45990,00000,00000,00000,00000,00000, Unit*, D245990, (Inventory*,DWORD idItem);//6FAE5990
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,00000,00000,869F0,00000,00000,00000,00000,00000, Unit*, D2ClientGetObject, (DWORD itemNum, DWORD type));//6FB269F0
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,B9970,B8CF0,BB0F0,00000,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,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
//A7(FAST, D2Client,00000,00000,00000,00000,1FEB0,5CDD0,00000,00000, void, D2OpenNPCMenu, (Unit* ptNPC));//by ESI
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -371,31 +371,31 @@ A7(FAST, D2Client,00000,00000,00000,8E480,5BA90,1CC00,4ABE0,7DC60, void, D2Relo
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,01DE0,00000,00000,00000,00000,00000, void*, D2GetClientByClientID, (Game* ptGame, DWORD clientID));//6FC31DE0
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(FAST, D2Game,00000,00000,0E6F0,00000,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,00000, DWORD, D2UpdateInventory, (Game* ptGame, Unit* ptChar, void* ptNetClient, Inventory* pInventory));//6FC40FB0
//A7(FAST, D2Game,00000,00000,110E0,00000,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,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,1ED80,00000,00000,00000,00000,00000, Unit*, D2CreateItem, (Game* ptGame, ItemGenerationData* itemGenerationData, DWORD));//6FC4ED80
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,22410,00000,00000,00000,00000,00000, void, D2AddStaffModAffixes, (Unit* ptItem, ItemGenerationData* itemParam));//6FC52410
//A7(FAST, D2Game,00000,00000,22C00,00000,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,00000, WORD, D2GetRareAffixName, (Unit* ptItem, DWORD wantPrefix));//6FC53610
//A7(FAST, D2Game,00000,00000,3AD10,00000,00000,00000,00000,00000, DWORD, D2GetSuperUniqueMonsterID, (Game* ptGame, Unit* ptMonster));//6FC6AD10
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,00000,00000,4C7B0,00000,00000,00000,00000,00000, Unit*, D2GetSkillItem, (Unit* ptChar));//6FC7C7B0
//A7(FAST, D2Game,00000,00000,5A500,00000,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,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,9F320,501C0,F1C50,F1A50,F3220,00000, Unit*, D2GetOwnerMonster, (Unit* ptMonster));
//A7(FAST, D2Game,00000,00000,E08D0,00000,00000,00000,00000,00000, void, D2UpdateSkillDataAfterUnassignment, (Game* ptGame, Unit* ptChar, DWORD skillID));//6FD108D0
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));
@ -405,7 +405,7 @@ A7(FAST, D2Game,00000,00000,00000,EAB20,2BC80,B3B90,B8610,C8850, void, D2BaalIA
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(FAST, D2Game,00000,00000,00000,00000,92420,00000,00000,00000, void, D2ReloadGambleScreenGame, (Unit* ptNPC, Game* ptGame, Unit* ptChar, DWORD, DWORD one));
A7(STD, D2Game,00000,00000, 89C0,E2390,E66D0,A8090,2C830,BE660, void, D2SaveGame, (Game* ptGame) );
@ -452,12 +452,12 @@ F7(FAST, Fog, 10104,10104,10104,10104,10104,10104,10104,10104, DWORD, D2MPQRead
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, 10126,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,10127, DWORD, D2GetBitFieldSize, (saveBitField* data));//6FF536C0
//F7(STD, Fog, 10128,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,10130, DWORD, D2DecodeValue, (saveBitField* data,DWORD readingSize));//6FF53840
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, 10217,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,10265, int, D2GetInstructionPointer, ());
//Fog10213 getIndexFromLookupTable (&table,code,bool)
@ -477,18 +477,19 @@ F7(STD, Fog, 00000,00000,00000,10265,10265,10265,10265,10265, int, D2GetInstru
////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,10002,10004,10010,10011,10011, LPWSTR, D2GetStringFromString, (const char* ptString));//6FC13BC0
//F7(FAST, D2Lang, 10003,10003,10003,00000,00000,00000,00000,10011, LPWSTR, D2GetStringFromString, (const char* ptString));//6FC13BC0
F7(FAST, D2Lang, 10003,10003,10003,10002,10004,10010,10011,10011, LPWSTR, D2GetStringFromString, (const char* ptString));//6FC13BC0 LAutour
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, 10006,10006,10006,00000,00000,00000,00000,00000, void, D2GetStringLang, (LPSTR ptLang, DWORD Zero));//6FC13FB0
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
//A7(FAST, D2Lang, 00000,00000,03A90,00000,00000,00000,00000, WORD, D2GetStrAndIndexFromString, (void* ptFile, void* ptMemLoc, LPSTR String, LPWSTR RetString));//6FC13A90
//A7(FAST, D2Lang, 00000,00000,02CD0,00000,00000,00000,00000, DWORD, D2unicodenwidth, (char* ptChar, DWORD size));//6FC12CD0_unicodenwidth
//A7(STD, D2Lang, 00000,00000,01670,00000,00000,00000,00000, DWORD, D2swprintf, (DWORD bufSize, LPWSTR buf, LPWSTR string, ...));//6FC11670_sprintf
//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,00000, DWORD, D2UnicodeWidth, (DWORD MemLoc, WORD Size));//6FC129B0
//A7(FAST, D2Lang, 00000,00000,02E60,00000,00000,00000,00000,00000, LPWSTR, D2GetStrFromIndex , (void* ptFile, void* ptMemLoc, DWORD dwIndexNum));//6FC12E60
//A7(FAST, D2Lang, 00000,00000,03640,00000,00000,00000,00000,00000, TblHeader*, D2LoadTblFile, (LPCSTR lpszFileName));//6FC13640
//A7(FAST, D2Lang, 00000,00000,03A90,00000,00000,00000,00000,00000, WORD, D2GetStrAndIndexFromString, (void* ptFile, void* ptMemLoc, LPSTR String, LPWSTR RetString));//6FC13A90
//A7(FAST, D2Lang, 00000,00000,02CD0,00000,00000,00000,00000,00000, DWORD, D2unicodenwidth, (char* ptChar, DWORD size));//6FC12CD0_unicodenwidth
//A7(STD, D2Lang, 00000,00000,01670,00000,00000,00000,00000,00000, DWORD, D2swprintf, (DWORD bufSize, LPWSTR buf, LPWSTR string, ...));//6FC11670_sprintf
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Storm : 6FFB0000
@ -497,7 +498,7 @@ F7(STD, D2Lang, 10013,10013,10013,00000,00000,00000,00000,10005, DWORD, D2GetS
//D2S(Storm,503, void, D2Storm503, (DWORD, DWORD, DWORD)); //+1.11
//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, 253, 253, 253, 253, 253, 253, 000, 000, void, D2StormMPQCloseFile, (void* mpqfile));
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));
@ -513,9 +514,9 @@ F7(STD, Storm, 511, 511, 511, 511, 511, 511, 511, 511, void, D2FreeWin
//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,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, 10023,10023,10023,00000,00000,00000,00000,00000, DWORD, D2CreateMainWindow,(DWORD,DWORD) );
//F7(STD, D2gfx, 10026,10026,10026,00000,00000,00000,00000,00000, DWORD, D2ShowWindow,() );
//F7,STD, D2gfx, 10027,10027,10027,00000,00000,00000,00000,00000, HWND, D2GetWindowHandle,() );//6FA749C0
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) );
@ -556,10 +557,10 @@ A7(STD, D2Client, B6680,B5A00,B7BD0,00000,00000,00000,00000,00000, DWORD, D2Ge
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, D2Client, 00000,00000, DA20,00000,00000,00000,00000,00000, void, D2SendToServer5, (BYTE type, DWORD p));//6FAADA20
//A7(FAST, D2Client, 00000,00000, D9E0,00000,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,00000, void, D2SendToServer9, (BYTE type, DWORD p1, DWORD p2));//6FAADA40
//A7(FAST, D2Client, 00000,00000, DA70,00000,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,00000, NetClient*, D2GetClient, (Unit* ptUnit, char* lpszErrFile, DWORD ErrLine));//6FCBC2E0
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -586,9 +587,9 @@ C7(D2Client, D50E8, D40E0, D40F0, F5C60, F4FC8, DC6E4, DBC4C,F7038, DWORD, Reso
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(D2Launch, 55818, 56088, 2CD5C,000000, 2CD5C,000000,000000,00000, DWORD, GameTypeMode);//0x50 = 80 //6FA3CD5C-6FA10000
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,000000,104225,000000,000000,00000, DWORD, CurrentNPCNum);
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);

9
Commons/D2UnitStruct.h
View File

@ -13,6 +13,9 @@
struct CBPlayerData;
struct CBItemData;
struct Unit;
struct SkillsBIN;
struct SkillData;
struct ObjectsBIN;
/*=================================================================*/
/* Skill Structure. */
@ -345,12 +348,14 @@ struct NetClient
WORD isHardCoreGame:1;
};
};
BYTE uk2[0x170]; //+0C
BYTE uk2; //+0C
char name[0x10]; //+0D
BYTE uk3[0x15F]; //+1D
BYTE* savefile; //+17C
DWORD finalSize; //+180
DWORD counter; //+184
DWORD currentSize; //+188
BYTE uk3[0x1C]; //+18C
BYTE uk4[0x1C]; //+18C
Game* ptGame; //+1A8
//+1A8 is ptGame
//+4A8 ptNextClient

178
Commons/VersionInfo.cpp
View File

@ -1,118 +1,86 @@
/*=================================================================
File created by Yohann NICOLAS.
Get Game version.
=================================================================*/
//#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
#include "VersionInfo.h"
#pragma comment(lib, "Version.Lib") //ïî ñðàâíåíèþ ñ Delphi 7 - òàêîé ãåììîðîé! :(
#include <windows.h>
#pragma comment(lib, "Version.Lib")
bool IsFile(char* sPath)
const char* VersionStrings[16] = { "1.00","1.07","1.08","1.09","1.09b","1.09d","1.10","1.11","1.11b","1.12","1.13c","1.13d","1.14a","1.14b","1.14c","1.14d" };
const char* GetVersionString(int version)
{
bool bFile = false;
HANDLE hFile = CreateFile
(
sPath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if(hFile != INVALID_HANDLE_VALUE)
return VersionStrings[version];
}
eGameVersion GetD2Version(LPCVOID pVersionResource)
{
CloseHandle(hFile);
bFile = true;
}
return bFile;
UINT uLen;
VS_FIXEDFILEINFO* ptFixedFileInfo;
if (!VerQueryValue(pVersionResource, "\\", (LPVOID*)&ptFixedFileInfo, &uLen))
return UNKNOW;
if (uLen == 0)
return UNKNOW;
WORD major = HIWORD(ptFixedFileInfo->dwFileVersionMS);
WORD minor = LOWORD(ptFixedFileInfo->dwFileVersionMS);
WORD revision = HIWORD(ptFixedFileInfo->dwFileVersionLS);
WORD subrevision = LOWORD(ptFixedFileInfo->dwFileVersionLS);
if (major != 1)
return UNKNOW;
if (minor == 0 && revision == 7 && subrevision == 0) return V107;
if (minor == 0 && revision == 8 && subrevision == 28) return V108;
if (minor == 0 && revision == 9 && subrevision == 19) return V109;
if (minor == 0 && revision == 9 && subrevision == 20) return V109b;
if (minor == 0 && revision == 9 && subrevision == 22) return V109d;
if (minor == 0 && revision == 10 && subrevision == 39) return V110;
if (minor == 0 && revision == 11 && subrevision == 45) return V111;
if (minor == 0 && revision == 11 && subrevision == 46) return V111b;
if (minor == 0 && revision == 12 && subrevision == 49) return V112;
if (minor == 0 && revision == 13 && subrevision == 60) return V113c;
if (minor == 0 && revision == 13 && subrevision == 64) return V113d;
if (minor == 14 && revision == 0 && subrevision == 64) return V114a;
if (minor == 14 && revision == 1 && subrevision == 68) return V114b;
if (minor == 14 && revision == 2 && subrevision == 70) return V114c;
if (minor == 14 && revision == 3 && subrevision == 71) return V114d;
return UNKNOW;
}
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)
eGameVersion GetD2Version(char* gameExe)
{
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;
};
DWORD len = GetFileVersionInfoSize(gameExe, NULL);
if (len == 0)
return UNKNOW;
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;
BYTE* pVersionResource = new BYTE[len];
GetFileVersionInfo(gameExe, NULL, len, pVersionResource);
eGameVersion version = GetD2Version(pVersionResource);
delete pVersionResource;
return version;
}
int GetD2Version(char* PathGameExe)
eGameVersion GetD2Version()
{
TFileVersion GameVer = {-1};
if (! GetAppVersion(PathGameExe, &GameVer)) return -1;
int ver = GetVerD2(GameVer);
return ver;
HMODULE hModule = GetModuleHandle(NULL);
HRSRC hResInfo = FindResource(hModule, MAKEINTRESOURCE(VS_VERSION_INFO), RT_VERSION);
HGLOBAL hResData = LoadResource(hModule, hResInfo);
LPVOID pVersionResource = LockResource(hResData);
//DWORD dwSize = SizeofResource(hInst, hResInfo);
//LPVOID pVersionResource = LocalAlloc(LMEM_FIXED, dwSize);
//CopyMemory(pVersionResource, pRes, dwSize);
eGameVersion version = GetD2Version(pVersionResource);
FreeResource(hResData);
//LocalFree(pVersionResource);
return version;
}
///////////////////////// END OF FILE ///////////////////////

52
Commons/VersionInfo.h
View File

@ -1,30 +1,34 @@
#include <windows.h>
/*=================================================================
File created by Yohann NICOLAS.
union TFileVersion
{
__int64 full;
struct {
WORD subrevision;
WORD revision;
WORD minor;
WORD major;
};
WORD w[4];
};
Get Game version.
=================================================================*/
#pragma once
enum eGameVersion
{
v109b=0,
v109d,
v110,
v111,
v111b,
v112,
v113c,
v113d,
v114a
UNKNOW = -1,
V100 = 0,
V107,
V108,
V109,
V109b,
V109d,
V110,
V111,
V111b,
V112,
V113c,
V113d,
V114a,
V114b,
V114c,
V114d
};
bool GetAppVersion(char* FileName, TFileVersion* VerInfo); // ïîëó÷åíèå âåðñèè ôàéëà
bool GetD2Path(char* buf, DWORD bufsize);
int GetD2Version(char* PathGameExe);
const char* GetVersionString(int version);
eGameVersion GetD2Version(char* gamePath);
eGameVersion GetD2Version();
///////////////////////// END OF FILE ///////////////////////

25
Commons/updatingConst.h
View File

@ -11,6 +11,7 @@ enum UpdateClientConst
{
UC_SELECT_STASH=0x18,
UC_SHARED_GOLD,
UC_PAGE_NAME,
UC_ADD_STAT,
UC_ADD_SYNERGY,
UC_TEST1,
@ -40,15 +41,27 @@ enum UpdateServerConst
US_SELECT_PREVIOUS_INDEX2,
US_SELECT_NEXT_INDEX2,
US_WORLDEVENT,
US_STARTSAVE,
US_SAVE,
US_MAXGOLD,
US_PUTGOLD,
US_TAKEGOLD,
//For CB
US_TEST1,
US_TEST2,
US_TEST3
US_RENAME,
US_PAGENAME,
US_SET_INDEX,
US_RESET_INDEX,
US_INSERT_PAGE,
US_DELETE_PAGE,
US_SWAP3,
US_SWAP2,
US_SWAP1,
US_SWAP0,
US_SWAP0_TOGGLE,
US_TOGGLE1,
US_TOGGLE2,
US_TOGGLE3,
US_TEST1, //For CB
US_TEST2, //For CB
US_TEST3 //For CB
};
/*================================= END OF FILE =================================*/

6
LICENSE
View File

@ -631,8 +631,8 @@ to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
{one line to give the program's name and a brief idea of what it does.}
Copyright (C) {year} {name of author}
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -652,7 +652,7 @@ Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
{project} Copyright (C) {year} {fullname}
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.

4
PlugY/BigStash.cpp
View File

@ -6,10 +6,8 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "plugYFiles.h" // Install_PlugYFiles()
#include "common.h"
bool active_bigStash = false;
bool active_bigStash_tested = false;

2
PlugY/ClientSaveFile.cpp
View File

@ -6,8 +6,6 @@
=================================================================*/
/*
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include <stdio.h>
#define BUFFER_SIZE 0x4000

364
PlugY/Commands.cpp
View File

@ -6,16 +6,14 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "updateServer.h"
#include "updateClient.h"
#include "infinityStash.h"
#include "newInterfaces.h"
#include "newInterface_CubeListing.h"
#include "extraOptions.h"
#include "windowed.h"
#include "common.h"
bool active_Commands=true;
@ -24,21 +22,34 @@ bool active_savegame=false;
#define MAX_CMD_SIZE 200
const char * CMD_RENAME="/rename";
const char * CMD_LISTCUBEFORMULA="/listcube";
const char * CMD_SAVE="/save";
const char * CMD_SELECTPAGE="/page";
const char * CMD_RELOAD="/reload";
const char * CMD_LOCK_MOUSE = "/lockmouse";
const char * CMD_LOCK_MOUSE2 = "/lock";
const char * CMD_UNLOCK_MOUSE = "/unlockmouse";
const char * CMD_UNLOCK_MOUSE2 = "/unlock";
const char * CMD_STARTSAVE="/save";
const char * CMD_RENAME_CHAR="/renamechar";
const char * CMD_MAXGOLD="/maxgold";
const char * CMD_REPAGE_NAME = "/renamepage";
const char * CMD_SET_INDEX = "/setindex";
const char * CMD_RESET_INDEX = "/resetindex";
const char * CMD_INSERT_PAGE = "/insertpage";
const char * CMD_DELETE_PAGE = "/deletepage";
const char * CMD_SWAP = "/swap";
const char * CMD_TOGGLE = "/toggle";
const char * CMD_DISPLAY_MANA_LIFE = "/dml";
const char * CMD_DISPLAY_LIFE_MANA = "/dlm";
const char * CMD_DISPLAY_LIFE = "/dl";
const char * CMD_DISPLAY_MANA = "/dm";
const char * CMD_LISTCUBEFORMULA="/listcube";
//const char * CMD_RELOAD="/reload";
//const char * CMD_MAXGOLD="/maxgold";
/*
$+21C8 02020648 |. 6A 01 PUSH 1
$+21CA 0202064A |. 52 PUSH EDX
@ -48,6 +59,116 @@ $+21CD 0202064D |. 8BC3 MOV EAX,EBX
$+21CF 0202064F |. E8 2CDEFFFF CALL D2Game.0201E480
*/
/*
struct D2NPCRecordStrc
{
DWORD value;
};
struct D2NPCDataStrc
{
DWORD value;
};
D2NPCRecordStrc* __fastcall STORES_GetRecord(Game* pGame, int nNPC, int* pIndex)
{
if (pGame == NULL)
return NULL;
if (pIndex != NULL)
*pIndex = 0;
D2NPCDataStrc* pControl = pGame->pVendorControl;
if (pControl == NULL)
return NULL;
D2NPCRecordStrc* pList = pControl->pVendors;
if (pList == NULL)
return NULL;
const int nCount = INLINE_GetCustomTXT()->nNPCCount;
for (int i = 0; i < nCount; i++)
{
if (pList->nNPC == nNPC)
{
if (pIndex != NULL)
*pIndex = i;
return pList;
}
pList++;
}
return NULL;
}
Inventory* __fastcall STORES_GetGambleInventory(Game* pGame, Unit* pPlayer, Unit* pNPC)
{
if (pGame == NULL || pPlayer == NULL || pNPC == NULL)
return NULL;
D2NPCRecordStrc* pRecord = STORES_GetRecord(pGame, pNPC->nUnitIndex, NULL);
if (pRecord == NULL || !pRecord->bGambleInit)
return NULL;
D2NPCGambleStrc* pGamble = pRecord->pGamble;
int nGUID = pPlayer->dwGUID;
while (pGamble != NULL)
{
if (pGamble->dwGUID == nGUID)
return pGamble->pInventory;
pGamble = pGamble->pNext;
}
return NULL;
}
void __fastcall STORES_UpdateInventoryItems(D2UnitStrc* pNPC, D2InventoryStrc* pInventory, BOOL bPlayDropSounds = FALSE)
{
D2UnitStrc* pItem = pInventory->pFirstItem;
while (pItem != NULL)
{
if (pItem->nUnitType == UNIT_ITEM)
{
pItem->fUnitFlagsEx |= UNITFLAG_SHOPITEM;
if (ITEMS_CheckSocketable(pItem))
ITEMS_SetFlag(pItem, ITEMFLAG_NEWITEM, TRUE);
ITEMS_UpdateTrade(pNPC->pInventory, pItem); //D2Common.#10283
if (bPlayDropSounds)
{
FileItemTable* pRecord = INLINE_GetItemRecord(pItem->nUnitIndex);
if (pRecord != NULL)
D2PlaySound(pRecord->nDropSound, pInventory->pOwner, 0, 0, 0);
}
}
pItem = pItem->pItemData->pNext;
}
}
void gambleReload(Unit* ptChar)
{
D2UnitStrc* pNPC = UNITS_GetServer(pGame, UNIT_MONSTER, pPacket->dwInteractGUID);
if (pNPC != NULL)
{
if (pNPC->dwGUID == pPlayer->dwInteractGUID)
{
D2NPCRecord* pNPCRecord = NPC_GetRecord(pGame, pNPC->nUnitIndex);
if (pNPCRecord->bGambleInit)
{
D2FillTradeOrGamble(pGame, pNPC, pPlayer, TRUE); //D2Game.0x6FCCAE20
D2InventoryStrc* pInv = STORES_GetGambleInventory(pGame, pPlayer, pNPC);
STORES_UpdateInventoryItems(pNPC, pInv, TRUE);
D2RefreshUnitInventory(pNPC, TRUE); //D2Common.#10357
}
}
}
}
*/
void gambleReload(Unit* ptChar)
{
Unit* ptNPC = D2GetCurrentNPC();
@ -138,44 +259,85 @@ void updateSharedGold(DWORD goldAmount)
PCPY->sharedGold = goldAmount;
}
bool renameCharacter(Unit* ptChar, const char* newName)
{
int len = strlen(newName);
if (len < 2 || len > 15)
return 0;
for (int i = 0; i < len; i++)
{
char c = newName[i];
if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c == '_')))
return 1;
}
// Move current save file
{
char szCurrentFile[MAX_PATH];
char szNewFile[MAX_PATH];
//Get temporary savefile name.
D2FogGetSavePath(szCurrentFile, MAX_PATH);
D2FogGetSavePath(szNewFile, MAX_PATH);
strcat(szCurrentFile, ptChar->ptPlayerData->name);
strcat(szNewFile, newName);
strcat(szCurrentFile, ".");
strcat(szNewFile, ".");
int curLen = strlen(szCurrentFile);
int newLen = strlen(szNewFile);
strcpy(&szCurrentFile[curLen], "d2s");
strcpy(&szNewFile[newLen], "d2s");
MoveFile(szCurrentFile, szNewFile);
strcpy(&szCurrentFile[curLen], "d2x");
strcpy(&szNewFile[newLen], "d2x");
MoveFile(szCurrentFile, szNewFile);
strcpy(&szCurrentFile[curLen], "key");
strcpy(&szNewFile[newLen], "key");
MoveFile(szCurrentFile, szNewFile);
strcpy(&szCurrentFile[curLen], "ma0");
strcpy(&szNewFile[newLen], "ma0");
MoveFile(szCurrentFile, szNewFile);
strcpy(&szCurrentFile[curLen], "ma1");
strcpy(&szNewFile[newLen], "ma1");
MoveFile(szCurrentFile, szNewFile);
strcpy(&szCurrentFile[curLen], "ma2");
strcpy(&szNewFile[newLen], "ma2");
MoveFile(szCurrentFile, szNewFile);
strcpy(&szCurrentFile[curLen], "ma3");
strcpy(&szNewFile[newLen], "ma3");
MoveFile(szCurrentFile, szNewFile);
strcpy(&szCurrentFile[curLen], "ma4");
strcpy(&szNewFile[newLen], "ma4");
MoveFile(szCurrentFile, szNewFile);
strcpy(&szCurrentFile[curLen], "map");
strcpy(&szNewFile[newLen], "map");
MoveFile(szCurrentFile, szNewFile);
}
// Update server
for (int i = 0; i <= len; i++)
updateServer(US_RENAME + (newName[i] << 8));
// Update client
log_msg("Rename on Client : %s -> %s\n", ptChar->ptPlayerData->name, newName);
strcpy(ptChar->ptPlayerData->name, newName);
updateServer(US_SAVE);
return 0;
}
/****************************************************************************************************/
int STDCALL commands (char* ptText)
{
//return 0;
log_msg("Command : %s\n", ptText);
Unit* ptChar = D2GetClientPlayer();
//return 0;
char command[MAX_CMD_SIZE];
ZeroMemory(command,MAX_CMD_SIZE);
//return 0;
strncpy(command,ptText,MAX_CMD_SIZE-1);
//return 0;
strlwr(command);
if (!strncmp(command,CMD_RENAME,strlen(CMD_RENAME)))
{
if (!active_multiPageStash) return 1;
char* param = &command[strlen(CMD_RENAME)];
DWORD len = strlen(param);
if (len && (param[0] != ' ')) return 1;
_strlwr(command);
Stash* ptStash = PCPY->currentStash;
if (!ptStash) return 0;
if (len>1)
if (!strcmp(command, CMD_SAVE))
{
D2FogMemDeAlloc(ptStash->name,__FILE__,__LINE__,0);
ptStash->name = (char *)malloc(len);//D2FogMemAlloc(len,__FILE__,__LINE__,0);
strcpy(ptStash->name,&param[1]);
} else {
D2FogMemDeAlloc(ptStash->name,__FILE__,__LINE__,0);
ptStash->name = NULL;
}
return 0;
}
if (!strcmp(command,CMD_LISTCUBEFORMULA))
{
if (!active_listAllCubeFormula) return 1;
listAllCubeFormula();
if (onRealm) return 1;
updateServer(US_SAVE);
return 0;
}
@ -186,24 +348,112 @@ int STDCALL commands (char* ptText)
return 0;
}
if (!strcmp(command,CMD_RELOAD))
if (!strcmp(command, CMD_LOCK_MOUSE) || !strcmp(command, CMD_LOCK_MOUSE2))
{
if (onRealm) return 1;
gambleReload(ptChar);
lockMouseCursor();
return 0;
}
if (!strcmp(command,CMD_STARTSAVE))
if (!strcmp(command, CMD_UNLOCK_MOUSE) || !strcmp(command, CMD_UNLOCK_MOUSE2))
{
if (onRealm) return 1;
updateServer(US_STARTSAVE);
unlockMouseCursor();
return 0;
}
if (!strcmp(command,CMD_MAXGOLD))
if (!strncmp(command, CMD_RENAME_CHAR, strlen(CMD_RENAME_CHAR)))
{
if (onRealm) return 1;
updateServer(US_MAXGOLD);
const char* param = &command[strlen(CMD_RENAME_CHAR)];
if (param[0] != ' ')
return 1;
param++;
return renameCharacter(ptChar, param);
}
if (!strncmp(command, CMD_REPAGE_NAME,strlen(CMD_REPAGE_NAME)))
{
if (!active_multiPageStash) return 1;
char* param = &command[strlen(CMD_REPAGE_NAME)];
Stash* ptStash = PCPY->currentStash;
if (!ptStash)
return 0;
int len = strlen(param);
while (len > 0 && param[0] == ' ')
{
param++;
len--;
}
if (len > 0 && len <= 15)
{
log_msg("Rename current page on Client : %s -> %s\n", ptStash->name, param);
renameCurrentStash(ptChar, param);
for (int i = 0; i <= len; i++)
updateServer(US_PAGENAME + (param[i] << 8));
}
else if (len == 0)
{
log_msg("Rename current page on Client: %s\n", ptStash->name);
renameCurrentStash(ptChar, NULL);
updateServer(US_PAGENAME);
}
return 0;
}
if (!strcmp(command, CMD_SET_INDEX))
{
if (!active_multiPageStash) return 1;
updateServer(US_SET_INDEX);
return 0;
}
if (!strcmp(command, CMD_RESET_INDEX))
{
if (!active_multiPageStash) return 1;
updateServer(US_RESET_INDEX);
return 0;
}
if (!strcmp(command, CMD_INSERT_PAGE))
{
if (!active_multiPageStash) return 1;
insertStash(ptChar);
updateServer(US_INSERT_PAGE);
return 0;
}
if (!strcmp(command, CMD_DELETE_PAGE))
{
if (!active_multiPageStash) return 1;
if (deleteStash(ptChar))
updateServer(US_DELETE_PAGE);
return 0;
}
if (!strncmp(command, CMD_SWAP, strlen(CMD_SWAP)))
{
if (!active_multiPageStash) return 1;
int page = atoi(&command[strlen(CMD_SWAP)]) - 1;
if (page < 0)
return 1;
updateServer(US_SWAP3 + ((page & 0xFF000000) >> 16));
updateServer(US_SWAP2 + ((page & 0xFF0000) >> 8));
updateServer(US_SWAP1 + (page & 0xFF00));
updateServer(US_SWAP0 + ((page & 0xFF) << 8));
return 0;
}
if (!strncmp(command, CMD_TOGGLE, strlen(CMD_TOGGLE)))
{
if (!active_sharedStash) return 1;
int page = atoi(&command[strlen(CMD_TOGGLE)]) - 1;
if (page < 0)
return 1;
updateServer(US_SWAP3 + ((page & 0xFF000000) >> 16));
updateServer(US_SWAP2 + ((page & 0xFF0000) >> 8));
updateServer(US_SWAP1 + (page & 0xFF00));
updateServer(US_SWAP0_TOGGLE + ((page & 0xFF) << 8));
return 0;
}
@ -224,6 +474,28 @@ int STDCALL commands (char* ptText)
active_AlwaysDisplayLifeMana = !active_AlwaysDisplayLifeMana;
return 0;
}
if (!strcmp(command, CMD_LISTCUBEFORMULA))
{
if (!active_listAllCubeFormula) return 1;
listAllCubeFormula();
return 0;
}
//if (!strcmp(command,CMD_RELOAD))
//{
// if (onRealm) return 1;
// gambleReload(ptChar);
// return 0;
//}
//if (!strcmp(command,CMD_MAXGOLD))
//{
// if (onRealm) return 1;
// updateServer(US_MAXGOLD);
// return 0;
//}
return 1;
}
@ -288,9 +560,11 @@ 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;

160
PlugY/Common.cpp
View File

@ -1,19 +1,11 @@
/*=================================================================
File created by Yohann NICOLAS.
*Modified by L'Autour.
Common functions.
=================================================================*/
#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);}
@ -26,156 +18,4 @@ void freeMessage(sWinMessage* msg)
D2FreeWinMessage(msg);
}
//MS C++__fastcall(ecx,edx,) vs Delphi register(eax,edx,ecx) - :(
typedef int (__stdcall *p_UCS2toUTF8)(char*, int, LPWSTR, int);
p_UCS2toUTF8 _UCS2toUTF8;
int UCS2toUTF8(char* dst, int maxdst, LPWSTR src, int lensrc)
{
if (_UCS2toUTF8 == NULL) return 0;
return _UCS2toUTF8(dst, maxdst, src, lensrc);
}
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)
{
if (_getTranslatedString == NULL) return L"#";
return _getTranslatedString(stringID);
}
typedef int(__stdcall *p_wSprintStringLastGender)(LPWSTR, int, int);
p_wSprintStringLastGender _wSprintStringLastGender;
int wSprintStringLastGender(LPWSTR buf, int lenbuf,int stringID)
{
if (_wSprintStringLastGender == NULL) return 0;
return _wSprintStringLastGender(buf, lenbuf, stringID);
}
typedef LPWSTR(__fastcall *p_cutStringGender)(LPWSTR);
p_cutStringGender _cutStringGender;
LPWSTR cutStringGender(LPWSTR str)
{
if (_cutStringGender == NULL) return str;
return _cutStringGender(str);
}
typedef LPWSTR(__fastcall *p_setMonoString)(LPWSTR);
p_setMonoString _setMonoString;
LPWSTR setMonoString(LPWSTR str)
{
if (_setMonoString == NULL) return str;
return _setMonoString(str);
}
typedef bool(__fastcall *p_initTranslatedString)(int);
HINSTANCE PlugyLocalLib = NULL;
bool initLocaleStrings()
{
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;
}
void freeLocaleStrings()
{
if (PlugyLocalLib == NULL) return;
FreeLibrary(PlugyLocalLib);
}
LPWSTR getTypeUString (WORD id, LPWSTR lpText, DWORD size)
{
ItemTypesBIN* itemTypeData = D2GetItemTypesBIN(id);
if (!itemTypeData)
{
wcsncpy(lpText, L"Bad Type", size);
return lpText;
}
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 = itemTypeData->code;
code.zero = 0;
UTF8toUCS2(lpText,size, (char*)&code, 0xFFFF);
} else
wcsncpy(lpText, string, size);
return lpText;
}
/*================================= END OF FILE =================================*/

489
PlugY/CommonUTF8.cpp
View File

@ -1,489 +0,0 @@
/*=================================================================
File created by Yohann NICOLAS.
Common functions.
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
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);}
void freeMessage(sWinMessage* msg)
{
msg->managed=1;
msg->unmanaged=0;
D2FreeWinMessage(msg);
}
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)
{
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;
}
}
#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)
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 点数");
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: 所有剩");
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)");
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");
// "取消所有技能加点");
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: 首页)");
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: 最后非空页");
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"";
}
}
/*=================================================================*/
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};
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)
{
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;
}
}
char* getTypeAString (WORD id, char* lpText, DWORD size)
{
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;
}
LPWSTR getTypeUString (WORD id, LPWSTR lpText, DWORD size)
{
ItemTypesBIN* itemTypeData = D2GetItemTypesBIN(id);
if (!itemTypeData)
{
mbstowcs(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;
mbstowcs(lpText, (char*)&code, size);
} else
mbstowcs(lpText, string, size);
return lpText;
}
/*================================= END OF FILE =================================*/

3
PlugY/CustomLibraries.cpp
View File

@ -5,9 +5,8 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "customLibraries.h"
#include "common.h"
TCustomDll* customDlls=NULL;

9
PlugY/D2functions.cpp
View File

@ -1,6 +1,6 @@
/*================================================
File created by Yohann NICOLAS.
*Add support 1.13d by L'Autour.
Add support 1.13d by L'Autour.
This file implements some common and useful
function related to some Diablo II mechanisms.
@ -8,9 +8,8 @@
================================================*/
#include "common.h"
#include "d2functions.h"
#include "error.h"
s_shifting shifting;
#define D2S(F, I, R, N, P) T##N N;
#define D2F(F, I, R, N, P) T##N N;
@ -617,7 +616,7 @@ 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,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 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);
@ -947,7 +946,7 @@ 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,49));
shifting.ptSpecificData = V7(D2Common,70,70,14,14,14,14,14,14);

174
PlugY/D2wrapper.cpp
View File

@ -9,13 +9,6 @@
=================================================================*/
// Core Class Headers
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "customLibraries.h"
/* Beginning of Custom Header */
#include "globalVariable.h" // Install_VariableOnRealm()
#include "commands.h" // Install_Commands()
#include "othersFeatures.h" // Install_ChangeResolution()
@ -32,27 +25,29 @@
#include "uberQuest.h" // Install_UberQuest()
#include "extraOptions.h" // Install_AlwaysRegenMapInSP()
#include "language.h" // Install_LanguageManagement()
#include "../Commons/VersionInfo.h"
#include "windowed.h" // installed with Install_PrintPlugYVersion()
#include "customLibraries.h"
#include "common.h"
int version_SmackW32 = UNKNOW;
int version_D2Common = UNKNOW;
int version_ijl11 = UNKNOW;
int version_D2Gdi = UNKNOW;
int version_D2Win = UNKNOW;
int version_D2sound = UNKNOW;
int version_D2MCPCLI = UNKNOW;
int version_D2Launch = UNKNOW;
int version_D2gfx = UNKNOW;
int version_D2Client = UNKNOW;
int version_D2Net = UNKNOW;
int version_D2Lang = UNKNOW;
int version_D2Game = UNKNOW;
int version_D2CMP = UNKNOW;
int version_Bnclient = UNKNOW;
int version_Fog = UNKNOW;
int version_Storm = UNKNOW;
//-------------------------
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;
@ -93,9 +88,6 @@ const char* S_Bnclient = "Bnclient.dll";
const char* S_Fog = "Fog.dll";
const char* S_Storm = "Storm.dll";
const char* S_CloneBattles ="CloneBattles.dll";
const char* S_DarkAlliance ="DarkAlliance.dll";
DWORD loadLibrary( const char* libraryName)
{
DWORD offset;
@ -318,7 +310,7 @@ void loadCustomLibraries()
/*
void getVersion(DWORD addr, DWORD addr111, int* ver, DWORD v109b, DWORD v109d, DWORD v110, DWORD v111, DWORD v111a, DWORD v111b, DWORD v112, DWORD v113, const char * filename)
void getVersion(DWORD addr, DWORD addr111, int* ver, DWORD v109b, DWORD v109d, DWORD v110, DWORD v111, DWORD v111a, DWORD v111b, DWORD v112, DWORD v113c, DWORD v113d, const char * filename)
{
log_msg("version of %s\t",filename);
@ -340,12 +332,15 @@ void getVersion(DWORD addr, DWORD addr111, int* ver, DWORD v109b, DWORD v109d, D
} else if (addr==v112) {
*ver = V112;
log_msg("1.12\n");
} else if (addr==v113) {
*ver = V113;
log_msg("1.13\n");
} else if (addr==v113c) {
*ver = V113c;
log_msg("1.13c\n");
} else if (addr==v113d) {
*ver = V113d;
log_msg("1.13d\n");
} else {
*ver = V113;
log_msg("unknow, try with 1.13\n");
*ver = V113d;
log_msg("unknow, try with 1.13d\n");
}
}
#define GET_VERSION(F,X,Y,A,B,C,D,E,G,H,I) getVersion(*(DWORD*)(offset_##F + 0x##X), *(DWORD*)(offset_##F + 0x##Y), &version_##F, 0x##A, 0x##B, 0x##C, 0x##D, 0x##E, 0x##G, 0x##H, 0x##I, S_##F)
@ -377,12 +372,14 @@ 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)
void getVersion(DWORD addr, int* ver, DWORD v109b, DWORD v109d, DWORD v110, DWORD v111, DWORD v111b, DWORD v112, DWORD v113c, int version, const char * filename)
{
log_msg("version of %s\t", filename);
if (addr==v109b) {
if (version >= V113d) {
*ver = version;
log_msg("%s\n", GetVersionString(version));
} else if (addr==v109b) {
*ver = V109b;
log_msg("1.09b\n");
} else if (addr==v109d) {
@ -400,82 +397,45 @@ void getVersion(DWORD addr, int* ver, DWORD v109b, DWORD v109d, DWORD v110, DWOR
} else if (addr==v112) {
*ver = V112;
log_msg("1.12\n");
} else if (addr==v113) {
*ver = V113;
log_msg("1.13\n");
} else if (addr==v113c) {
*ver = V113c;
log_msg("1.13c\n");
} else {
*ver = V113;
log_msg("unknow, try with 1.13\n");
*ver = V113d;
log_msg("unknow, try with 1.13d\n");
}
}
#define GET_VERSION(F,X,A,B,C,D,E,G,H) getVersion(*(DWORD*)(offset_##F + 0x##X), &version_##F, 0x##A, 0x##B, 0x##C, 0x##D, 0x##E, 0x##G, 0x##H, S_##F)
#define GET_VERSION(F,X,A,B,C,D,E,G,H,V) getVersion(*(DWORD*)(offset_##F + 0x##X), &version_##F, 0x##A, 0x##B, 0x##C, 0x##D, 0x##E, 0x##G, 0x##H, V, S_##F)
bool initD2version()
{
log_msg("***** Get Game.exe version *****\n");
int version = GetD2Version();
log_msg("Game.exe version : %i (%s)\n", version, GetVersionString(version));
log_msg("***** Get dll versions *****\n");
//GET_VERSION(SmackW32
GET_VERSION(D2Common, 10CA, A1E86FDC, B1E86FDC, 72D03B42, F883057E, 16746AC6, 00FE81C3, 74FE85DB);
GET_VERSION(D2Common, 10CA, A1E86FDC, B1E86FDC, 72D03B42, F883057E, 16746AC6, 00FE81C3, 74FE85DB, version);
//GET_VERSION(ijl11
GET_VERSION(D2Gdi, 105, B4000000, 0B210E00, E4000000, 48000401, 2F000401, 00000000, B7000401);
GET_VERSION(D2Win, 1699, 88686F8C, 84686F8C, D094686F, F0030000, 001435E8, 8B088F44, 0013F5E8);
GET_VERSION(D2Gdi, 105, B4000000, 0B210E00, E4000000, 48000401, 2F000401, 00000000, B7000401, version);
GET_VERSION(D2Win, 1699, 88686F8C, 84686F8C, D094686F, F0030000, 001435E8, 8B088F44, 0013F5E8, version);
//GET_VERSION(D2sound
//GET_VERSION(D2MCPCLI
GET_VERSION(D2Launch, 109A, 81E8526F, 01E8526F, 85E8526F, 247C8B00, 00FC6583, 15FF0424, E850E045);
GET_VERSION(D2gfx, 10D, EB000000, 006FA700, 00000010, 2A000401, 19000401, 0B210E00, 00000000);
GET_VERSION(D2Client, 17F, 00000000, 14500000, 12500000, 0D814800, 0D812800, 0DA01000, 0DA03000);
GET_VERSION(D2Net, 16E1, 78B8A73C, 68B8A73C, 10244C8B, 5349E808, 5EA9E808, 105D8B72, 53B9E808);
GET_VERSION(D2Lang, 126D, FC45048B, F445048B, 02C18313, C4830000, 00C6E045, 8B48408B, 0C75FF0C);
// GET_VERSION(D2Game, 1010, D22A78A1, D22910A1, D43FB0A1, 03E8506F, 53E8506F, 89E8506F, 63E8506F);
GET_VERSION(D2Game, 1092, 18968BF1, 38968BF1, 28968BF1, F6335608, C690C5B9, 895FD713, 56535700);
GET_VERSION(D2CMP, 1359, 3C686FE0, 38686FE0, 8BF78B56, 4C880424, 07C71824, CCCCCCCC, C7000005);
GET_VERSION(D2Launch, 109A, 81E8526F, 01E8526F, 85E8526F, 247C8B00, 00FC6583, 15FF0424, E850E045, version);
GET_VERSION(D2gfx, 10D, EB000000, 006FA700, 00000010, 2A000401, 19000401, 0B210E00, 00000000, version);
GET_VERSION(D2Client, 17F, 00000000, 14500000, 12500000, 0D814800, 0D812800, 0DA01000, 0DA03000, version);
GET_VERSION(D2Net, 16E1, 78B8A73C, 68B8A73C, 10244C8B, 5349E808, 5EA9E808, 105D8B72, 53B9E808, version);
GET_VERSION(D2Lang, 126D, FC45048B, F445048B, 02C18313, C4830000, 00C6E045, 8B48408B, 0C75FF0C, version);
// GET_VERSION(D2Game, 1010, D22A78A1, D22910A1, D43FB0A1, 03E8506F, 53E8506F, 89E8506F, 63E8506F, version);
GET_VERSION(D2Game, 1092, 18968BF1, 38968BF1, 28968BF1, F6335608, C690C5B9, 895FD713, 56535700, version);
GET_VERSION(D2CMP, 1359, 3C686FE0, 38686FE0, 8BF78B56, 4C880424, 07C71824, CCCCCCCC, C7000005, version);
//GET_VERSION(Bnclient
GET_VERSION(Fog, 102, D0000006, 10000001, 00000006, 000042E6, 00004302, 0000483C, 00004B95);
GET_VERSION(Storm, 1190, 19E85082, 59E85082, 13C103F6, 0474F685, 8B000321, 3B1074C9, 0D896404);
GET_VERSION(Fog, 102, D0000006, 10000001, 00000006, 000042E6, 00004302, 0000483C, 00004B95, version);
GET_VERSION(Storm, 1190, 19E85082, 59E85082, 13C103F6, 0474F685, 8B000321, 3B1074C9, 0D896404, version);
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)
@ -489,12 +449,7 @@ extern "C" __declspec(dllexport) void* __stdcall Init(LPSTR IniName)
loadD2Libraries();
if (!initD2version())
{
log_msg("wrong G ame.exe version\n");
return NULL;
}
if (!initD2version()) return NULL;
if (!initD2functions()) return NULL;
@ -519,7 +474,7 @@ extern "C" __declspec(dllexport) void* __stdcall Init(LPSTR IniName)
if (active_VersionTextChange)
Install_VersionChange();
if (active_PrintPlugYVersion)
if (active_PrintPlugYVersion || active_Windowed)
Install_PrintPlugYVersion();
if (active_StatsPoints)
@ -588,12 +543,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();
loadLocalizedStrings(D2GetLang());
log_msg("***** ENTERING DIABLO II *****\n\n" );
active_logFile = active_logFile - 1;
@ -608,7 +561,6 @@ extern "C" __declspec(dllexport) bool __stdcall Release()
log_msg("\n***** ENDING DIABLO II *****\n\n" );
freeCustomLibraries();
freeLocaleStrings();
freeD2Libraries();
return true;
}

6
PlugY/Error.cpp
View File

@ -5,14 +5,14 @@
=================================================================*/
#include "parameters.h"
#include "error.h"
#include <windows.h>
#include <stdio.h> // fopen() fclose() fprintf() vfprintf()
#include <stdarg.h> // ...
#include <string.h> // strlen() strcat()
#include <direct.h> // _getcwd()
#include "error.h"
#include "d2functions.h" // Fog_assert()
DWORD active_logFile = 1;
static char log_file[MAX_PATH] = "";

5
PlugY/ExtendedSaveFile.cpp
View File

@ -5,12 +5,11 @@
=================================================================*/
#include "common.h"
#include "extendedSaveFile.h"
#include "error.h"
#include "d2functions.h"
#include "infinityStash.h"
#include "customLibraries.h"
#include "common.h"
#include <stdio.h>
#define BUFFER_SIZE 0x4000
#define FILE_VERSION 0x3130 //"01"

18
PlugY/ExtraOptions.cpp
View File

@ -7,14 +7,12 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include <stdio.h>
int active_RunLODs = false;
int active_alwaysRegenMapInSP = false;
DWORD nbPlayersCommandByDefault = 1;
int active_DisplayItemLevel = false;
DWORD nbPlayersCommandByDefault = 0;
int active_alwaysRegenMapInSP = false;
int active_RunLODs = false;
int active_AlwaysDisplayLifeMana = false;
int active_EnabledTXTFilesWithMSExcel = false;
int active_DisplayBaseStatsValue = false;
@ -27,9 +25,7 @@ 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, getTranslatedString(STR_ITEM_LEVEL), D2GetItemLevel(ptItem));
wcscat(text,L"\n");
_snwprintf(text, sizeof(text), L"%s: %u\n", getLocalString(STR_ITEM_LEVEL), D2GetItemLevel(ptItem));
D2SetColorPopup(text,WHITE);
wcscat(popup,text);
}
@ -401,10 +397,7 @@ 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, 0000);
@ -437,7 +430,6 @@ 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 )
@ -525,7 +517,7 @@ void STDCALL printDisplayBaseStatsValue(WORD statID, sDrawImageInfo* data, DWORD
if (isOnRect(D2GetMouseX(),D2GetMouseY(),x+5,y+5,32,32))
{
WCHAR text[100];
swprintf(text, getTranslatedString(STR_STATS_BASE_MIN), statValue, minValue);
_snwprintf(text, sizeof(text), getLocalString(STR_STATS_BASE_MIN), statValue, minValue);
D2SetFont(1);
D2PrintPopup(text, x+18, y-32, WHITE, 1);
}

7
PlugY/GlobalVariable.cpp
View File

@ -6,13 +6,10 @@
=================================================================*/
#include "bigStash.h" // active_bigStash_tested
#include "uberQuest.h" //active_UberQuest + resetQuestState()
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "bigStash.h"
#include <stdio.h>
#include "uberQuest.h"
#include "worldEvent.h"
bool onRealm=false;
bool needToInit=false;

333
PlugY/INIfile.cpp
View File

@ -12,11 +12,9 @@
******************************************************************************/
#include <stdio.h>
#include "INIfile.h"
#include "d2functions.h"
#include "error.h"
#include "common.h"
#include <stdio.h>
/*
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/getprivateprofilestring.asp
@ -24,12 +22,10 @@ http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/ge
/*****************************************************************************/
// First a few support routines
// Utils
static char *strstri(char *text, char *string)
LPSTR strstri(LPSTR text, LPSTR string)
{
char *found = NULL;
if(text && string)
{
int len = strlen(string);
@ -37,9 +33,9 @@ static char *strstri(char *text, char *string)
{
while(*text)
{
if(strnicmp(string, text, len) == 0)
if(_strnicmp(string, text, len) == 0)
{
found = text;
return text;
break;
}
@ -47,12 +43,32 @@ static char *strstri(char *text, char *string)
}
}
}
return found;
return NULL;
}
LPCWSTR strstri(LPCWSTR text, LPCWSTR string)
{
if (text && string)
{
int len = wcslen(string);
if (len)
{
while (*text)
{
if (_wcsnicmp(string, text, len) == 0)
{
return text;
break;
}
static BOOL chrcmp(char c, char *string)
text++;
}
}
}
return NULL;
}
BOOL chrcmp(char c, char *string)
{
for(unsigned int i=0; i<strlen(string); i++)
{
@ -64,7 +80,7 @@ static BOOL chrcmp(char c, char *string)
}
static BOOL FileExists(char *name)
BOOL FileExists(char *name)
{
DWORD attr = GetFileAttributes(name);
return ( (attr != (DWORD)-1) && !(attr & FILE_ATTRIBUTE_DIRECTORY) );
@ -72,14 +88,14 @@ static BOOL FileExists(char *name)
/*****************************************************************************/
/*****************************************************************************/
INIFile::INIFile()
{
m_readWrite = 0;
m_file = NULL;
m_cache = NULL;
m_cacheWritePos = 0;
m_cache = NULL;
m_sectionStart = NULL;
m_sectionEnd = NULL;
@ -98,14 +114,11 @@ INIFile::~INIFile()
}
/*****************************************************************************/
BOOL INIFile::InitReadWrite(char *path, int readWrite, DWORD writeCacheSize)
{
if(path)
BOOL INIFile::InitReadWrite(const char *path, int readWrite, DWORD writeCacheSize)
{
if (!path)
return false;
m_readWrite = readWrite;
m_cacheWritePos = 0;
m_sectionStart = NULL;
@ -201,7 +214,6 @@ BOOL INIFile::InitReadWrite(char *path, int readWrite, DWORD writeCacheSize)
if(m_cache)
return TRUE;
}
}
return FALSE;
}
@ -268,19 +280,13 @@ BOOL INIFile::close()
}
/*****************************************************************************/
static char delimiterEnd[] = "\r\n\0";
int INIFile::GetPrivateProfileString(const char *section, const char *key, const char *def, char *dest, DWORD size)
{
DWORD copied = 0;
if((m_cache) && (section && key && dest && size))
{
if(stricmp(section, m_currentSection) != 0)
if(_stricmp(section, m_currentSection) != 0)
{
strncpy(m_currentSection, section, MAX_SECTIONNAME_LENGTH);
@ -319,7 +325,7 @@ int INIFile::GetPrivateProfileString(const char *section, const char *key, const
{
s += strlen(keyString);
while(*s && (copied < size) && (chrcmp(*s, delimiterEnd) == FALSE))
while(*s && copied < size && *s != '\n' && *s != '\r' && *s != NULL)
{
*dest++ = *s++;
copied++;
@ -333,7 +339,10 @@ int INIFile::GetPrivateProfileString(const char *section, const char *key, const
}
if (!copied && def)
{
strncpy(dest, def, size);
return strlen(dest);
}
return copied; // Do not include the terminating null character
}
@ -343,7 +352,7 @@ BOOL INIFile::WritePrivateProfileString(char *section, char *key, char *string)
{
if(!section || !key || !string) return false;
if(stricmp(section, m_currentSection) != 0)
if(_stricmp(section, m_currentSection) != 0)
{
if(m_cacheWritePos == 0)
m_cacheWritePos += sprintf((m_cache + m_cacheWritePos), "[%s]\r\n", section);
@ -356,4 +365,262 @@ BOOL INIFile::WritePrivateProfileString(char *section, char *key, char *string)
return true;
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
INIFileW::INIFileW()
{
m_readWrite = 0;
m_file = NULL;
m_cacheWritePos = 0;
m_cache = NULL;
m_sectionStart = NULL;
m_sectionEnd = NULL;
ZeroMemory((void *)m_path, sizeof(m_path));
ZeroMemory((void *)m_currentSection, sizeof(m_currentSection));
}
INIFileW::~INIFileW()
{
if (m_file)
CloseHandle(m_file);
if (m_cache)
delete[] m_cache;
}
BOOL INIFileW::InitReadWrite(const char *path, int readWrite, DWORD writeCacheSize)
{
if (!path)
return false;
m_readWrite = readWrite;
m_cacheWritePos = 0;
m_sectionStart = NULL;
m_sectionEnd = NULL;
ZeroMemory((void *)m_path, sizeof(m_path));
ZeroMemory((void *)m_currentSection, sizeof(m_currentSection));
strncpy(m_path, path, sizeof(m_path));
if (m_file)
{
CloseHandle(m_file);
m_file = NULL;
}
if (m_cache)
{
delete[] m_cache;
m_cache = NULL;
}
// If read, the open file and cache content in memory
if (m_readWrite == INIFILE_MPQREAD)
{
void* refFile;
if (D2MPQOpenFile(m_path, &refFile))
{
DWORD fileSize = D2MPQGetSizeFile(refFile, NULL);
m_cache = new WCHAR[fileSize + 1];
if (m_cache)
{
DWORD read;
if (D2MPQReadFile(refFile, (BYTE*)m_cache, fileSize, &read, NULL, NULL, NULL) == 0)
{
delete[] m_cache;
m_cache = NULL;
}
else
m_cache[fileSize] = 0;
}
D2MPQCloseFile(refFile);
if (m_cache)
return TRUE;
}
}
// if((m_readWrite == INIFILE_MPQREAD) || (m_readWrite == INIFILE_READ))
if (m_readWrite == INIFILE_READ)
{
if (FileExists(m_path))
{
m_file = CreateFile(m_path,
GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (m_file != INVALID_HANDLE_VALUE)
{
DWORD fileSize = GetFileSize(m_file, NULL);
m_cache = new WCHAR[fileSize + 1];
if (m_cache)
{
DWORD read;
if (ReadFile(m_file, m_cache, fileSize, &read, NULL) == 0)
{
delete[] m_cache;
m_cache = NULL;
}
else
m_cache[fileSize] = 0;
}
CloseHandle(m_file);
m_file = NULL;
if (m_cache)
return TRUE;
}
}
// If write, then create write cache memory buffer
if (m_readWrite == INIFILE_WRITE)
{
m_cache = new WCHAR[writeCacheSize];
if (m_cache)
return TRUE;
}
}
return FALSE;
}
BOOL INIFileW::close()
{
BOOL success = FALSE;
// If read, then kill the memory cached settings
if (m_readWrite == INIFILE_READ)
{
// Just to be sure, close the settings file again if it's still open for some reason
if (m_file)
{
CloseHandle(m_file);
m_file = NULL;
}
if (m_cache)
{
delete[] m_cache;
m_cache = NULL;
success = TRUE;
}
// Just to be sure, reset section position markers
m_sectionStart = NULL;
m_sectionEnd = NULL;
}
// If write, then commit (write) cached settings file to disk
if (m_readWrite == INIFILE_WRITE)
{
if (m_path && m_cache)
{
m_file = CreateFile(m_path,
GENERIC_WRITE,
0,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (m_file != INVALID_HANDLE_VALUE)
{
DWORD written;
WriteFile(m_file, m_cache, m_cacheWritePos, &written, NULL);
CloseHandle(m_file);
m_file = NULL;
if (written == m_cacheWritePos)
success = TRUE;
}
delete[] m_cache;
m_cache = NULL;
}
}
return success;
}
int INIFileW::GetPrivateProfileString(LPCWSTR section, LPCWSTR key, LPCWSTR def, LPWSTR dest, DWORD size)
{
DWORD copied = 0;
if ((m_cache) && (section && key && dest && size))
{
if (_wcsicmp(section, m_currentSection) != 0)
{
wcsncpy(m_currentSection, section, MAX_SECTIONNAME_LENGTH);
WCHAR headerString[MAX_SECTIONNAME_LENGTH];
ZeroMemory((void *)headerString, sizeof(headerString));
// _snprintf(headerString, MAX_SECTIONNAME_LENGTH, "[%s]\r\n", section);
_snwprintf(headerString, MAX_SECTIONNAME_LENGTH, L"[%s]", section);
// Locate section start in buffer
m_sectionStart = strstri(m_cache, headerString);
// We found the start section
if (m_sectionStart)
{
// Keys start after the "[" + section + "]" header
m_sectionStart += wcslen(section) + 2;
// Locate section end in buffer
m_sectionEnd = wcsstr(m_sectionStart, L"\r\n[");
// If no next section is found, then use end of buffer
if (m_sectionEnd == NULL)
m_sectionEnd = m_cache + wcslen(m_cache);
}
}
if (m_sectionStart && m_sectionEnd)
{
WCHAR keyString[MAX_KEYNAME_LENGTH];
ZeroMemory((void *)keyString, sizeof(keyString));
_snwprintf(keyString, MAX_KEYNAME_LENGTH, L"\r\n%s=", key);
if (LPCWSTR s = strstri(m_sectionStart, keyString))
{
if (s < m_sectionEnd)
{
s += wcslen(keyString);
while (*s && copied < size && *s != '\n' && *s != '\r' && *s != NULL)
{
*dest++ = *s++;
copied++;
}
*dest = 0;
copied++;
}
}
}
}
if (!copied && def)
{
wcsncpy(dest, def, size);
return wcslen(dest);
}
return copied; // Do not include the terminating null character
}
/*================================= END OF FILE =================================*/

37
PlugY/INIfile.h
View File

@ -11,9 +11,7 @@
©1999-2004 Ultrafunk (www.ultrafunk.com) - info@ultrafunk.com
******************************************************************************/
#ifndef _INIFILE_H
#define _INIFILE_H
#pragma once
#include <windows.h>
@ -24,31 +22,48 @@
#define MAX_SECTIONNAME_LENGTH 128
#define MAX_KEYNAME_LENGTH 128
/*****************************************************************************/
class INIFile
{
public:
INIFile();
~INIFile();
BOOL InitReadWrite(char *path, int readWrite, DWORD writeCacheSize);
BOOL InitReadWrite(const char *path, int readWrite, DWORD writeCacheSize);
BOOL close();
int GetPrivateProfileString(const char *section, const char *key, const char *def, char *dest, DWORD size);
BOOL WritePrivateProfileString(char *section, char *key, char *string);
private:
char m_currentSection[MAX_SECTIONNAME_LENGTH];
char *m_cache;
char *m_sectionStart;
char *m_sectionEnd;
int m_readWrite;
char m_path[_MAX_PATH];
HANDLE m_file;
char *m_cache;
DWORD m_cacheWritePos;
char *m_sectionStart;
char *m_sectionEnd;
char m_currentSection[MAX_SECTIONNAME_LENGTH];
};
class INIFileW
{
public:
INIFileW();
~INIFileW();
#endif // _INIFILE_H
BOOL InitReadWrite(const char *path, int readWrite, DWORD writeCacheSize);
BOOL close();
int GetPrivateProfileString(LPCWSTR section, LPCWSTR key, LPCWSTR def, LPWSTR dest, DWORD size);
int GetPrivateProfileStringList(LPCWSTR section, LPCWSTR key, DWORD** codes, LPWSTR** values);
//BOOL WritePrivateProfileString(char *section, char *key, char *string);
LPWSTR m_cache;
private:
WCHAR m_currentSection[MAX_SECTIONNAME_LENGTH];
LPCWSTR m_sectionStart;
LPCWSTR m_sectionEnd;
int m_readWrite;
char m_path[_MAX_PATH];
HANDLE m_file;
DWORD m_cacheWritePos;
};
/*================================= END OF FILE =================================*/

186
PlugY/InfinityStash.cpp
View File

@ -6,13 +6,10 @@
=================================================================*/
#include "common.h"
#include "infinityStash.h"
#include "error.h"
#include "d2functions.h"
#include "updateClient.h"
#include "interface_Stash.h"
#include "common.h"
#define STASH_TAG 0x5453 //"ST"
#define JM_TAG 0x4D4A //"JM"
@ -27,7 +24,7 @@ bool separateHardSoftStash = false;
bool active_sharedGold=false;
char* sharedStashFilename = NULL;
typedef int (*TchangeToSelectedStash)(Unit* ptChar, Stash* newStash, DWORD bIsClient);
typedef int (*TchangeToSelectedStash)(Unit* ptChar, Stash* newStash, DWORD bOnlyItems, DWORD bIsClient);
Unit* firstClassicStashItem(Unit* ptChar)
{
@ -48,6 +45,7 @@ DWORD endStashList(Unit* ptChar, Stash* ptStash)//WORKS
while (stash)
{
if (stash->ptListItem || ((stash == PCPY->currentStash) && firstClassicStashItem(ptChar))) return 0;
if (stash->isIndex || (stash->name != NULL && stash->name[0])) return 0;
stash = stash->nextStash;
}
return 1;
@ -78,10 +76,10 @@ Stash* getLastStash(Stash* ptStash)//WORKS
Stash* newStash(DWORD id)
{
d2_assert( id == 0xFFFFFFFF , "trop de stash", __FILE__, __LINE__);
d2_assert( id == 0xFFFFFFFF , "Too much stash", __FILE__, __LINE__);
Stash* stash = (Stash*)malloc(sizeof(Stash));//D2AllocMem(memPool, sizeof(Stash),__FILE__,__LINE__,0);
d2_assert(!stash , "pb de generation de stash", __FILE__, __LINE__);
d2_assert(!stash , "Error on stash allocation.", __FILE__, __LINE__);
ZeroMemory(stash, sizeof(Stash));
stash->id = id;
@ -131,11 +129,11 @@ Stash* getStash(Unit* ptChar, DWORD isShared, DWORD id)//WORKS
}
int changeToSelectedStash_9(Unit* ptChar, Stash* newStash, DWORD bIsClient)
int changeToSelectedStash_9(Unit* ptChar, Stash* newStash, DWORD bOnlyItems, DWORD bIsClient)
{
if (!newStash) return 0;
log_msg("changeToSelectedStash ID:%d\tshared:%d\tclient:%d\n",newStash->id,newStash->id,bIsClient);
log_msg("changeToSelectedStash ID:%d\tshared:%d\tonlyItems:%d\tclient:%d\n", newStash->id, newStash->isShared, bOnlyItems, bIsClient);
Stash* currentStash = PCPY->currentStash;
if (currentStash == newStash) return 0;
@ -176,7 +174,6 @@ int changeToSelectedStash_9(Unit* ptChar, Stash* newStash, DWORD bIsClient)
}
// add items of new stash
PCPY->currentStash = newStash;
ptItem = newStash->ptListItem;
while (ptItem)
{
@ -184,16 +181,20 @@ int changeToSelectedStash_9(Unit* ptChar, Stash* newStash, DWORD bIsClient)
D2Common10242(PCInventory, D2GetRealItem(ptItem), 1);
ptItem = D2UnitGetNextItem(ptItem);
}
newStash->ptListItem = NULL;
if (bOnlyItems)
newStash->ptListItem = PCPY->currentStash->ptListItem;
else
PCPY->currentStash = newStash;
PCPY->currentStash->ptListItem = NULL;
return 1;
}
int changeToSelectedStash_10(Unit* ptChar, Stash* newStash, DWORD bIsClient)
int changeToSelectedStash_10(Unit* ptChar, Stash* newStash, DWORD bOnlyItems, DWORD bIsClient)
{
if (!newStash) return 0;
log_msg("changeToSelectedStash ID:%d\tshared:%d\tclient:%d\n",newStash->id,newStash->id,bIsClient);
log_msg("changeToSelectedStash ID:%d\tshared:%d\tonlyItems:%d\tclient:%d\n",newStash->id,newStash->isShared, bOnlyItems,bIsClient);
Stash* currentStash = PCPY->currentStash;
if (currentStash == newStash) return 0;
@ -221,14 +222,17 @@ int changeToSelectedStash_10(Unit* ptChar, Stash* newStash, DWORD bIsClient)
}
// add items of new stash
PCPY->currentStash = newStash;
ptItem = newStash->ptListItem;
while (ptItem)
{
D2InvAddItem(PCInventory, ptItem, ptItem->path->x, ptItem->path->y, 0xC, bIsClient, 4);
ptItem = D2UnitGetNextItem(ptItem);
}
newStash->ptListItem = NULL;
if (bOnlyItems)
newStash->ptListItem = PCPY->currentStash->ptListItem;
else
PCPY->currentStash = newStash;
PCPY->currentStash->ptListItem = NULL;
return 1;
}
@ -251,6 +255,15 @@ DWORD loadStash(Unit* ptChar, Stash* ptStash, BYTE data[], DWORD startSize, DWOR
}
curSize += 2;
// Read flags.
int len = strlen((char*)&data[curSize]);
if (*(WORD*)&data[curSize + len + 1] != JM_TAG)
{
ptStash->flags = *(DWORD *)&data[curSize];
curSize += 4;
}
// Read Name
// if (strlen((char *)&data[curSize]) > 0xF)
// *(char *)&data[curSize+0xF] = NULL;
if (strlen((char *)&data[curSize]))
@ -259,6 +272,7 @@ DWORD loadStash(Unit* ptChar, Stash* ptStash, BYTE data[], DWORD startSize, DWOR
strcpy(ptStash->name, (char *)&data[curSize]);
curSize += strlen((char *)&data[curSize]) + 1;
// Read inventory.
DWORD ret = D2LoadInventory(PCGame, ptChar, (saveBitField*)&data[curSize], 0x60, maxSize-curSize, 0, &nbBytesRead);
if (ret) log_msg("loadStash -> D2LoadInventory failed\n");
log_msg("Stash loaded (%d : %s)\n", ptStash->id ,ptStash->name);
@ -267,7 +281,7 @@ DWORD loadStash(Unit* ptChar, Stash* ptStash, BYTE data[], DWORD startSize, DWOR
return ret;
}
DWORD loadStashList(Unit* ptChar, BYTE data[], DWORD maxSize, DWORD* curSize, bool isShared)//WORKS
DWORD loadStashList(Unit* ptChar, BYTE* data, DWORD maxSize, DWORD* curSize, bool isShared)//WORKS
{
DWORD curStash = 0;
Stash* newStash;
@ -278,7 +292,7 @@ DWORD loadStashList(Unit* ptChar, BYTE data[], DWORD maxSize, DWORD* curSize, bo
while (curStash < nbStash)
{
newStash = addStash(ptChar, isShared);
changeToSelectedStash(ptChar, newStash, false);
changeToSelectedStash(ptChar, newStash, 0, false);
DWORD ret = loadStash(ptChar, newStash, data, *curSize, 10000000, curSize);
if (ret) return ret;
curStash++;
@ -311,6 +325,9 @@ void saveStash(Unit* ptChar, Stash* ptStash, BYTE** data, DWORD* maxSize, DWORD*
//write "ST"
SETDATA(WORD, STASH_TAG);
//Write flags.
SETDATA(DWORD, ptStash->flags);
//save name
if (ptStash->name)
{
@ -380,24 +397,27 @@ void updateSelectedStashClient(Unit* ptChar)//WORKS
{
Stash* newStash = PCPY->currentStash;
updateClient(ptChar, UC_SELECT_STASH, newStash->id, newStash->flags, PCPY->flags);
updateClient(ptChar, UC_PAGE_NAME, newStash->name);
}
void setSelectedStashClient(DWORD stashId, DWORD stashFlags, DWORD flags)//WORKS
void setSelectedStashClient(DWORD stashId, DWORD stashFlags, DWORD flags, bool bOnlyItems)//WORKS
{
log_msg("setSelectedStashClient ID:%d, isShared:%d, flags:%08X\n", stashId, stashFlags&1, flags);
log_msg("setSelectedStashClient ID:%d, stashFlags:%d, flags:%08X\n", stashId, stashFlags, flags);
Unit* ptChar = D2GetClientPlayer();
Stash* newStash = getStash(ptChar, stashFlags&1, stashId);
Stash* newStash = getStash(ptChar, (stashFlags & 1) == 1, stashId);
if (!newStash) do
newStash = addStash(ptChar, stashFlags&1);
newStash = addStash(ptChar, (stashFlags & 1) == 1);
while (newStash->id < stashId);
changeToSelectedStash(ptChar, newStash, 1);
newStash->flags = stashFlags;
changeToSelectedStash(ptChar, newStash, bOnlyItems, 1);
PCPY->flags = flags;
}
void selectStash(Unit* ptChar, Stash* newStash)//WORKS
{
changeToSelectedStash(ptChar, newStash, 0);
changeToSelectedStash(ptChar, newStash, 0, 0);
updateSelectedStashClient(ptChar);
}
@ -424,6 +444,112 @@ void toggleToSharedStash(Unit* ptChar)
}
}
void swapStash(Unit* ptChar, Stash* curStash, Stash* swpStash)
{
if (!ptChar || !curStash || !swpStash || curStash == swpStash)
return;
changeToSelectedStash(ptChar, swpStash, 1, 0);
updateClient(ptChar, UC_SELECT_STASH, swpStash->id, swpStash->flags | 4, PCPY->flags);
}
void toggleStash(Unit* ptChar, DWORD page)
{
log_msg("toggle stash page = %u\n", page);
Stash* curStash = PCPY->currentStash;
Stash* swpStash = curStash->isShared ? PCPY->selfStash : PCPY->sharedStash;
swapStash(ptChar, curStash, swpStash);
}
void swapStash(Unit* ptChar, DWORD page, bool toggle)
{
log_msg("swap stash page = %u\n", page);
Stash* curStash = PCPY->currentStash;
Stash* swpStash = curStash->isShared == toggle ? PCPY->selfStash : PCPY->sharedStash;
for (DWORD i = 0; i < page; i++)
{
if (curStash->nextStash == NULL)
addStash(ptChar, swpStash->isShared);
swpStash = swpStash->nextStash;
}
swapStash(ptChar, curStash, swpStash);
}
void insertStash(Unit* ptChar)
{
Stash* curStash = PCPY->currentStash;
Stash* stash = addStash(ptChar, curStash->isShared);
do
{
stash->flags = stash->previousStash->flags;
stash->name = stash->previousStash->name;
stash->ptListItem = stash->previousStash->ptListItem;
stash = stash->previousStash;
} while (stash != curStash);
stash->isIndex = 0;
stash->name = NULL;
stash->ptListItem = NULL;
selectNextStash(ptChar);
}
bool deleteStash(Unit* ptChar)
{
if (firstClassicStashItem(ptChar) != NULL)
return false;
//if (D2InventoryGetFirstItem())
Stash* stash = PCPY->currentStash;
if (stash->nextStash == NULL)
{
stash->isIndex = 0;
stash->name = NULL;
return true;
}
stash->flags = stash->nextStash->flags;
stash->name = stash->nextStash->name;
if (stash->nextStash->ptListItem != NULL)
swapStash(ptChar, stash, stash->nextStash);
stash = stash->nextStash;
do {
stash->flags = stash->nextStash->flags;
stash->name = stash->nextStash->name;
stash->ptListItem = stash->nextStash->ptListItem;
stash = stash->nextStash;
} while (stash->nextStash);
stash->isIndex = 0;
stash->name = NULL;
stash->ptListItem = NULL;
return true;
}
void renameCurrentStash(Unit* ptChar, char* name)
{
log_msg("renameCurrentStash : %08X, %s\n", ptChar, name);
Stash* stash = PCPY->currentStash;
int len = 0;
if (name != NULL)
len = strlen(name);
log_msg("renameCurrentStash : %d\n", len);
if (stash->name)
D2FogMemDeAlloc(stash->name, __FILE__, __LINE__, 0);
log_msg("renameCurrentStash 3\n");
if (len > 0)
{
stash->name = (char *)malloc(len);//D2FogMemAlloc(len,__FILE__,__LINE__,0);
strcpy(stash->name, name);
}
else
stash->name = NULL;
log_msg("renameCurrentStash 4\n");
}
void setCurrentStashIndex(Unit* ptChar, bool isIndex)
{
if (PCPY->currentStash)
PCPY->currentStash->isIndex = isIndex;
updateSelectedStashClient(ptChar);
}
void selectPreviousStash(Unit* ptChar)
{
@ -473,8 +599,15 @@ void selectPreviousIndexStash(Unit* ptChar)
{
selectPreviousStash(ptChar);
Stash* selStash = PCPY->currentStash;
while (selStash && !selStash->isIndex)
selStash = selStash->previousStash;
if (selStash == NULL)
{
selStash = PCPY->currentStash;
while (selStash->previousStash && ((selStash->id + 1) % nbPagesPerIndex != 0))
selStash = selStash->previousStash;
}
if (selStash && (selStash != PCPY->currentStash))
selectStash(ptChar, selStash);
@ -495,12 +628,19 @@ void selectNextIndexStash(Unit* ptChar)
{
selectNextStash(ptChar);
Stash* selStash = PCPY->currentStash;
while (selStash && !selStash->isIndex)
selStash = selStash->nextStash;
if (selStash == NULL)
{
selStash = PCPY->currentStash;
while ((selStash->id + 1) % nbPagesPerIndex != 0)
{
if (!selStash->isShared && (selStash->id >= maxSelfPages)) break;
if (selStash->isShared && (selStash->id >= maxSharedPages)) break;
selStash = selStash->nextStash ? selStash->nextStash : addStash(ptChar, PCPY->showSharedStash);;
}
}
if (selStash && (selStash != PCPY->currentStash))
selectStash(ptChar, selStash);
}

6
PlugY/Interface_Skills.cpp
View File

@ -6,12 +6,10 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "updateServer.h" // Install_UpdateServer()
#include "plugYFiles.h" // Install_PlugYImagesFiles()
#include "skillsPoints.h"
#include "common.h"
#include <stdio.h>
int posXUnassignSkillBtn=-1;
@ -37,7 +35,7 @@ void STDCALL printSkillsPageBtns()
if ( isOnButtonUnassignSkill(D2GetMouseX(),D2GetMouseY()))
{
LPWSTR popupText = getTranslatedString(STR_SKILLS_UNASSIGN);
LPWSTR popupText = getLocalString(STR_SKILLS_UNASSIGN);
D2PrintPopup(popupText, getXSkillBtn()+getLSkillBtn()/2, getYSkillBtn()-getHSkillBtn(), 0, 1);
}
}

30
PlugY/Interface_Stash.cpp
View File

@ -6,13 +6,11 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "interface_Stash.h"
#include "d2functions.h"
#include "updateServer.h"
#include "infinityStash.h"
#include "plugYFiles.h" // Install_PlugYImagesFiles()
#include "common.h"
#include <stdio.h>
static struct
@ -142,31 +140,31 @@ void* STDCALL printBtns()
D2SetFont(1);
if (isOnButtonPreviousStash(mx,my)) {
lpText = getTranslatedString(STR_STASH_PREVIOUS_PAGE);
lpText = getLocalString(STR_STASH_PREVIOUS_PAGE);
D2PrintPopup(lpText, getXPreviousBtn()+getLPreviousBtn()/2, getYPreviousBtn()-getHPreviousBtn(), WHITE, 1);
} else if (isOnButtonNextStash(mx,my)) {
lpText = getTranslatedString(STR_STASH_NEXT_PAGE);
lpText = getLocalString(STR_STASH_NEXT_PAGE);
D2PrintPopup(lpText, getXNextBtn()+getLNextBtn()/2, getYNextBtn()-getHNextBtn(), WHITE, 1);
} else if (active_sharedStash && isOnButtonToggleSharedStash(mx,my)) {
lpText = getTranslatedString(PCPY->showSharedStash ? STR_TOGGLE_TO_PERSONAL : STR_TOGGLE_TO_SHARED);
lpText = getLocalString(PCPY->showSharedStash ? STR_TOGGLE_TO_PERSONAL : STR_TOGGLE_TO_SHARED);
D2PrintPopup(lpText, getXSharedBtn()+getLSharedBtn()/2, getYSharedBtn()-getHSharedBtn(), WHITE, 1);
} else if (isOnButtonPreviousIndexStash(mx,my)) {
swprintf(text, getTranslatedString(STR_STASH_PREVIOUS_INDEX) ,nbPagesPerIndex,nbPagesPerIndex2);
_snwprintf(text, sizeof(text), getLocalString(STR_STASH_PREVIOUS_INDEX) ,nbPagesPerIndex,nbPagesPerIndex2);
D2PrintPopup(text, getXPreviousIndexBtn()+getLPreviousIndexBtn()/2, getYPreviousIndexBtn()-getHPreviousIndexBtn(), 0, 0);
} else if (isOnButtonNextIndexStash(mx,my)) {
swprintf(text, getTranslatedString(STR_STASH_NEXT_INDEX) ,nbPagesPerIndex,nbPagesPerIndex2);
_snwprintf(text, sizeof(text), getLocalString(STR_STASH_NEXT_INDEX) ,nbPagesPerIndex,nbPagesPerIndex2);
D2PrintPopup(text, getXNextIndexBtn()+getLNextIndexBtn()/2, getYNextIndexBtn()-getHNextIndexBtn(), WHITE, 1);
} else if (active_sharedGold && isOnButtonPutGold(mx,my)) {
lpText = getTranslatedString(STR_PUT_GOLD);
lpText = getLocalString(STR_PUT_GOLD);
D2PrintPopup(lpText, getXPutGoldBtn()+getLPutGoldBtn()/2, getYPutGoldBtn()-getHPutGoldBtn(), WHITE, 1);
} else if (active_sharedGold && isOnButtonTakeGold(mx,my)) {
lpText = getTranslatedString(STR_TAKE_GOLD);
lpText = getLocalString(STR_TAKE_GOLD);
D2PrintPopup(lpText, getXTakeGoldBtn()+getLTakeGoldBtn()/2, getYTakeGoldBtn()-getHTakeGoldBtn(), WHITE, 1);
}
@ -275,14 +273,15 @@ void FASTCALL printPageNumber(LPWSTR maxGoldText, DWORD x, DWORD y, DWORD color,
if (PCPY->currentStash)
{
bool isShared = PCPY->currentStash->isShared;
bool isIndex = PCPY->currentStash->isIndex;
DWORD currentId = PCPY->currentStash->id;
if (PCPY->currentStash->name && PCPY->currentStash->name[0])
mbstowcs(popupText,PCPY->currentStash->name,50);//strlen(PCPY->currentStash->name)+1
else swprintf(popupText, getTranslatedString( isShared ? STR_SHARED_PAGE_NUMBER : STR_PERSONAL_PAGE_NUMBER), currentId+1);
D2PrintString(popupText,x,y, isShared?RED:WHITE ,bfalse);
else _snwprintf(popupText, sizeof(popupText), getLocalString( isShared ? STR_SHARED_PAGE_NUMBER : STR_PERSONAL_PAGE_NUMBER), currentId+1);
D2PrintString(popupText, x, y, isShared ? (isIndex ? CRYSTAL_RED : RED) : (isIndex ? BRIGHT_WHITE : WHITE), bfalse);
} else {
swprintf(popupText, getTranslatedString(STR_NO_SELECTED_PAGE));
_snwprintf(popupText, sizeof(popupText), getLocalString(STR_NO_SELECTED_PAGE));
D2PrintString(popupText, x, y, WHITE, bfalse);
}
@ -293,8 +292,7 @@ void FASTCALL printPageNumber(LPWSTR maxGoldText, DWORD x, DWORD y, DWORD color,
{
if (active_sharedGold)
{
swprintf(popupText, L"%s\n", maxGoldText);
swprintf(popupText+wcslen(popupText), getTranslatedString(STR_SHARED_GOLD_QUANTITY), PCPY->sharedGold);
_snwprintf(popupText, sizeof(popupText), L"%s\n%s: %u", maxGoldText, getLocalString(STR_SHARED_GOLD_QUANTITY), PCPY->sharedGold);
DWORD x = D2GetPixelLen(maxGoldText);
DWORD x2 = D2GetPixelLen(popupText) - x;
D2PrintPopup(popupText, RX(0xA8-max(x,x2)/2), RY(0x1CA), WHITE, 0);
@ -467,7 +465,7 @@ void Install_InterfaceStash()
//6FB60FE2 |. E8 99C2F5FF CALL <JMP.&D2Win.#10020>
//6FB2DF62 |. E8 19F3F8FF CALL <JMP.&D2Win.#10064>
//6FB63632 |. E8 299DF5FF CALL <JMP.&D2Win.#10001>
//6FB49A32 |. E8 91F4F6FF CALL <JMP.&D2Win.#10150>
//6FB49A32 |. E8 4739F7FF CALL <JMP.&D2Win.#10150>
//6FB4DE02 |. E8 4739F7FF CALL <JMP.&D2Win.#10076>
// Manage mouse down (Play sound)

11
PlugY/Interface_Stats.cpp
View File

@ -6,12 +6,10 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "plugYFiles.h" // Install_PlugYImagesFiles()
#include "statsPoints.h"
#include "plugYFiles.h" // Install_PlugYImagesFiles()
#include "newInterfaces.h"
#include "common.h"
#include <stdio.h>
static struct
@ -69,12 +67,12 @@ void STDCALL printStatsPageBtns()
D2SetFont(1);
if (D2GetResolution() && isOnPreviousPageBtn(mx,my)) //print popup "previous page"
{
lpText = getTranslatedString(STR_PREVIOUS_PAGE);
lpText = getLocalString(STR_PREVIOUS_PAGE);
D2PrintPopup(lpText, getXPreviousPageBtn()+getLPreviousPageBtn()/2, getYPreviousPageBtn()-getHPreviousPageBtn(), WHITE, 1);
}
else if ( isOnNextPageBtn(mx,my))
{
lpText = getTranslatedString(STR_NEXT_PAGE);
lpText = getLocalString(STR_NEXT_PAGE);
D2PrintPopup(lpText, getXNextPageBtn()+getLNextPageBtn()/2, getYNextPageBtn()-getHNextPageBtn(), WHITE, 1);
}
}
@ -285,6 +283,7 @@ void Install_InterfaceStats()
//6FB703B9 |. 5B POP EBX
//6FB703BA |. 81C4 70030000 ADD ESP,370
//6FB703Ñ0 \. C3 RETN
if ( version_D2Client >= V111 )
{
// Manage mouse down (Play sound)

4
PlugY/Language.cpp
View File

@ -5,10 +5,8 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "language.h"
#include "common.h"
#include <stdio.h>

4
PlugY/LoadPlayerData.cpp
View File

@ -6,12 +6,10 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "infinityStash.h"
#include "extendedSaveFile.h"
#include "sharedSaveFile.h"
#include "common.h"
/************************************ LOADING ***********************************/

323
PlugY/LocalizedStrings.cpp Normal file
View File

@ -0,0 +1,323 @@
/*=================================================================
File created by Yohann NICOLAS.
Localized strings functions.
=================================================================*/
#include "INIfile.h"
#include "LocalizedStrings.h"
#include "common.h"
#include <stdio.h>
LPWSTR StripGender(LPWSTR text)
{
if (text[0] == L' ')
text++;
if (text[0] != L'[')
return text;
text++;
while (text[0] != L']' && text[0] != NULL)
text++;
text++;
return text;
}
LPCWSTR StripGender(LPCWSTR text) { return StripGender((LPWSTR)text); }
///////////////////////////////////////// Get Local Strings /////////////////////////////////////////
struct LocalizedTypeString
{
DWORD code;
LPSTR itemStr;
LPWSTR typeLocalizedString;
} *sLocalizedTypeStrings;
LPWSTR sLocalizedStrings[60];
int nbLocalizedTypeString = 0;
LPWSTR getLocalString(int stringId)
{
return sLocalizedStrings[stringId];
}
LPCWSTR getLocalTypeString(DWORD code)
{
for (int i = 0; i < nbLocalizedTypeString; i++)
{
if (sLocalizedTypeStrings[i].code == code)
{
log_msg("Code=%08X\n", code);
if (sLocalizedTypeStrings[i].itemStr)
return StripGender(D2GetStringFromString(sLocalizedTypeStrings[i].itemStr));
LPWSTR text = StripGender(sLocalizedTypeStrings[i].typeLocalizedString);
if (!text || !text[0])
break;
return text;
}
}
char itemIdx[5];
itemIdx[0] = (code) & 0xFF;
itemIdx[1] = (code >> 8) & 0xFF;
itemIdx[2] = (code >> 16) & 0xFF;
itemIdx[3] = (code >> 24) & 0xFF;
itemIdx[4] = 0;
LPWSTR typeName = StripGender(D2GetStringFromString(itemIdx));
if (wcsstr(typeName, L"-not xlated call ken") == NULL)
return typeName;
static WCHAR itemIdxW[5];
itemIdxW[0] = (code) & 0xFF;
itemIdxW[1] = (code >> 8) & 0xFF;
itemIdxW[2] = (code >> 16) & 0xFF;
itemIdxW[3] = (code >> 24) & 0xFF;
itemIdxW[4] = 0;
return itemIdxW;
}
///////////////////////////////////////// Load Strings /////////////////////////////////////////
#define LOAD(I) loadLocalString(iniFile, I, L#I, key)
#define BUFSIZE 0x400
void loadLocalString(INIFileW *iniFile, int id, LPCWSTR section, LPCWSTR key)
{
WCHAR buffer[BUFSIZE];
iniFile->GetPrivateProfileString(section, key, NULL, buffer, BUFSIZE);
int len = wcslen(buffer);
if (len == 0)
iniFile->GetPrivateProfileString(section, L"ENG", section, buffer, BUFSIZE);
len = wcslen(buffer);
if (len == 0)
{
len = wcslen(section);
sLocalizedStrings[id] = new WCHAR[len + 1];
wcsncpy(sLocalizedStrings[id], section, len);
sLocalizedStrings[id][len] = NULL;
}
if (buffer[0] == L'"' && buffer[len-1] == L'"')
{
sLocalizedStrings[id] = new WCHAR[len - 1];
wcsncpy(sLocalizedStrings[id], buffer + 1, len - 2);
sLocalizedStrings[id][len - 2] = NULL;
}
else
{
sLocalizedStrings[id] = new WCHAR[len + 1];
wcsncpy(sLocalizedStrings[id], buffer, len);
sLocalizedStrings[id][len] = NULL;
}
}
int GetPrivateProfileStringList(LPCWCHAR m_cache, LPCWSTR section, LPCWSTR key)
{
WCHAR sectionString[MAX_SECTIONNAME_LENGTH];
_snwprintf(sectionString, MAX_SECTIONNAME_LENGTH, L"\n[%s", section);
WCHAR keyString[MAX_KEYNAME_LENGTH];
_snwprintf(keyString, MAX_KEYNAME_LENGTH, L"\n%s=", key);
int keyLen = wcslen(keyString);
WCHAR defKeyString[MAX_KEYNAME_LENGTH];
_snwprintf(defKeyString, MAX_KEYNAME_LENGTH, L"\n%s=", L"ENG");
int defKeyLen = wcslen(defKeyString);
WCHAR itemKeyString[MAX_KEYNAME_LENGTH];
_snwprintf(itemKeyString, MAX_KEYNAME_LENGTH, L"\n%s=", L"ITEM");
int itemKeyLen = wcslen(itemKeyString);
// Get nb TYPE sections.
LPCWSTR end;
int nb = 0;
LPCWSTR cur = m_cache;
while ((cur = wcsstr(cur, sectionString)))
{
cur = wcsstr(cur, L"]") + 1;
if (cur == NULL)
continue;
nb++;
}
// Allocation
sLocalizedTypeStrings = new LocalizedTypeString[nb];
// Search next section.
cur = m_cache;
LPCWSTR nextHeader = wcsstr(cur, sectionString);
// Treat next section
int i = 0;
while (nextHeader)
{
cur = nextHeader + wcslen(sectionString);
end = wcsstr(cur, L"]");
if (end == NULL)
break;
nextHeader = wcsstr(end, sectionString);
if (cur == end) { cur++; continue; }
// Fill code
sLocalizedTypeStrings[i].code = (*cur & 0xFF); cur++;
if (cur != end) { sLocalizedTypeStrings[i].code |= (*cur & 0xFF) << 8; cur++; } else sLocalizedTypeStrings[i].code |= ' ' << 8;
if (cur != end) { sLocalizedTypeStrings[i].code |= (*cur & 0xFF) << 16; cur++; } else sLocalizedTypeStrings[i].code |= ' ' << 16;
if (cur != end) { sLocalizedTypeStrings[i].code |= (*cur & 0xFF) << 24; cur++; } else sLocalizedTypeStrings[i].code |= ' ' << 24;
sLocalizedTypeStrings[i].itemStr = NULL;
// Search item key
cur = wcsstr(end + 1, itemKeyString);
if (!(cur == NULL || (nextHeader && cur > nextHeader) || cur[itemKeyLen] == '\r' || cur[itemKeyLen] == '\n' || cur[itemKeyLen] == NULL))// Found
{
cur += itemKeyLen;
end = cur;
while (end[0] != '\r' && end[0] != '\n' && end[0] != NULL)
end++;
sLocalizedTypeStrings[i].itemStr = new char[end - cur + 1];
for (int j = 0; j < end - cur; j++)
sLocalizedTypeStrings[i].itemStr[j] = (char)cur[j];
sLocalizedTypeStrings[i].itemStr[end - cur] = NULL;
i++;
continue;
}
// Search lng key
cur = wcsstr(end + 1, keyString);
if (cur == NULL || (nextHeader && cur > nextHeader) || cur[keyLen] == '\r' || cur[keyLen] == '\n' || cur[keyLen] == NULL)// Not found
{
// Search def key
cur = wcsstr(end + 1, defKeyString);
if (cur == NULL || (nextHeader && cur > nextHeader) || cur[defKeyLen] == '\r' || cur[defKeyLen] == '\n' || cur[defKeyLen] == NULL)// Not found
{
sLocalizedTypeStrings[i].typeLocalizedString = new WCHAR[1];
sLocalizedTypeStrings[i].typeLocalizedString[0] = NULL;
i++;
continue;
}
cur += defKeyLen;
}
else
cur += keyLen;
// Search end value.
end = cur;
while (end[0] && end[0] != '\r' && end[0] != '\n')
end++;
// Strip ""
if (cur[0] == '"' && (end - 1)[0] == '"') { cur++; end--; }
// Strip Gender
if (cur[0] == '[')
{
LPCWSTR tmp = cur;
while (tmp[0] && tmp[0] != ']' && tmp[0] != '\r' && tmp[0] != '\n')
tmp++;
if (tmp[0] == ']')
{
cur = tmp + 1;
end = cur;
while (end[0] && end[0] != '[' && end[0] != '\r' && end[0] != '\n' && end[0] != '"')
end++;
}
}
// Fill value
sLocalizedTypeStrings[i].typeLocalizedString = new WCHAR[end - cur + 1];
_snwprintf(sLocalizedTypeStrings[i].typeLocalizedString, end - cur, cur);
sLocalizedTypeStrings[i].typeLocalizedString[end - cur] = NULL;
i++;
}
return nb;
}
void loadLocalizedStrings(int language)
{
INIFileW *iniFile = new INIFileW;
log_msg("***** Load localized Strings *****\n");
if (!iniFile->InitReadWrite("PlugY\\LocalizedStrings.ini", INIFILE_MPQREAD, 0))//C:\\Jeux\\Blizzard\\D2\\-
{
log_msg("Failed to load LocalizedStrings, default values used.\n\n");
}
LPCWSTR key;
switch (language)
{
case LNG_ENG: key = L"ENG"; break;
case LNG_ESP: key = L"ESP"; break;
case LNG_DEU: key = L"DEU"; break;
case LNG_FRA: key = L"FRA"; break;
case LNG_POR: key = L"POR"; break;
case LNG_ITA: key = L"ITA"; break;
case LNG_JPN: key = L"JPN"; break;
case LNG_KOR: key = L"KOR"; break;
case LNG_SIN: key = L"SIN"; break;
case LNG_CHI: key = L"CHI"; break;
case LNG_POL: key = L"POL"; break;
case LNG_RUS: key = L"RUS"; break;
case LNG_DEF: key = L"ENG"; break;
default: key = L"ENG";
}
// Load localized type string
nbLocalizedTypeString = GetPrivateProfileStringList(iniFile->m_cache, L"TYPE_", key);
// PlugY localized string
LOAD(STR_STATS_UNASSIGN_WITH_LIMIT);
LOAD(STR_STATS_UNASSIGN_WITHOUT_LIMIT);
LOAD(STR_STATS_BASE_MIN);
LOAD(STR_SKILLS_UNASSIGN);
LOAD(STR_STASH_PREVIOUS_PAGE);
LOAD(STR_STASH_NEXT_PAGE);
LOAD(STR_TOGGLE_TO_PERSONAL);
LOAD(STR_TOGGLE_TO_SHARED);
LOAD(STR_STASH_PREVIOUS_INDEX);
LOAD(STR_STASH_NEXT_INDEX);
LOAD(STR_PUT_GOLD);
LOAD(STR_TAKE_GOLD);
LOAD(STR_PERSONAL_PAGE_NUMBER);
LOAD(STR_SHARED_PAGE_NUMBER);
LOAD(STR_NO_SELECTED_PAGE);
LOAD(STR_SHARED_GOLD_QUANTITY);
LOAD(STR_PREVIOUS_PAGE);
LOAD(STR_NEXT_PAGE);
LOAD(STR_ITEM_LEVEL);
// Cube receipt :
LOAD(STR_COW_PORTAL);
LOAD(STR_PANDEMONIUM_PORTAL);
LOAD(STR_PANDEMONIUM_FINAL_PORTAL);
LOAD(STR_FULL);
LOAD(STR_REPAIR);
LOAD(STR_AND);
LOAD(STR_RECHARGE);
LOAD(STR_DESTROY_FILLERS);
LOAD(STR_REMOVE_FILLERS);
LOAD(STR_REGENERATE);
LOAD(STR_UPGRADE_TO_EXCEPTIONAL);
LOAD(STR_UPGRADE_TO_ELITE);
LOAD(STR_ETHERAL);
LOAD(STR_NOT_ETHERAL);
LOAD(STR_NOT_RUNEWORD);
LOAD(STR_BASIC);
LOAD(STR_EXCEPTIONAL);
LOAD(STR_ELITE);
LOAD(STR_CRACKED);
LOAD(STR_NORMAL);
LOAD(STR_SUPERIOR);
LOAD(STR_MAGIC);
LOAD(STR_SET);
LOAD(STR_RARE);
LOAD(STR_UNIQUE);
LOAD(STR_CRAFTED);
LOAD(STR_TEMPERED);
LOAD(STR_ITEM);
LOAD(STR_ITEM_SAME_TYPE);
LOAD(STR_INCLUDE_UPGRADED);
LOAD(STR_WITHOUT_SOCKET);
LOAD(STR_WITH_SOCKETS);
LOAD(STR_WITH_N_SOCKETS);
LOAD(STR_ONLY_N_H);
LOAD(STR_ONLY_HELL);
LOAD(STR_ONLY_CLASS);
iniFile->close();
delete iniFile;
}
/*================================= END OF FILE =================================*/

79
PlugY/LocalizedStrings.h Normal file
View File

@ -0,0 +1,79 @@
/*==============================================
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.
/*============================================*/
#pragma once
#include <windows.h>
void loadLocalizedStrings(int language);
LPWSTR getLocalString(int stringId);
LPCWSTR getLocalTypeString(DWORD code);
LPWSTR StripGender(LPWSTR text);
LPCWSTR StripGender(LPCWSTR text);
enum eStringList
{
STR_STATS_UNASSIGN_WITH_LIMIT = 0,
STR_STATS_UNASSIGN_WITHOUT_LIMIT,
STR_STATS_BASE_MIN,
STR_SKILLS_UNASSIGN,
STR_STASH_PREVIOUS_PAGE,
STR_STASH_NEXT_PAGE,
STR_TOGGLE_TO_PERSONAL,
STR_TOGGLE_TO_SHARED,
STR_STASH_PREVIOUS_INDEX,
STR_STASH_NEXT_INDEX,
STR_PUT_GOLD,
STR_TAKE_GOLD,
STR_PERSONAL_PAGE_NUMBER,
STR_SHARED_PAGE_NUMBER,
STR_NO_SELECTED_PAGE,
STR_SHARED_GOLD_QUANTITY,
STR_PREVIOUS_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_UPGRADE_TO_EXCEPTIONAL,
STR_UPGRADE_TO_ELITE,
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_INCLUDE_UPGRADED,
STR_WITHOUT_SOCKET,
STR_WITH_SOCKETS,
STR_WITH_N_SOCKETS,
STR_ONLY_N_H,
STR_ONLY_HELL,
STR_ONLY_CLASS,
};
/*================================= END OF FILE =================================*/

12
PlugY/MainScreen.cpp
View File

@ -2,14 +2,13 @@
File created by Yohann NICOLAS.
Add support 1.13d by L'Autour.
Add "plugY v1.00" on screen.
Print PlugY version on screen.
=================================================================*/
#include "extraOptions.h"
#include "windowed.h"
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include <stdio.h>
char* versionText = "";
@ -21,6 +20,10 @@ BYTE colorOfPlugYVersion = 4;
DWORD newTextBoxData[]={4,0x237,0x243,0xC8,0x14,0,0,0,0,0,0,2};//type,x,y,l,h,?,?,?,?,?,?,?(0,257,C8,28)
void STDCALL printPlugYVersion(void** childrens, DWORD* sgnNumChildren)
{
if (active_Windowed)
SetWindowedOptions();
if (active_PrintPlugYVersion)
{
char buf[20];
void* textbox = D2CreateTextBox(newTextBoxData);
@ -29,6 +32,7 @@ void STDCALL printPlugYVersion(void** childrens, DWORD* sgnNumChildren)
sprintf(buf, "PlugY %s", PLUGY_VERSION);
D2PrintLineOnTextBox(textbox, buf, colorOfPlugYVersion);
}
}
FCT_ASM ( caller_printPlugYVersion )
POP ESI

3
PlugY/ModifMemory.cpp
View File

@ -5,10 +5,9 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "parameters.h"
#include "modifMemory.h"
#include "d2functions.h"
const char* MSG_ERROR_READ_MEMORY = "Error : Read access missing to patch memory at %08X.\nPlease install a clean version of Lord of Destruction\n\n"
"You can avoid this error message by setting ActiveCkeckMemory=0 in PlugY.ini\n(WARNING: Be careful when you use it, it shouldn't be used by common user)";

390
PlugY/NewInterface_CubeListing.cpp
View File

@ -1,319 +1,273 @@
/*=================================================================
File created by Yohann NICOLAS.
Modified by L'Autour.
Cube Listing functions
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "updateClient.h"
#include "common.h"
#include <stdio.h>
#include <direct.h> // _getcwd()
const char* CUBEFORMULA_FILE = "cube.txt";
const LPWSTR STRING_ERROR= L"***Error***";
const LPCWSTR STRING_ERROR = L"***Error***";
bool InNoSocket;
#define lenbuf 512
#define lenbufi 256
#define BUF &buf[cntbuf], lenbuf-cntbuf
bool InNoSocket; //~~~~~
#define BUF (&buf[*len])
#define PRINT *len += swprintf
/*
6FC9275F |. E8 ECCCFFFF |CALL D2Game.6FC8F450 ; \D2Game.6FC8F450
*/
void printOutput(CubeOutput* output, WCHAR* buf, BYTE* nbOutputs)
void printOutputItem(CubeOutput* output, LPWSTR buf, LPINT len, LPINT nbOutputs)
{
if (!output->outputType)
if (output->outputType == 0)
return;
int cntbuf = wcslen(buf);
if (*nbOutputs)
cntbuf += swprintf(BUF,L" + ");
if (*nbOutputs > 0)
PRINT(BUF, L" + ");
*nbOutputs += 1;
if (output->outputType == 1) {
swprintf(BUF,getTranslatedString(STR_COW_PORTAL));
PRINT(BUF, getLocalString(STR_COW_PORTAL));
return;
} else if (output->outputType == 2) {
swprintf(BUF,getTranslatedString(STR_PANDEMONIUM_PORTAL));
PRINT(BUF, getLocalString(STR_PANDEMONIUM_PORTAL));
return;
} else if (output->outputType == 3) {
swprintf(BUF,getTranslatedString(STR_PANDEMONIUM_FINAL_PORTAL));
PRINT(BUF, getLocalString(STR_PANDEMONIUM_FINAL_PORTAL));
return;
}
if ((output->quantityOrNbSockets>1) && !output->haveSockets)
{
if (output->quantityOrNbSockets == 255)
{cntbuf += swprintf(BUF,getTranslatedString(STR_FULL));}
if (output->quantityOrNbSockets = 255)
PRINT(BUF, L"%s ", getLocalString(STR_FULL));
else
{cntbuf += swprintf(BUF,L"%u ", output->quantityOrNbSockets);}
PRINT(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)
cntbuf += wSprintStringLastGender(BUF, STR_REPAIR);
PRINT(BUF, L"%s ", getLocalString(STR_REPAIR));
if ((output->repair)&&(output->recharge))
cntbuf += wSprintStringLastGender(BUF, STR_AND);
if (output->repair && output->recharge)
PRINT(BUF, L"%s ", getLocalString(STR_AND));
if (output->recharge)
cntbuf += wSprintStringLastGender(BUF, STR_RECHARGE);
if (output->isEthereal)
cntbuf += wSprintStringLastGender(BUF, STR_ETHERAL);
PRINT(BUF, L"%s ", getLocalString(STR_RECHARGE));
if (output->destroysFillers)
cntbuf += wSprintStringLastGender(BUF, STR_DESTROY_FILLERS);
PRINT(BUF, L"%s ", getLocalString(STR_DESTROY_FILLERS));
if (output->removeFillers)
cntbuf += wSprintStringLastGender(BUF, STR_REMOVE_FILLERS);
PRINT(BUF, L"%s ", getLocalString(STR_REMOVE_FILLERS));
if (output->regeneratesUnique)
cntbuf += wSprintStringLastGender(BUF, STR_REGENERATE);
PRINT(BUF, L"%s ", getLocalString(STR_REGENERATE));
if (output->upgradeToExceptional)
cntbuf += wSprintStringLastGender(BUF, STR_EXCEPTIONAL);
PRINT(BUF, L"%s ", getLocalString(STR_UPGRADE_TO_EXCEPTIONAL));
if (output->upgradeToElite)
cntbuf += wSprintStringLastGender(BUF, STR_ELITE);
PRINT(BUF, L"%s ", getLocalString(STR_UPGRADE_TO_ELITE));
if (output->isEthereal)
PRINT(BUF, L"%s ", getLocalString(STR_ETHERAL));
if (output->isSpecificItem) {
if (output->quality == ITEMQUALITY_UNIQUE)
{
UniqueItemsBIN* uniqueItems = SgptDataTables->uniqueItems + output->specificID-1;
LPWSTR string = D2GetStringFromIndex(uniqueItems->uniqueNameId);
cntbuf += swprintf(BUF,string);
PRINT(BUF, D2GetStringFromIndex(uniqueItems->uniqueNameId));
} else if (output->quality == ITEMQUALITY_SET) {
SetItemsBIN* setItems = SgptDataTables->setItems + output->specificID-1;
LPWSTR string = D2GetStringFromIndex(setItems->setNameId);
cntbuf += swprintf(BUF,string);
PRINT(BUF, D2GetStringFromIndex(setItems->setNameId));
} else {
swprintf(BUF,STRING_ERROR);return;
PRINT(BUF,STRING_ERROR);return;
}
} else {
switch (output->quality)
{
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;
case 1:PRINT(BUF, L"%s ", getLocalString(STR_CRACKED));break;
case 2:PRINT(BUF, L"%s ", getLocalString(STR_NORMAL));break;
case 3:PRINT(BUF, L"%s ", getLocalString(STR_SUPERIOR));break;
case 4:PRINT(BUF, L"%s ", getLocalString(STR_MAGIC));break;
case 5:PRINT(BUF, L"%s ", getLocalString(STR_SET));break;
case 6:PRINT(BUF, L"%s ", getLocalString(STR_RARE));break;
case 7:PRINT(BUF, L"%s ", getLocalString(STR_UNIQUE));break;
case 8:PRINT(BUF, L"%s ", getLocalString(STR_CRAFTED));break;
case 9:PRINT(BUF, L"%s ", getLocalString(STR_TEMPERED));break;
}
switch (output->outputType)
{
case 0xFC:
items = D2GetItemsBIN(output->ID);
string = D2GetStringFromIndex(items->NameStr);
cntbuf += swprintf(BUF,string);
{
ItemsBIN* items = D2GetItemsBIN(output->ID);
PRINT(BUF, StripGender(D2GetStringFromIndex(items->NameStr)));
break;
}
case 0xFD:
getTypeUString(output->ID,BUF);
{
ItemTypesBIN* itemTypeData = D2GetItemTypesBIN(output->ID);
if (!itemTypeData)
PRINT(BUF, L"Unknow Item Type");
else
PRINT(BUF, getLocalTypeString(itemTypeData->code));
break;
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)
case 0xFE: PRINT(BUF, L"%s", getLocalString(STR_ITEM)); break;
case 0xFF: PRINT(BUF, L"%s", getLocalString(STR_ITEM_SAME_TYPE)); break;
default: PRINT(BUF, L"%s ", STRING_ERROR); return;
}
}
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));
PRINT(BUF, L" ");
if (output->quantityOrNbSockets >= 1)
PRINT(BUF, getLocalString(STR_WITH_N_SOCKETS), output->quantityOrNbSockets);
// else if (output->quantityOrNbSockets == 1)
// PRINT(BUF, getLocalString(STR_WITH_ONE_SOCKET));
else
PRINT(BUF, getLocalString(STR_WITH_SOCKETS));
}
}
}
void printInput(CubeInput* input, WCHAR* buf, BYTE* nbInputs)//maxsize)
void printInputItem(CubeInput* input, LPWSTR buf, LPINT len, LPINT nbInputs)//maxsize)
{
if (!input->byItemID && !input->byItemTypeID)
return;
int cntbuf = wcslen(buf);
if (*nbInputs)
cntbuf += swprintf(BUF,L" + ");
PRINT(BUF, L" + ");
BYTE nb = input->quantity > 0 ? input->quantity : 1;
*nbInputs += nb;
if (nb > 1)
cntbuf += swprintf(BUF,L"%u ", nb);
PRINT(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)
cntbuf += wSprintStringLastGender(BUF, STR_ETHERAL);
PRINT(BUF, L"%s ", getLocalString(STR_ETHERAL));
if (input->isNotEthereal)
cntbuf += wSprintStringLastGender(BUF, STR_NOT_ETHERAL);
PRINT(BUF, L"%s ", getLocalString(STR_NOT_ETHERAL));
if (input->isNotRuneword)
cntbuf += wSprintStringLastGender(BUF, STR_NOT_RUNEWORD);
PRINT(BUF, L"%s ", getLocalString(STR_NOT_RUNEWORD));
if (input->isBasic)
cntbuf += wSprintStringLastGender(BUF, STR_BASIC);
PRINT(BUF, L"%s ", getLocalString(STR_BASIC));
if (input->isExceptional)
cntbuf += wSprintStringLastGender(BUF, STR_EXCEPTIONAL);
PRINT(BUF, L"%s ", getLocalString(STR_EXCEPTIONAL));
if (input->isElite)
cntbuf += wSprintStringLastGender(BUF, STR_ELITE);
PRINT(BUF, L"%s ", getLocalString(STR_ELITE));
if (input->isSpecificItem) {
if (input->quality == ITEMQUALITY_UNIQUE)
{
UniqueItemsBIN* uniqueItems = SgptDataTables->uniqueItems + input->specificID - 1;
LPWSTR string = D2GetStringFromIndex(uniqueItems->uniqueNameId);
cntbuf += swprintf(BUF,string);
} else if (input->quality == ITEMQUALITY_SET) {
SetItemsBIN* setItems = SgptDataTables->setItems + input->specificID-1;
LPWSTR string = D2GetStringFromIndex(setItems->setNameId);
cntbuf += swprintf(BUF,string);
} else {
swprintf(BUF,STRING_ERROR);return;
PRINT(BUF, StripGender(D2GetStringFromIndex(uniqueItems->uniqueNameId)));
}
} else {
else if (input->quality == ITEMQUALITY_SET) {
SetItemsBIN* setItems = SgptDataTables->setItems + input->specificID - 1;
PRINT(BUF, StripGender(D2GetStringFromIndex(setItems->setNameId)));
}
else {
PRINT(BUF, L"%s ", STRING_ERROR); return;
}
}
else {
switch (input->quality)
{
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;
}/*
case 1:PRINT(BUF, L"%s ", getLocalString(STR_CRACKED)); break;
case 2:PRINT(BUF, L"%s ", getLocalString(STR_NORMAL)); break;
case 3:PRINT(BUF, L"%s ", getLocalString(STR_SUPERIOR)); break;
case 4:PRINT(BUF, L"%s ", getLocalString(STR_MAGIC)); break;
case 5:PRINT(BUF, L"%s ", getLocalString(STR_SET)); break;
case 6:PRINT(BUF, L"%s ", getLocalString(STR_RARE)); break;
case 7:PRINT(BUF, L"%s ", getLocalString(STR_UNIQUE)); break;
case 8:PRINT(BUF, L"%s ", getLocalString(STR_CRAFTED)); break;
case 9:PRINT(BUF, L"%s ", getLocalString(STR_TEMPERED)); break;
}
if (input->byItemTypeID) {
getTypeUString(input->ID,BUF);
} else if (input->ID == 0xFFFF) {
cntbuf += swprintf(BUF,getTranslatedString(STR_ITEM));
} else {
ItemTypesBIN* itemTypeData = D2GetItemTypesBIN(input->ID);
if (!itemTypeData)
PRINT(BUF, L"Unknow Item Type");
else
PRINT(BUF, getLocalTypeString(itemTypeData->code));
}
else if (input->ID == 0xFFFF) {
PRINT(BUF, getLocalString(STR_ITEM));
}
else {
ItemsBIN* items = D2GetItemsBIN(input->ID);
LPWSTR string = D2GetStringFromIndex(items->NameStr);
cntbuf += swprintf(BUF,string);
}*/
cntbuf += swprintf(BUF,itemstr);
PRINT(BUF, StripGender(D2GetStringFromIndex(items->NameStr)));
}
}
if (input->includeUpgradedVersions && !input->isElite)
cntbuf += swprintf(BUF,getTranslatedString(STR_OR_UPGRADED));
PRINT(BUF, L" %s", getLocalString(STR_INCLUDE_UPGRADED));
if (input->haveNoSocket)
{
cntbuf += swprintf(BUF,getTranslatedString(STR_WITHOUT_SOCKET));
InNoSocket = true;//~~~~~
PRINT(BUF, L" %s", getLocalString(STR_WITHOUT_SOCKET));
InNoSocket = true;
}
if (input->haveSockets)
swprintf(BUF,getTranslatedString(STR_WITH_SOCKET));
PRINT(BUF, L" %s", getLocalString(STR_WITH_SOCKETS));
}
DWORD print(CubeMainBIN* curForm, WCHAR* buf, DWORD)//maxsize)
DWORD print(CubeMainBIN* curForm, LPWSTR buf, LPINT len, DWORD)//maxsize)
{
if (!buf || !curForm || !curForm->enabled) return 0;
InNoSocket = false; //~~~~~
BYTE realNbInputs=0;
printInput(&curForm->input1, buf, &realNbInputs);
printInput(&curForm->input2, buf, &realNbInputs);
printInput(&curForm->input3, buf, &realNbInputs);
printInput(&curForm->input4, buf, &realNbInputs);
printInput(&curForm->input5, buf, &realNbInputs);
printInput(&curForm->input6, buf, &realNbInputs);
printInput(&curForm->input7, buf, &realNbInputs);
int cntbuf = wcslen(buf);
InNoSocket = false;
int realNbInputs=0;
printInputItem(&curForm->input1, buf, len, &realNbInputs);
printInputItem(&curForm->input2, buf, len, &realNbInputs);
printInputItem(&curForm->input3, buf, len, &realNbInputs);
printInputItem(&curForm->input4, buf, len, &realNbInputs);
printInputItem(&curForm->input5, buf, len, &realNbInputs);
printInputItem(&curForm->input6, buf, len, &realNbInputs);
printInputItem(&curForm->input7, buf, len, &realNbInputs);
if (realNbInputs != curForm->numinputs)
{
cntbuf += swprintf(BUF,L" *** ERROR : numInputs(%d) != realNbInputs(%d) ***", curForm->numinputs, realNbInputs);
PRINT(BUF, L" *** ERROR : numInputs(%d) != realNbInputs(%d) ***", curForm->numinputs, realNbInputs);
return 1;
}
cntbuf += swprintf(BUF,L" => ");
BYTE realNbOutputs=0;
printOutput(&curForm->output1, buf, &realNbOutputs);
printOutput(&curForm->output2, buf, &realNbOutputs);
printOutput(&curForm->output3, buf, &realNbOutputs);
PRINT(BUF,L" => ");
int realNbOutputs=0;
printOutputItem(&curForm->output1, buf, len, &realNbOutputs);
printOutputItem(&curForm->output2, buf, len, &realNbOutputs);
printOutputItem(&curForm->output3, buf, len, &realNbOutputs);
// if (curForm->ladder)
// cntbuf += swprintf(BUF," [ladder only]");
// sprintf(BUF," [ladder only]");
if (curForm->minDiff == 1)
cntbuf += swprintf(BUF,getTranslatedString(STR_ONLY_N_H));
PRINT(BUF, L" %s", getLocalString(STR_ONLY_N_H));
else if (curForm->minDiff == 2)
cntbuf += swprintf(BUF,getTranslatedString(STR_ONLY_HELL));
PRINT(BUF, L" %s", getLocalString(STR_ONLY_HELL));
if (curForm->playerClass != 0xFF)
{
CharStatsBIN* charStats = D2GetCharStatsBIN(curForm->playerClass);
cntbuf += swprintf(BUF, getTranslatedString(STR_ONLY_CLASS), charStats->name);
PRINT(BUF, L" (");
PRINT(BUF, getLocalString(STR_ONLY_CLASS), charStats->name);
PRINT(BUF, L")");
}
if ((curForm->op>0) && (curForm->op!=28))
cntbuf += swprintf(BUF, L" [op%d(%d,%d)]", curForm->op, curForm->param, curForm->value);
PRINT(BUF, L" [op%d(%d,%d)]", curForm->op, curForm->param, curForm->value);
// if (curForm->version == 100)
// cntbuf += swprintf(BUF, " [expansion only]");
// sprintf(BUF, " [expansion only]");
return 1;
}
@ -323,66 +277,50 @@ DWORD print(CubeMainBIN* curForm, WCHAR* buf, DWORD)//maxsize)
void listAllCubeFormula()
{
log_msg("\n\n********** Print all cube formula **********\n");
char filename[MAX_PATH];
_getcwd( filename, MAX_PATH );
if( filename[strlen(filename)] != '\\')
strcat(filename, "\\");
D2FogGetSavePath(filename, MAX_PATH);
strcat(filename, CUBEFORMULA_FILE);
FILE* file = fopen(filename, "w");
if (!file) return;
log_msg("\n\n********** Print all cube formula **********\n");//SgptDataTables->nbCubemain\n"
int nbLines = D2GetNbCubeMainBIN();//SgptDataTables->nbCubemain
log_msg("nbLines : %d\n",nbLines);
WCHAR buf[lenbuf];
char bufa[lenbuf];
if (D2GetLang() != LNG_DEU)
if (!file)
{
bufa[0] = (char)0xEF;
bufa[1] = (char)0xBB;
bufa[2] = (char)0xBF;
bufa[3] = (char)0x00;
fprintf(file,"%s",bufa);
log_msg("Failed to open save file.\n");
return;
}
int nbLines = D2GetNbCubeMainBIN();
log_msg("nbLines : %d\n",nbLines);
WCHAR buf[512];
// Print BOM UTF-16
//buf[0] = 0xFEFF;
//buf[1] = NULL;
//write(buf, 2, 2, file);
// Print BOM UTF-8
//printf(file, "");
int len = 0;
int nbCubeReceipt = 0;
for (int i=0; i<nbLines; i++)
{
buf[0]=NULL;
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);
DWORD res = 1;
len = 0;
buf[len] = NULL;
res = print(D2GetCubeMainBIN(i), buf, &len, 512);
//wcstombs(bufa, buf, 1024);
if (res)
{
nbCubeReceipt++;
fwprintf(file, L"%3u: %s\n", i, buf);
}
}
fclose(file);
log_msg("\n********** Printing over **********\n\n");
/* _getcwd( filename, MAX_PATH );
if( filename[strlen(filename)] != '\\')
strcat(filename, "\\");
strcat(filename, "tmp.txt");
file = fopen(filename, "w");
ItemStatCostBIN* itemStatCost;
LPWSTR lpText;
for (i=0;i<=STATS_ITEM_CHARGED_SKILL_MOD;i++)
{
buf[0]='\0';
itemStatCost = D2GetItemStatCostBIN(i);
lpText = D2GetStringFromIndex(itemStatCost->descstrpos);
wcstombs(&buf[0],lpText,100);
strcat(buf,"\t - \t");
lpText = D2GetStringFromIndex(itemStatCost->descstrneg);
wcstombs(&buf[strlen(buf)],lpText,100);
fprintf(file,"%03d %03X \t- %s\n",i,i,buf);
}
fclose(file);*/
}
/*================================= END OF FILE =================================*/

11
PlugY/NewInterface_Runewords.cpp
View File

@ -5,13 +5,11 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "updateServer.h" // Install_UpdateServer()
#include "plugYFiles.h" // Install_PlugYImagesFiles()
#include "statsPoints.h"
#include "newInterfaces.h"
#include "common.h"
#include <stdio.h>
#define NB_RUNES_PER_PAGE 25
@ -74,9 +72,10 @@ void printRuneword(RunesBIN* runesData, DWORD pos)
{
WORD type = runesData->Itypes[numItype];
if (!type) break;
getTypeUString(type,temp,50);
ItemTypesBIN* itemTypeData = D2GetItemTypesBIN(type);
LPCWSTR typeName = getLocalTypeString(itemTypeData->code);
if (numItype) wcscat(typesList,L"/");
wcscat(typesList,temp);
wcscat(typesList, typeName);
numItype++;
}
nbPixel = D2GetPixelLen(typesList);
@ -200,7 +199,7 @@ void STDCALL printRunewordsPage()
}
else if (isOnNextPageBtn(x,y)) // print popup "next page"
{
lpText = getTranslatedString(STR_NEXT_PAGE);
lpText = getLocalString(STR_NEXT_PAGE);
D2PrintPopup(lpText, getXNextPageBtn()+getLNextPageBtn()/2, getYNextPageBtn()-getHNextPageBtn(), WHITE, 1);
}
}

8
PlugY/NewInterface_Stats.cpp
View File

@ -5,13 +5,11 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "updateServer.h" // Install_UpdateServer()
#include "plugYFiles.h" // Install_PlugYImagesFiles()
#include "statsPoints.h"
#include "newInterfaces.h"
#include "common.h"
#include <stdio.h>
@ -573,12 +571,12 @@ if (version_D2Client <= V110)
}
else if (isOnPreviousPageBtn(x,y)) //print popup "previous page"
{
lpText = getTranslatedString(STR_PREVIOUS_PAGE);
lpText = getLocalString(STR_PREVIOUS_PAGE);
D2PrintPopup(lpText, getXPreviousPageBtn()+getLPreviousPageBtn()/2, getYPreviousPageBtn()-getHPreviousPageBtn(), WHITE, 1);
}
else if (isOnNextPageBtn(x,y)) //print popup "next page"
{
lpText = getTranslatedString(STR_NEXT_PAGE);
lpText = getLocalString(STR_NEXT_PAGE);
D2PrintPopup(lpText, getXNextPageBtn()+getLNextPageBtn()/2, getYNextPageBtn()-getHNextPageBtn(), WHITE, 1);
}
else if (isOnRect(x, y, 0xAD, 0x137, 0x15, 0x13))

8
PlugY/NewInterface_StatsPageTwo.cpp
View File

@ -5,13 +5,11 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "updateServer.h"
#include "plugYFiles.h"
#include "statsPoints.h"
#include "newInterfaces.h"
#include "common.h"
#include <stdio.h>
#define getXCloseBtn() RX(0x110)
@ -227,12 +225,12 @@ void STDCALL printNewStatsPageTwo(int currentPage)
}
else if (isOnPreviousPageBtn(mx,my)) //print popup "previous page"
{
lpText = getTranslatedString(STR_PREVIOUS_PAGE);
lpText = getLocalString(STR_PREVIOUS_PAGE);
D2PrintPopup(lpText, getXPreviousPageBtn()+getLPreviousPageBtn()/2, getYPreviousPageBtn()-getHPreviousPageBtn(), WHITE, 1);
}
else if (isOnNextPageBtn(mx,my)) //print popup "next page"
{
lpText = getTranslatedString(STR_NEXT_PAGE);
lpText = getLocalString(STR_NEXT_PAGE);
D2PrintPopup(lpText, getXNextPageBtn()+getLNextPageBtn()/2, getYNextPageBtn()-getHNextPageBtn(), WHITE, 1);
}
}

7
PlugY/NewInterfaces.cpp
View File

@ -6,17 +6,15 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "plugYFiles.h" // Install_PlugYImagesFiles()
#include "globalVariable.h"
#include "updateServer.h" // Install_UpdateServer()
#include "plugYFiles.h" // Install_PlugYImagesFiles()
#include "interface_Stats.h"// Install_InterfaceStats()
#include "newInterfaces.h"
#include "newInterface_Stats.h"
#include "newInterface_StatsPageTwo.h"
#include "newInterface_Runewords.h"
#include "common.h"
#include <stdio.h>
bool active_newInterfaces=false;
@ -70,7 +68,6 @@ void STDCALL printCustomPage()
DWORD STDCALL mouseCustomPageLeftDown(sWinMessage* msg)
{
if(onRealm) return -1;
if ( (selectedPage > 0) && (selectedPage<=lastPage) )
return mouseNewStatsPageTwoLeftDown(msg);

2
PlugY/OthersFeatures.cpp
View File

@ -6,8 +6,6 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
bool active_othersFeatures = false;

113
PlugY/Parameters.cpp
View File

@ -5,15 +5,12 @@
=================================================================*/
// Core Class Headers
#include "error.h"
#include "INIfile.h"
#include "parameters.h" // loadParameters()
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "common.h"
#include "error.h"
#include "parameters.h" // loadParameters()
#include "D2functions.h"
#include "INIfile.h"
#define PARAMETERS_FILENAME "PlugY.ini"
@ -37,7 +34,7 @@
#include "extraOptions.h"
#include "commands.h"
#include "language.h"
extern bool displayGreenSetItemIncludeSharedStash;
#include "windowed.h"
char* modDataDirectory = "PlugY";
@ -60,6 +57,18 @@ const char* S_active_CheckMemory = "ActiveCheckMemory";
const char* S_active_Commands = "ActiveCommands";
const char* S_active_othersFeatures = "ActiveAllOthersFeatures";
const char* S_WINDOWED = "WINDOWED";
const char* S_ActiveWindowed = "ActiveWindowed";
const char* S_RemoveBorder = "RemoveBorder";
const char* S_WindowOnTop = "WindowOnTop";
const char* S_Maximized = "Maximized";
const char* S_SetWindowPos = "SetWindowPos";
const char* S_X = "X";
const char* S_Y = "Y";
const char* S_Width = "Width";
const char* S_Height = "Height";
const char* S_LockMouseOnStartup = "LockMouseOnStartup";
const char* S_LANGUAGE = "LANGUAGE";
const char* S_active_ChangeLanguage = "ActiveChangeLanguage";
const char* S_selectedLanguage = "SelectedLanguage";
@ -85,6 +94,7 @@ const char* S_maxSelfPages = "MaxPersonnalPages";
const char* S_nbPagesPerIndex = "NbPagesPerIndex";
const char* S_nbPagesPerIndex2 = "NbPagesPerIndex2";
const char* S_active_sharedStash = "ActiveSharedStash";
const char* S_openSharedStashOnLoading = "OpenSharedStashOnLoading";
const char* S_maxSharedPages = "MaxSharedPages";
const char* S_sharedStashFilename = "SharedStashFilename";
const char* S_separateHardSoftStash = "SeparateHardcoreStash";
@ -167,6 +177,10 @@ const char* S_USER = "USER:\t";
const char* S_FIXED = "FIXED:\t";
// Convert 4 char code in a DWORD code
#define BIN(A,B,C,D) ((DWORD)A) + (((DWORD)B) << 8) + (((DWORD)C) << 16) + (((DWORD)D) << 24)
#define GET_PRIVATE_PROFILE_STRING(S,F,D)\
if (!iniFixedFile->GetPrivateProfileString(S, F, NULL, buffer, maxSize)) \
if (!iniFile->GetPrivateProfileString(S, F, NULL, buffer, maxSize)) \
@ -183,7 +197,6 @@ if (!iniDefaultFile->GetPrivateProfileString(S, F, D, buffer, maxSize)) \
else log_msg(S_DEFAULT); \
else log_msg(S_USER)
#define GET_PRIVATE_PROFILE_STRING3(S,F,D)\
if (!iniFile->GetPrivateProfileString(S, F, NULL, buffer, maxSize)) \
if (!iniFixedFile->GetPrivateProfileString(S, F, NULL, buffer, maxSize)) \
@ -210,7 +223,7 @@ void init_General(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFi
{
GET_PRIVATE_PROFILE_STRING(S_GENERAL, S_active_DisableBattleNet, "0");
active_DisableBattleNet = atoi(buffer) != 0;
log_msg("active_DisableBattleNet\t\t\t\t= %d\n", active_DisableBattleNet);
log_msg("active_DisableBattleNet\t\t= %d\n", active_DisableBattleNet);
GET_PRIVATE_PROFILE_STRING(S_GENERAL, S_active_logFile, "0");
active_logFile = atoi(buffer)+1;
@ -242,6 +255,51 @@ void init_General(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFi
log_msg("\n");
}
void init_Windowed(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize)
{
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_ActiveWindowed, "0");
active_Windowed = atoi(buffer) != 0;
log_msg("active_Windowed\t\t\t\t= %d\n", active_Windowed);
if (active_Windowed)
{
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_RemoveBorder, "0");
active_RemoveBorder = atoi(buffer) != 0;
log_msg("active_RemoveBorder\t\t\t= %d\n", active_RemoveBorder);
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_WindowOnTop, "0");
active_WindowOnTop = atoi(buffer) != 0;
log_msg("active_WindowOnTop\t\t\t= %d\n", active_WindowOnTop);
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_Maximized, "0");
active_Maximized = atoi(buffer) != 0;
log_msg("active_Maximized\t\t\t= %d\n", active_Maximized);
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_SetWindowPos, "0");
active_SetWindowPos = atoi(buffer) != 0;
log_msg("active_MoveAndResizeWindow\t= %d\n", active_SetWindowPos);
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_X, "0");
windowedX = atoi(buffer);
log_msg("windowedX\t\t\t\t\t= %d\n", windowedX);
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_Y, "0");
windowedY = atoi(buffer);
log_msg("windowedY\t\t\t\t\t= %d\n", windowedY);
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_Width, "0");
windowedWidth = atoi(buffer);
log_msg("windowedWidth\t\t\t\t= %d\n", windowedWidth);
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_Height, "0");
windowedHeight = atoi(buffer);
log_msg("windowedHeight\t\t\t\t= %d\n", windowedHeight);
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_LockMouseOnStartup, "0");
active_LockMouseOnStartup = atoi(buffer) != 0;
log_msg("active_LockMouseOnStartup\t= %d\n\n", active_LockMouseOnStartup);
}
}
void init_ActiveLanguage(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize)
{
GET_PRIVATE_PROFILE_STRING(S_LANGUAGE, S_active_ChangeLanguage, "0");
@ -251,7 +309,7 @@ void init_ActiveLanguage(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDe
if (active_ChangeLanguage)
{
GET_PRIVATE_PROFILE_STRING(S_LANGUAGE, S_selectedLanguage, "ENG");
strupr(buffer);
_strupr(buffer);
switch (*(DWORD*)buffer)
{
case BIN('E','N','G',0) : selectedLanguage=LNG_ENG;break;
@ -281,7 +339,7 @@ void init_ActiveLanguage(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDe
if (active_LanguageManagement)
{
GET_PRIVATE_PROFILE_STRING(S_LANGUAGE, S_defaultLanguage, "ENG");
strupr(buffer);
_strupr(buffer);
switch (*(DWORD*)buffer)
{
case BIN('E','N','G',0) : defaultLanguage=LNG_ENG;break;
@ -302,7 +360,7 @@ void init_ActiveLanguage(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDe
GET_PRIVATE_PROFILE_STRING(S_LANGUAGE, S_availableLanguages, "ENG|ESP|DEU|FRA|POR|ITA|JPN|KOR|SIN|CHI|POL|RUS");
availableLanguages.all = 0;
strupr(buffer);
_strupr(buffer);
char* curString = strtok(buffer,"|");
while (curString)
{
@ -392,11 +450,24 @@ void init_VersionText(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefau
{
switch(version_D2Game)
{
case V109b: strcpy(buffer, "v 1.09b");break;
case V109d: strcpy(buffer, "v 1.09d");break;
//case V110: strcpy(buffer, "v 1.10");break;
//case V111: strcpy(buffer, "v 1.11");break;
case V111b: strcpy(buffer, "v 1.11b");break;
//case V107: //"v 1.07"
//case V108: //"v 1.08"
//case V109: //"v 1.09"
case V109b: //"v 1.09"
case V109d: //"v 1.09"
//case V110: //"v 1.10"
//case V111: //"v 1.11"
case V111b: //"v 1.11"
//case V112: //"v 1.12"
case V113c: //"v 1.13"
case V113d: //"v 1.13"
case V114a: //"v 1.14"
//case V114b: //"v 1.14b"
//case V114c: //"v 1.14c"
//case V114d: //"v 1.14d"
strcpy(buffer, "v ");
strcat(buffer, GetVersionString(version_D2Game));
break;
default:
active_VersionTextChange=0;
}
@ -415,7 +486,6 @@ void init_VersionText(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefau
active_PrintPlugYVersion = atoi(buffer) != 0;
log_msg("active_PrintPlugYVersion\t= %u\n", active_PrintPlugYVersion);
if (active_PrintPlugYVersion)
{
GET_PRIVATE_PROFILE_STRING(S_MAIN_SCREEN, S_colorOfPlugYVersion, "4");
@ -494,6 +564,10 @@ void init_Stash(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile
if (active_sharedStash)
{
GET_PRIVATE_PROFILE_STRING(S_STASH, S_openSharedStashOnLoading, "0");
openSharedStashOnLoading = atoi(buffer) != 0;
log_msg("openSharedStashOnLoading\t\t= %u\n", openSharedStashOnLoading);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_maxSharedPages, "0");
maxSharedPages = atoi(buffer) - 1;
log_msg("maxSharedPages\t\t\t\t= %u\n", maxSharedPages);
@ -757,7 +831,7 @@ void loadParameters()
INIFile *iniFixedFile = new INIFile;
INIFile *iniDefaultFile = new INIFile;
srand(time(NULL));
srand((UINT)time(NULL));
log_msg("***** PARAMETERS *****\n");
if (iniFile->InitReadWrite(PARAMETERS_FILENAME, INIFILE_READ, 0))
@ -783,6 +857,7 @@ void loadParameters()
if (active_plugin)
{
init_General(iniFile, iniFixedFile, iniDefaultFile, buffer, BUFSIZE);
init_Windowed(iniFile, iniFixedFile, iniDefaultFile, buffer, BUFSIZE);
init_ActiveLanguage(iniFile, iniFixedFile, iniDefaultFile, buffer,BUFSIZE);
init_SavePath(iniFile, iniFixedFile, iniDefaultFile, buffer, BUFSIZE);
init_VersionText(iniFile, iniFixedFile, iniDefaultFile, buffer, BUFSIZE);

12
PlugY/PlayerCustomData.cpp
View File

@ -7,15 +7,15 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "updateClient.h"
#include "d2functions.h"
#include "infinityStash.h"
#include "savePlayerData.h" //Install_SavePlayerData()
#include "loadPlayerData.h" //Install_LoadPlayerData()
#include "common.h"
bool active_PlayerCustomData = true;
bool openSharedStashOnLoading = false;
/*********************************** UPDATING ***********************************/
@ -72,7 +72,11 @@ void STDCALL updateClientPlayerOnLoading(Unit* ptChar)
log_msg("--- Start updateClientPlayerOnLoading ---\n");
if (PCGame->isLODGame)
{
selectStash(ptChar, PCPY->selfStash);
//selectStash(ptChar, openSharedStashOnLoading ? PCPY->sharedStash : PCPY->selfStash);
if (openSharedStashOnLoading)
toggleToSharedStash(ptChar);
else
toggleToSelfStash(ptChar);
log_msg("End update client on loading.\n\n");
}
updateClient(ptChar, UC_SHARED_GOLD, PCPY->sharedGold, 0, 0);

BIN
PlugY/PlugY.aps
View File

Binary file not shown.

13
PlugY/PlugY.cpp
View File

@ -5,18 +5,23 @@
=================================================================*/
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
#include <windows.h>
BOOL WINAPI DllMain(HANDLE /*hModule*/, DWORD dwReason, LPVOID /*lpReserved*/)
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch(dwReason)
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return true;
return TRUE;
}
/*================================= END OF FILE =================================*/

BIN
PlugY/PlugY.rc
View File

Binary file not shown.

15
PlugY/PlugY.sln
View File

@ -1,6 +1,7 @@
Microsoft Visual Studio Solution File, Format Version 9.00
# Visual Studio 2005
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PlugY", "PlugY.vcproj", "{F5E47DA0-4D85-41E4-954D-29237DF8AFCB}"

Microsoft Visual Studio Solution File, Format Version 10.00
# Visual C++ Express 2008
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PlugY", "PlugY.vcproj", "{EB63DF4E-A019-4522-A140-9E8C7350B331}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
@ -8,10 +9,10 @@ Global
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{F5E47DA0-4D85-41E4-954D-29237DF8AFCB}.Debug|Win32.ActiveCfg = Debug|Win32
{F5E47DA0-4D85-41E4-954D-29237DF8AFCB}.Debug|Win32.Build.0 = Debug|Win32
{F5E47DA0-4D85-41E4-954D-29237DF8AFCB}.Release|Win32.ActiveCfg = Release|Win32
{F5E47DA0-4D85-41E4-954D-29237DF8AFCB}.Release|Win32.Build.0 = Release|Win32
{EB63DF4E-A019-4522-A140-9E8C7350B331}.Debug|Win32.ActiveCfg = Debug|Win32
{EB63DF4E-A019-4522-A140-9E8C7350B331}.Debug|Win32.Build.0 = Debug|Win32
{EB63DF4E-A019-4522-A140-9E8C7350B331}.Release|Win32.ActiveCfg = Release|Win32
{EB63DF4E-A019-4522-A140-9E8C7350B331}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

BIN
PlugY/PlugY.suo
View File

Binary file not shown.

261
PlugY/PlugY.vcproj
View File

@ -1,11 +1,12 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Version="9,00"
Name="PlugY"
ProjectGUID="{F5E47DA0-4D85-41E4-954D-29237DF8AFCB}"
ProjectGUID="{EB63DF4E-A019-4522-A140-9E8C7350B331}"
RootNamespace="PlugY"
Keyword="ExtStoredProcProj"
Keyword="Win32Proj"
TargetFrameworkVersion="196613"
>
<Platforms>
<Platform
@ -17,10 +18,9 @@
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="Debug"
IntermediateDirectory="Debug"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC70.vsprops"
CharacterSet="2"
>
<Tool
@ -37,19 +37,16 @@
/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="_DEBUG"
MkTypLibCompatible="false"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_WINDOWS;_DEBUG;_USRDLL"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_CRT_NON_CONFORMING_SWPRINTFS;_CRT_SECURE_NO_WARNINGS;_USRDLL;PLUGY_EXPORTS"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="4"
/>
<Tool
@ -57,15 +54,12 @@
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1033"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="opends60.lib"
LinkIncremental="2"
GenerateDebugInformation="true"
SubSystem="2"
@ -89,21 +83,17 @@
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="Release"
IntermediateDirectory="Release"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC70.vsprops"
UseOfMFC="0"
CharacterSet="2"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
@ -119,42 +109,31 @@
/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="false"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
OmitFramePointers="true"
PreprocessorDefinitions="WIN32;_WINDOWS;NDEBUG;_USRDLL;_CRT_NON_CONFORMING_SWPRINTFS;_CRT_SECURE_NO_DEPRECATE;_CRT_ NONSTDC_NO_DEPRECATE;_USE_32BIT_TIME_T"
StringPooling="false"
ExceptionHandling="0"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableIntrinsicFunctions="true"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_CRT_NON_CONFORMING_SWPRINTFS;_CRT_SECURE_NO_WARNINGS;_USRDLL;PLUGY_EXPORTS"
RuntimeLibrary="2"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="0"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="opends60.lib"
OutputFile="$(OutDir)\$(ProjectName).dll"
LinkIncremental="1"
GenerateDebugInformation="false"
GenerateDebugInformation="true"
SubSystem="2"
OptimizeReferences="2"
EnableCOMDATFolding="2"
@ -178,12 +157,9 @@
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCWebDeploymentTool"
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="copy $(TargetPath) &quot;..\PlugYInstaller\PlugY.dll&quot;&#x0D;&#x0A;copy $(TargetPath) &quot;D:\Games\Diablo II\PlugY.dll&quot;&#x0D;&#x0A;&#x0D;&#x0A;"
CommandLine="copy &quot;$(TargetPath)&quot; &quot;..\PlugYInstaller\PlugY.dll&quot;"
/>
</Configuration>
</Configurations>
@ -191,179 +167,184 @@
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;odl;idl;hpj;bat;asm"
Name="Fichiers sources"
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath="BigStash.cpp"
RelativePath=".\BigStash.cpp"
>
</File>
<File
RelativePath="ClientSaveFile.cpp"
RelativePath=".\ClientSaveFile.cpp"
>
</File>
<File
RelativePath="Commands.cpp"
RelativePath=".\Commands.cpp"
>
</File>
<File
RelativePath="Common.cpp"
RelativePath=".\Common.cpp"
>
</File>
<File
RelativePath="CustomLibraries.cpp"
RelativePath=".\CustomLibraries.cpp"
>
</File>
<File
RelativePath="D2functions.cpp"
RelativePath=".\D2functions.cpp"
>
</File>
<File
RelativePath="D2wrapper.cpp"
RelativePath=".\D2wrapper.cpp"
>
</File>
<File
RelativePath="Error.cpp"
RelativePath=".\Error.cpp"
>
</File>
<File
RelativePath="ExtendedSaveFile.cpp"
RelativePath=".\ExtendedSaveFile.cpp"
>
</File>
<File
RelativePath="ExtraOptions.cpp"
RelativePath=".\ExtraOptions.cpp"
>
</File>
<File
RelativePath="GlobalVariable.cpp"
RelativePath=".\GlobalVariable.cpp"
>
</File>
<File
RelativePath="InfinityStash.cpp"
RelativePath=".\InfinityStash.cpp"
>
</File>
<File
RelativePath="INIfile.cpp"
RelativePath=".\INIfile.cpp"
>
</File>
<File
RelativePath="Interface_Skills.cpp"
RelativePath=".\Interface_Skills.cpp"
>
</File>
<File
RelativePath="Interface_Stash.cpp"
RelativePath=".\Interface_Stash.cpp"
>
</File>
<File
RelativePath="Interface_Stats.cpp"
RelativePath=".\Interface_Stats.cpp"
>
</File>
<File
RelativePath="Language.cpp"
RelativePath=".\Language.cpp"
>
</File>
<File
RelativePath="LoadPlayerData.cpp"
RelativePath=".\LoadPlayerData.cpp"
>
</File>
<File
RelativePath="MainScreen.cpp"
RelativePath=".\LocalizedStrings.cpp"
>
</File>
<File
RelativePath="ModifMemory.cpp"
RelativePath=".\MainScreen.cpp"
>
</File>
<File
RelativePath="NewInterface_CubeListing.cpp"
RelativePath=".\ModifMemory.cpp"
>
</File>
<File
RelativePath="NewInterface_Runewords.cpp"
RelativePath=".\NewInterface_CubeListing.cpp"
>
</File>
<File
RelativePath="NewInterface_Stats.cpp"
RelativePath=".\NewInterface_Runewords.cpp"
>
</File>
<File
RelativePath="NewInterface_StatsPageTwo.cpp"
RelativePath=".\NewInterface_Stats.cpp"
>
</File>
<File
RelativePath="NewInterfaces.cpp"
RelativePath=".\NewInterface_StatsPageTwo.cpp"
>
</File>
<File
RelativePath="OthersFeatures.cpp"
RelativePath=".\NewInterfaces.cpp"
>
</File>
<File
RelativePath="Parameters.cpp"
RelativePath=".\OthersFeatures.cpp"
>
</File>
<File
RelativePath="PlayerCustomData.cpp"
RelativePath=".\Parameters.cpp"
>
</File>
<File
RelativePath="PlugY.cpp"
RelativePath=".\PlayerCustomData.cpp"
>
</File>
<File
RelativePath="PlugY.rc"
RelativePath=".\PlugY.cpp"
>
</File>
<File
RelativePath="PlugYFiles.cpp"
RelativePath=".\PlugYFiles.cpp"
>
</File>
<File
RelativePath="SavePath.cpp"
RelativePath=".\SavePath.cpp"
>
</File>
<File
RelativePath="SavePlayerData.cpp"
RelativePath=".\SavePlayerData.cpp"
>
</File>
<File
RelativePath="SharedSaveFile.cpp"
RelativePath=".\SharedSaveFile.cpp"
>
</File>
<File
RelativePath="SkillPerLevelUp.cpp"
RelativePath=".\SkillPerLevelUp.cpp"
>
</File>
<File
RelativePath="SkillsPoints.cpp"
RelativePath=".\SkillsPoints.cpp"
>
</File>
<File
RelativePath="StatPerLevelUp.cpp"
RelativePath=".\StatPerLevelUp.cpp"
>
</File>
<File
RelativePath="StatsPoints.cpp"
RelativePath=".\StatsPoints.cpp"
>
</File>
<File
RelativePath="UberQuest.cpp"
RelativePath=".\UberQuest.cpp"
>
</File>
<File
RelativePath="UpdateClient.cpp"
RelativePath=".\UpdateClient.cpp"
>
</File>
<File
RelativePath="UpdateServer.cpp"
RelativePath=".\UpdateServer.cpp"
>
</File>
<File
RelativePath="WorldEvent.cpp"
RelativePath=".\Windowed.cpp"
>
</File>
<File
RelativePath=".\WorldEvent.cpp"
>
</File>
<Filter
Name="Coomons"
Name="Commons"
>
<File
RelativePath="..\Commons\VersionInfo.cpp"
@ -372,175 +353,188 @@
</Filter>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc"
Name="Fichiers d&apos;en-tête"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath="bigStash.h"
RelativePath=".\bigStash.h"
>
</File>
<File
RelativePath="clientSaveFile.h"
RelativePath=".\clientSaveFile.h"
>
</File>
<File
RelativePath="commands.h"
RelativePath=".\commands.h"
>
</File>
<File
RelativePath="common.h"
RelativePath=".\common.h"
>
</File>
<File
RelativePath="customData.h"
RelativePath=".\customData.h"
>
</File>
<File
RelativePath="customLibraries.h"
RelativePath=".\customLibraries.h"
>
</File>
<File
RelativePath="d2functions.h"
RelativePath=".\d2functions.h"
>
</File>
<File
RelativePath="error.h"
RelativePath=".\d2wrapper.h"
>
</File>
<File
RelativePath="extendedSaveFile.h"
RelativePath=".\error.h"
>
</File>
<File
RelativePath="extraOptions.h"
RelativePath=".\extendedSaveFile.h"
>
</File>
<File
RelativePath="globalVariable.h"
RelativePath=".\extraOptions.h"
>
</File>
<File
RelativePath="infinityStash.h"
RelativePath=".\globalVariable.h"
>
</File>
<File
RelativePath="INIfile.h"
RelativePath=".\infinityStash.h"
>
</File>
<File
RelativePath="interface_Skills.h"
RelativePath=".\INIfile.h"
>
</File>
<File
RelativePath="interface_Stash.h"
RelativePath=".\interface_Skills.h"
>
</File>
<File
RelativePath="interface_Stats.h"
RelativePath=".\interface_Stash.h"
>
</File>
<File
RelativePath="language.h"
RelativePath=".\interface_Stats.h"
>
</File>
<File
RelativePath="loadPlayerData.h"
RelativePath=".\language.h"
>
</File>
<File
RelativePath=".\LocaleStrings.h"
RelativePath=".\loadPlayerData.h"
>
</File>
<File
RelativePath="mainScreen.h"
RelativePath=".\LocalizedStrings.h"
>
</File>
<File
RelativePath="modifMemory.h"
RelativePath=".\mainScreen.h"
>
</File>
<File
RelativePath="newInterface_CubeListing.h"
RelativePath=".\modifMemory.h"
>
</File>
<File
RelativePath="newInterface_Runewords.h"
RelativePath=".\newInterface_CubeListing.h"
>
</File>
<File
RelativePath="newInterface_Stats.h"
RelativePath=".\newInterface_Runewords.h"
>
</File>
<File
RelativePath="newInterface_StatsPageTwo.h"
RelativePath=".\newInterface_Stats.h"
>
</File>
<File
RelativePath="newInterfaces.h"
RelativePath=".\newInterface_StatsPageTwo.h"
>
</File>
<File
RelativePath="othersFeatures.h"
RelativePath=".\newInterfaces.h"
>
</File>
<File
RelativePath="parameters.h"
RelativePath=".\othersFeatures.h"
>
</File>
<File
RelativePath="playerCustomData.h"
RelativePath=".\parameters.h"
>
</File>
<File
RelativePath="plugYFiles.h"
RelativePath=".\playerCustomData.h"
>
</File>
<File
RelativePath="resource.h"
RelativePath=".\plugYFiles.h"
>
</File>
<File
RelativePath="savePath.h"
RelativePath=".\resource.h"
>
</File>
<File
RelativePath="savePlayerData.h"
RelativePath=".\savePath.h"
>
</File>
<File
RelativePath="sharedSaveFile.h"
RelativePath=".\savePlayerData.h"
>
</File>
<File
RelativePath="skillPerLevelUp.h"
RelativePath=".\sharedSaveFile.h"
>
</File>
<File
RelativePath="skillsPoints.h"
RelativePath=".\skillPerLevelUp.h"
>
</File>
<File
RelativePath="statPerLevelUp.h"
RelativePath=".\skillsPoints.h"
>
</File>
<File
RelativePath="statsPoints.h"
RelativePath=".\statPerLevelUp.h"
>
</File>
<File
RelativePath="uberQuest.h"
RelativePath=".\statsPoints.h"
>
</File>
<File
RelativePath="updateClient.h"
RelativePath=".\targetver.h"
>
</File>
<File
RelativePath="updateServer.h"
RelativePath=".\uberQuest.h"
>
</File>
<File
RelativePath="worldEvent.h"
RelativePath=".\updateClient.h"
>
</File>
<File
RelativePath=".\updateServer.h"
>
</File>
<File
RelativePath=".\windowed.h"
>
</File>
<File
RelativePath=".\worldEvent.h"
>
</File>
<Filter
@ -581,9 +575,14 @@
</Filter>
</Filter>
<Filter
Name="Resource Files"
Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
Name="Fichiers de ressources"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
<File
RelativePath=".\PlugY.rc"
>
</File>
</Filter>
</Files>
<Globals>

65
PlugY/PlugY.vcproj.ATHLON64.Yohann.user
View File

@ -1,65 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioUserFile
ProjectType="Visual C++"
Version="8,00"
ShowAllFiles="false"
>
<Configurations>
<Configuration
Name="Debug|Win32"
>
<DebugSettings
Command=""
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="ATHLON64"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|Win32"
>
<DebugSettings
Command=""
WorkingDirectory=""
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="ATHLON64"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor=""
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
</Configurations>
</VisualStudioUserFile>

4
PlugY/PlugYFiles.cpp
View File

@ -7,10 +7,8 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "plugYFiles.h"
#include "common.h"
#include <stdio.h>
//#include "newInterfaces.h"

52
PlugY/Progress.txt
View File

@ -1,52 +0,0 @@
Parameters.h et PlugY.rc => version changing
A faire :
A tester :
UPDATED :
DONE D2funcs.h
DONE BigStash.cpp
DONE ClientSaveFile.cpp
DONE Commands.cpp
DONE Common.cpp
DONE CustomLibraries.cpp
DONE D2functions.cpp
DONE D2wrapper.cpp
DONE Error.cpp
DONE ExtendedSaveFile.cpp
DONE ExtraOptions.cpp
DONE GlobalVariable.cpp
DONE InfinityStash.cpp
DONE INIfile.cpp
DONE Interface_Skills.cpp
DONE Interface_Stash.cpp
DONE Interface_Stats.cpp
DONE Language.cpp
DONE LoadPlayerData.cpp
DONE MainScreen.cpp
DONE ModifMemory.cpp
DONE NewInterface_CubeListing.cpp
DONE NewInterface_Runewords.cpp
DONE NewInterface_Stats.cpp
DONE NewInterface_StatsPageTwo.cpp
DONE NewInterfaces.cpp
DONE OthersFeatures.cpp
DONE Parameters.cpp
DONE PlayerCustomData.cpp
DONE PlugY.cpp
DONE PlugY.rc
DONE PlugYFiles.cpp
DONE SavePath.cpp
DONE SavePlayerData.cpp
DONE SharedSaveFile.cpp
DONE SkillPerLevelUp.cpp
DONE SkillsPoints.cpp
DONE StatPerLevelUp.cpp
DONE StatsPoints.cpp
DONE UberQuest.cpp
DONE UpdateClient.cpp
DONE UpdateServer.cpp
DONE WorldEvent.cpp

2
PlugY/SavePath.cpp
View File

@ -8,8 +8,6 @@
#include "savePath.h"
#include "common.h"
#include "error.h"
#include "d2functions.h"
char* savePath = NULL;
bool active_changingSavePath = false;

4
PlugY/SavePlayerData.cpp
View File

@ -6,12 +6,10 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "infinityStash.h"
#include "extendedSaveFile.h"
#include "sharedSaveFile.h"
#include "common.h"
void STDCALL SaveSPPlayerCustomData(Unit* ptChar)

5
PlugY/SharedSaveFile.cpp
View File

@ -5,12 +5,11 @@
=================================================================*/
#include "common.h"
#include "sharedSaveFile.h"
#include "error.h"
#include "d2functions.h"
#include "infinityStash.h"
#include "customLibraries.h"
#include "common.h"
#include <stdio.h>
#define FILE_SHAREDSTASH 0x00535353 //"SSS "
#define BUFFER_SIZE 0x4000

2
PlugY/SkillPerLevelUp.cpp
View File

@ -8,8 +8,6 @@
#include "skillPerLevelUp.h"
#include "common.h"
#include "error.h"
#include "d2functions.h"
bool active_SkillPerLevelUpChange=0;
DWORD skillPerLevelUp=1;

4
PlugY/SkillsPoints.cpp
View File

@ -5,11 +5,9 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "updateServer.h"
#include "interface_Skills.h" // Install_InterfaceSkills()
#include "common.h"
bool active_SkillsPoints=0;
bool unassignSkillsPointsOneByOne=0;

2
PlugY/StatPerLevelUp.cpp
View File

@ -8,8 +8,6 @@
#include "statPerLevelUp.h"
#include "common.h"
#include "error.h"
#include "d2functions.h"
bool active_StatPerLevelUpChange=0;
DWORD statPerLevelUp=5;

17
PlugY/StatsPoints.cpp
View File

@ -6,13 +6,10 @@
=================================================================*/
#include "common.h"
#include "error.h"
#include "d2functions.h"
#include "plugYFiles.h" // Install_PlugYImagesFiles()
#include "interface_Stats.h" // Install_InterfaceStats()
#include "updateServer.h"
#include "common.h"
#include <stdio.h>
bool active_StatsPoints=0;
@ -162,11 +159,12 @@ void STDCALL printDisabledStatsBtn(WORD statID, sDrawImageInfo* data, DWORD x, D
{
WCHAR text[100];
if (active_StatsShiftClickLimit)
swprintf(text, getTranslatedString(STR_STATS_UNASSIGN_WITH_LIMIT),limitValueToShiftClick);
_snwprintf(text, sizeof(text) - 1, getLocalString(STR_STATS_UNASSIGN_WITH_LIMIT), limitValueToShiftClick);
else
swprintf(text, getTranslatedString(STR_STATS_UNASSIGN_WITHOUT_LIMIT));
_snwprintf(text, sizeof(text) - 1, getLocalString(STR_STATS_UNASSIGN_WITHOUT_LIMIT));
wcscat(text,L"\n");
swprintf(text+wcslen(text), getTranslatedString(STR_STATS_BASE_MIN), statValue, minValue);
int len = wcslen(text);
_snwprintf(text + len, sizeof(text) - len, getLocalString(STR_STATS_BASE_MIN), statValue, minValue);
D2SetFont(1);
D2PrintPopup(text, x+18, y-32, WHITE, 1);
}
@ -329,8 +327,7 @@ void Install_StatsPoints()
Install_UpdateServer();
log_msg("Patch D2Client for unassign stat points when specified key is press. (StatsPoints)\n");
//if ( version_D2Client < V113 )
{
// Always print stat button images.
mem_seek R7(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5, BF955);
memt_byte( 0x8B, 0xEB ); // JMP SHORT D2Client.6FAD0088
@ -453,7 +450,7 @@ void Install_StatsPoints()
MEMC_REF4( D2SendToServer3, caller_setValue);
//6FAD1610 . E8 7BC3FDFF CALL D2Client.6FAAD990
}
} log_msg("\n");
log_msg("\n");
isInstalled = true;
}

3
PlugY/UberQuest.cpp
View File

@ -6,9 +6,8 @@
=================================================================*/
#include "uberQuest.h"
#include "common.h"
#include "error.h"
#include "d2functions.h"
bool active_UberQuest=0;

30
PlugY/UpdateClient.cpp
View File

@ -6,14 +6,10 @@
=================================================================*/
#include "common.h"
#include "updateClient.h"
#include "error.h"
#include "d2functions.h"
#include "infinityStash.h"
#include "commands.h"
#include "common.h"
void updateClient(Unit* ptChar, DWORD mFunc, DWORD p1, DWORD p2, DWORD p3)
{
@ -36,14 +32,36 @@ void updateClient(Unit* ptChar, DWORD mFunc, DWORD p1, DWORD p2, DWORD p3)
D2SendPacket(ptNetClient, &packet, sizeof(DataPacket));
}
void updateClient(Unit* ptChar, DWORD mFunc, char* msg)
{
void* ptNetClient;
DataPacket packet;
// Intialize the packet to send to client
ZeroMemory(&packet, sizeof(DataPacket));
packet.mType = 0x9D;
packet.mFunc = (BYTE)mFunc;
packet.mSize = sizeof(DataPacket);
packet.mPlayerID = ptChar->nUnitId;
if (msg != NULL && strlen(msg) >= 20)
return;
if (msg != NULL)
strcpy((char*)&packet.mItemID, msg);
ptNetClient = D2GetClient(ptChar, __FILE__, __LINE__);
// Send packet to client for remove placed skills
D2SendPacket(ptNetClient, &packet, sizeof(DataPacket));
}
DWORD FASTCALL handleClientUpdate(DataPacket* packet)
{
log_msg("[CLIENT] Received custom message: %d with param: %08X , %08X , %08X\n",packet->mFunc,packet->mParam1,packet->mParam2,packet->mParam3);
switch (packet->mFunc)
{
case UC_SELECT_STASH : setSelectedStashClient(packet->mParam1,packet->mParam2,packet->mParam3); return 1;
case UC_SELECT_STASH: setSelectedStashClient(packet->mParam1, packet->mParam2, packet->mParam3, (packet->mParam2 & 4) == 4); return 1;
case UC_SHARED_GOLD : updateSharedGold(packet->mParam1); return 1;
case UC_PAGE_NAME: renameCurrentStash(D2GetClientPlayer(), (char*)&packet->mItemID); return 1;
default : return 0;
}
}

60
PlugY/UpdateServer.cpp
View File

@ -6,21 +6,23 @@
=================================================================*/
#include "common.h"
#include "updateServer.h"
#include "error.h"
#include "d2functions.h"
#include "statsPoints.h"
#include "skillsPoints.h"
#include "infinityStash.h"
#include "commands.h"
#include "common.h"
int renameIndex = 0;
char renameString[16];
DWORD PageSwap;
int STDCALL handleServerUpdate(Unit* ptChar, WORD param)
{
log_msg("Received custom message: %X\n", param);
switch(param & 0xFF)
int type = param & 0xFF;
DWORD arg = (param & 0xFF00) >> 8;
log_msg("Received custom message: type=%i, arg=%i\n", type, arg);
switch(type)
{
case US_UNASSIGN_STR_POINT : UnassignStrPoint( ptChar ); return 1;
case US_UNASSIGN_ENE_POINT : UnassignEnePoint( ptChar ); return 1;
@ -31,29 +33,64 @@ int STDCALL handleServerUpdate(Unit* ptChar, WORD param)
case US_UNASSIGN_DEX_POINTS : UnassignDexPoints( ptChar ); return 1;
case US_UNASSIGN_VIT_POINTS : UnassignVitPoints( ptChar ); return 1;
case US_UNASSIGN_SKILLS : UnassignAllSkillsPoints( ptChar ); return 1;
case US_SET_INDEX: setCurrentStashIndex(ptChar, true); return 1;
case US_RESET_INDEX: setCurrentStashIndex(ptChar, false); return 1;
case US_SELECT_PREVIOUS : selectPreviousStash( ptChar ); return 1;
case US_SELECT_NEXT : selectNextStash( ptChar ); return 1;
case US_SELECT_SELF : if (active_sharedStash) toggleToSelfStash( ptChar ); return 1;
case US_SELECT_SHARED : if (active_sharedStash) toggleToSharedStash( ptChar ); return 1;
case US_SELECT_PREVIOUS_INDEX : selectPreviousIndexStash( ptChar ); return 1;
case US_SELECT_NEXT_INDEX : selectNextIndexStash( ptChar ); return 1;
case US_SELECT_PREVIOUS2 : selectPrevious2Stash( ptChar ); return 1;
case US_SELECT_NEXT2 : selectNext2Stash( ptChar ); return 1;
case US_SELECT_PREVIOUS_INDEX2: selectPreviousIndex2Stash( ptChar ); return 1;
case US_SELECT_NEXT_INDEX2 : selectNextIndex2Stash( ptChar ); return 1;
case US_INSERT_PAGE: insertStash(ptChar); return 1;
case US_DELETE_PAGE: deleteStash(ptChar); return 1;
case US_STARTSAVE : savePlayers( ptChar ); return 1;
case US_SAVE : savePlayers( ptChar ); return 1;
case US_MAXGOLD : maxGold(ptChar); return 1;
case US_PUTGOLD : putGold(ptChar, 0); return 1;
case US_TAKEGOLD : takeGold(ptChar, 0); return 1;
default : return 0;
case US_SWAP3 : PageSwap = arg << 24; return 1;
case US_SWAP2 : PageSwap |= arg << 16; return 1;
case US_SWAP1 : PageSwap |= arg << 8; return 1;
case US_SWAP0: swapStash(ptChar, PageSwap | arg, false); PageSwap = 0; return 1;
case US_SWAP0_TOGGLE : swapStash(ptChar, PageSwap | arg, true); PageSwap = 0; return 1;
case US_RENAME :
if (renameIndex == 0)
for (int i = 0; i < 16; i++)
renameString[i] = 0;
renameString[renameIndex++] = (char)arg;
if (arg == 0)
{
renameIndex = 0;
log_msg("Rename on Server : %s -> %s\n", ptChar->ptPlayerData->name, renameString);
strcpy(ptChar->ptPlayerData->name, renameString);
strcpy(ptChar->ptPlayerData->ptNetClient->name, renameString);
}
return 1;
case US_PAGENAME:
if (renameIndex == 0)
for (int i = 0; i < 16; i++)
renameString[i] = 0;
renameString[renameIndex++] = (char)arg;
if (arg == 0)
{
renameIndex = 0;
log_msg("Rename current page on Server : %s -> %s\n", PCPY->currentStash->name, renameString);
renameCurrentStash(ptChar, renameString);
}
return 1;
default :
return 0;
}
}
FCT_ASM( caller_handleServerUpdate)
PUSH EAX
PUSH ESI
PUSH EBX
CALL handleServerUpdate
TEST EAX,EAX
@ -118,6 +155,9 @@ void Install_UpdateServer()
//6FCEC983 . C1EE 08 SHR ESI,8
//6FCEC986 . 57 PUSH EDI
//6FCEC987 . 8BF8 MOV EDI,EAX
//066A76C3 |. C1EE 08 SHR ESI,8
//066A76C6 |. 57 PUSH EDI
//066A76C7 |. 8BF8 MOV EDI,EAX
} else if (version_D2Game == V110) {
memt_byte( 0xC1, 0xE8 ); // CALL caller_handleServerUpdate
MEMT_REF4( 0xF88B08EE, caller_handleServerUpdate);

98
PlugY/Windowed.cpp Normal file
View File

@ -0,0 +1,98 @@
/*=================================================================
File created by Yohann NICOLAS.
Windowed mode options.
=================================================================*/
#include "windowed.h"
#include "common.h"
int active_Windowed = true;
int setWindowedOptionsDone = false;
int active_RemoveBorder = true;
int active_WindowOnTop = true;
int active_Maximized = true;
int active_SetWindowPos = true;
int windowedX = 240;
int windowedY = 0;
int windowedWidth = 1440;
int windowedHeight = 1080;
int active_LockMouseOnStartup = true;
void unlockMouseCursor()
{
ClipCursor(NULL);
}
void lockMouseCursor(int width, int height)
{
RECT clientRect;
RECT rect;
HWND hwnd = GetActiveWindow();
GetClientRect(hwnd, &clientRect);
GetWindowRect(hwnd, &rect);
int shiftX = (rect.right - rect.left - clientRect.right) / 2;
int shiftY = rect.bottom - rect.top - clientRect.bottom - shiftX;
log_msg("Windows size : %i, %i, %i, %i\n", rect.left, rect.top, rect.right, rect.bottom);
rect.left += shiftX;
rect.right = rect.left + width;
rect.top += shiftY;
rect.bottom = rect.top + height;
//no resize : 560, 231, 1360, 831
//resized : 240, 0, 1040, 600
log_msg("Lock Mouse Cursor : %i, %i, %i, %i\n", rect.left, rect.top, rect.right, rect.bottom);
ClipCursor(&rect);
}
void lockMouseCursor() { lockMouseCursor(ResolutionX, ResolutionY); }
void SetWindowedOptions()
{
if (setWindowedOptionsDone)
return;
HWND hwnd = GetActiveWindow();
RECT clientRect;
GetClientRect(hwnd, &clientRect);
if (active_RemoveBorder)
{
LONG lStyle = GetWindowLong(hwnd, GWL_STYLE);
lStyle &= ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU);
SetWindowLong(hwnd, GWL_STYLE, lStyle);
SetWindowPos(hwnd, NULL, 0, 0, clientRect.right, clientRect.bottom, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOZORDER | SWP_NOOWNERZORDER);
}
if (active_Maximized && !active_SetWindowPos)
{
RECT screen;
GetWindowRect(GetDesktopWindow(), &screen);
log_msg("Screen size : %i, %i, %i, %i\n", screen.left, screen.top, screen.right, screen.bottom);
int w = screen.bottom * clientRect.right / clientRect.bottom;
int h = w * clientRect.bottom / clientRect.right;
if (screen.right < w)
{
h = screen.right * clientRect.bottom / clientRect.right;
w = h * clientRect.right / clientRect.bottom;
}
windowedX = (screen.right - w) / 2;
windowedY = (screen.bottom - h) / 2;
windowedWidth = w;
windowedHeight = h;
}
if (active_SetWindowPos || active_Maximized)
{
if (active_WindowOnTop)
SetWindowPos(hwnd, HWND_TOPMOST, windowedX, windowedY, windowedWidth, windowedHeight, SWP_FRAMECHANGED);
else
SetWindowPos(hwnd, NULL, windowedX, windowedY, windowedWidth, windowedHeight, SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOOWNERZORDER);
}
else if (active_WindowOnTop)
SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, clientRect.right, clientRect.bottom, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE);
if (active_LockMouseOnStartup)
lockMouseCursor(clientRect.right, clientRect.bottom);
setWindowedOptionsDone = true;
}

3
PlugY/WorldEvent.cpp
View File

@ -6,9 +6,8 @@
=================================================================*/
#include "worldEvent.h"
#include "common.h"
#include "error.h"
#include "d2functions.h"
#pragma pack(1)
struct s_WEdata

9
PlugY/bigStash.h
View File

@ -4,16 +4,13 @@
Use a more big stash
=================================================================*/
#pragma once
#ifndef __BIGSTASH_HPP__INCLUDED
#define __BIGSTASH_HPP__INCLUDED
#include <windows.h>
#include "common.h"
extern bool active_bigStash;
extern bool active_bigStash_tested;
void Install_BigStash();
#endif
/*================================= END OF FILE =================================*/

6
PlugY/clientSaveFile.h
View File

@ -4,13 +4,11 @@
Add an extra save file for each characters.
=================================================================*/
/*
#pragma once
/*
#include "common.h"
DWORD loadClientSaveFile();
DWORD saveClientSaveFile();
*/
/*================================= END OF FILE =================================*/

6
PlugY/commands.h
View File

@ -4,9 +4,9 @@
Commands directly in game.
=================================================================*/
#pragma once
#ifndef __COMMANDS_H__INCLUDED
#define __COMMANDS_H__INCLUDED
#include "common.h"
extern bool active_Commands;
@ -18,4 +18,4 @@ void updateSharedGold(DWORD goldAmount);
void Install_Commands();
#endif
/*================================= END OF FILE =================================*/

182
PlugY/common.h
View File

@ -6,194 +6,30 @@
function related to some Diablo II mechanisms.
/*============================================*/
#pragma once
//#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
#include <windows.h>
#include "../Commons/d2Constants.h"
#include "../Commons/d2BinFile.h"
#include "../Commons/d2Struct.h"
#include "../Commons/d2StringTblStruct.h"
#include "../Commons/D2UnitStruct.h"
#include "../Commons/updatingConst.h"
#include "../Commons/VersionInfo.h"
#include "customData.h"
#include "error.h"
#include "modifMemory.h"
#include "parameters.h"
#include "globalVariable.h"
#include "d2wrapper.h"
#include "playerCustomData.h" // include common.h
#include "globalVariable.h" // include common.h
//#ifdef MSVC
#define FASTCALL __fastcall
//#else
//#define FASTCALL __msfastcall
//#endif
#define STDCALL __stdcall
#define FCT_ASM(N) __declspec(naked) void N() {__asm{
#define RANDOM(V) ((int)(rand()/(RAND_MAX+1.0)*(V)))
//#define RANDOM(V) (rand()%(V))
// Convertion to 1.09
struct s_shifting {
DWORD ptInventory;
DWORD ptSpecificData;
DWORD ptPYPlayerData;
DWORD ptGame;
DWORD ptClientGame;
DWORD ptSkills;
DWORD ptImage;
DWORD ptFrame;
};
extern s_shifting shifting;
//#define PY(C) (*(PYPlayerData**)((BYTE*)(ptChar)+shifting.ptPYPlayerData))
#define PCPlayerData (*(PlayerData**)((DWORD)(ptChar)+shifting.ptSpecificData)) //->ptPlayerData
#define PCGame (*(Game**)((DWORD)(ptChar)+shifting.ptGame)) //->ptGame
#define PClientGame (*(Game**)((DWORD)(ptClient)+shifting.ptClientGame)) //ptClient->ptGame
#define PCInventory (*(Inventory**)((DWORD)(ptChar)+shifting.ptInventory)) //->ptInventory
//#define PIItemData (*(ItemData**)((DWORD)(ptItem)+shifting.ptSpecificData)) //->ptItemData
//#define PCPY (*(PYPlayerData**)((DWORD)(ptChar)+shifting.ptPYPlayerData)) //->ptPYPlayerData
#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,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
#define BIN(A,B,C,D) ((DWORD)A) + (((DWORD)B) << 8) + (((DWORD)C) << 16) + (((DWORD)D) << 24)
#define RX(v) (WindowStartX+(v))
#define RY(v) (ResolutionY+NegWindowStartY-(v))
enum eFileVersion
{
V109b=0,
V109d,
V110,
V111,
V111b,
V112,
V113c,
V113d,
V114a
};
extern int version_SmackW32;
extern int version_D2Common;
extern int version_ijl11;
extern int version_D2Gdi;
extern int version_D2Win;
extern int version_D2sound;
extern int version_D2MCPCLI;
extern int version_D2Launch;
extern int version_D2gfx;
extern int version_D2Client;
extern int version_D2Net;
extern int version_D2Lang;
extern int version_D2Game;
extern int version_D2CMP;
extern int version_Bnclient;
extern int version_Fog;
extern int version_Storm;
// Address in memory of external DLL
extern DWORD offset_SmackW32;
extern DWORD offset_D2Common;
extern DWORD offset_ijl11;
extern DWORD offset_D2Gdi;
extern DWORD offset_D2Win;
extern DWORD offset_D2sound;
extern DWORD offset_D2MCPCLI;
extern DWORD offset_D2Launch;
extern DWORD offset_D2gfx;
extern DWORD offset_D2Client;
extern DWORD offset_D2Net;
extern DWORD offset_D2Lang;
extern DWORD offset_D2Game;
extern DWORD offset_D2CMP;
extern DWORD offset_Bnclient;
extern DWORD offset_Fog;
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,
STR_STATS_UNASSIGN_WITHOUT_LIMIT,
STR_STATS_BASE_MIN,
STR_SKILLS_UNASSIGN,
STR_STASH_PREVIOUS_PAGE,
STR_STASH_NEXT_PAGE,
STR_TOGGLE_TO_PERSONAL,
STR_TOGGLE_TO_SHARED,
STR_STASH_PREVIOUS_INDEX,
STR_STASH_NEXT_INDEX,
STR_PERSONAL_PAGE_NUMBER,
STR_SHARED_PAGE_NUMBER,
STR_NO_SELECTED_PAGE,
STR_PUT_GOLD,
STR_TAKE_GOLD,
STR_SHARED_GOLD_QUANTITY,
STR_PREVIOUS_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
};
#include "d2functions.h"
#include "LocalizedStrings.h"
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);
/*================================= END OF FILE =================================*/

1
PlugY/customData.h
View File

@ -4,7 +4,6 @@
Data added to D2 base-stucture
=================================================================*/
#pragma once
#include "playerCustomData.h"

4
PlugY/customLibraries.h
View File

@ -4,9 +4,10 @@
Language management.
=================================================================*/
#pragma once
#include "common.h"
typedef int (STDCALL *TsaveSaveFile) (Unit* ptChar, BYTE** data, DWORD* maxSize, DWORD* curSize);
typedef int (STDCALL *TloadSaveFile) (Unit* ptChar, BYTE* data, DWORD maxSize, DWORD* curSize);
typedef int (STDCALL *TinitSaveFile) (BYTE** data, DWORD* maxSize, DWORD* curSize);
@ -42,5 +43,4 @@ private:
extern TCustomDll* customDlls;
/*================================= END OF FILE =================================*/

42
PlugY/d2functions.h
View File

@ -6,10 +6,48 @@
function related to some Diablo II mechanisms.
================================================*/
#pragma once
#include "common.h"
// Convertion to 1.09
struct s_shifting {
DWORD ptInventory;
DWORD ptSpecificData;
DWORD ptPYPlayerData;
DWORD ptGame;
DWORD ptClientGame;
DWORD ptSkills;
DWORD ptImage;
DWORD ptFrame;
};
extern s_shifting shifting;
//#ifdef MSVC
#define FASTCALL __fastcall
//#else
//#define FASTCALL __msfastcall
//#endif
#define STDCALL __stdcall
#define FCT_ASM(N) __declspec(naked) void N() {__asm{
#define RANDOM(V) ((int)(rand()/(RAND_MAX+1.0)*(V)))
//#define RANDOM(V) (rand()%(V))
//#define PY(C) (*(PYPlayerData**)((BYTE*)(ptChar)+shifting.ptPYPlayerData))
#define PCPlayerData (*(PlayerData**)((DWORD)(ptChar)+shifting.ptSpecificData)) //->ptPlayerData
#define PCGame (*(Game**)((DWORD)(ptChar)+shifting.ptGame)) //->ptGame
#define PClientGame (*(Game**)((DWORD)(ptClient)+shifting.ptClientGame)) //ptClient->ptGame
#define PCInventory (*(Inventory**)((DWORD)(ptChar)+shifting.ptInventory)) //->ptInventory
//#define PIItemData (*(ItemData**)((DWORD)(ptItem)+shifting.ptSpecificData)) //->ptItemData
//#define PCPY (*(PYPlayerData**)((DWORD)(ptChar)+shifting.ptPYPlayerData)) //->ptPYPlayerData
#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,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)))))))
#define RX(v) (WindowStartX+(v))
#define RY(v) (ResolutionY+NegWindowStartY-(v))
#define D2S(F, I, R, N, P) typedef R (STDCALL *T##N) P; extern T##N N;//static D N = (D)(A);
#define D2F(F, I, R, N, P) typedef R (FASTCALL *T##N) P; extern T##N N;//static D N = (D)(A);

55
PlugY/d2wrapper.h Normal file
View File

@ -0,0 +1,55 @@
/******************************************************************************
File modified by Yohann NICOLAS.
NAME
inifile.h
DESCRIPTION
Memory cached INI file read/write class to replace legacy MS code
COPYRIGHT
©1999-2004 Ultrafunk (www.ultrafunk.com) - info@ultrafunk.com
******************************************************************************/
#pragma once
#include <windows.h>
extern int version_SmackW32;
extern int version_D2Common;
extern int version_ijl11;
extern int version_D2Gdi;
extern int version_D2Win;
extern int version_D2sound;
extern int version_D2MCPCLI;
extern int version_D2Launch;
extern int version_D2gfx;
extern int version_D2Client;
extern int version_D2Net;
extern int version_D2Lang;
extern int version_D2Game;
extern int version_D2CMP;
extern int version_Bnclient;
extern int version_Fog;
extern int version_Storm;
// Address in memory of external DLL
extern DWORD offset_SmackW32;
extern DWORD offset_D2Common;
extern DWORD offset_ijl11;
extern DWORD offset_D2Gdi;
extern DWORD offset_D2Win;
extern DWORD offset_D2sound;
extern DWORD offset_D2MCPCLI;
extern DWORD offset_D2Launch;
extern DWORD offset_D2gfx;
extern DWORD offset_D2Client;
extern DWORD offset_D2Net;
extern DWORD offset_D2Lang;
extern DWORD offset_D2Game;
extern DWORD offset_D2CMP;
extern DWORD offset_Bnclient;
extern DWORD offset_Fog;
extern DWORD offset_Storm;
/*================================= END OF FILE =================================*/

6
PlugY/error.h
View File

@ -8,9 +8,7 @@
error handling in D2External functions.
==============================================*/
#ifndef __ERROR_H__INCLUDED__
#define __ERROR_H__INCLUDED__
#pragma once
#include <windows.h>
@ -21,4 +19,4 @@ void log_box( const char* pFormat, ... );
void log_msg( const char* pFormat, ... );
void d2_assert( bool pCondition, char* pLocation, char* pMessage, int pLineNbr );
#endif
/*================================= END OF FILE =================================*/

2
PlugY/extendedSaveFile.h
View File

@ -4,11 +4,9 @@
Add an extra save file for each characters.
=================================================================*/
#pragma once
#include "common.h"
#include <stdio.h>
BYTE* readExtendedSaveFile(char* name, DWORD* size);
void writeExtendedSaveFile(char* name, BYTE* data, DWORD size);

18
PlugY/extraOptions.h
View File

@ -4,28 +4,28 @@
More little options.
=================================================================*/
#pragma once
#ifndef __EXTRAOPTIONS_H__INCLUDED
#define __EXTRAOPTIONS_H__INCLUDED
#include "common.h"
extern int active_RunLODs;
extern int active_alwaysRegenMapInSP;
extern DWORD nbPlayersCommandByDefault;
extern int active_DisplayItemLevel;
extern DWORD nbPlayersCommandByDefault;
extern int active_alwaysRegenMapInSP;
extern int active_RunLODs;
extern int active_AlwaysDisplayLifeMana;
extern int active_EnabledTXTFilesWithMSExcel;
extern int active_DisplayBaseStatsValue;
extern int active_LadderRunewords;
extern int active_EnabledCowPortalWhenCowKingWasKill;
void Install_RunLODs();
void Install_AlwaysRegenMapInSP();
void Install_SendPlayersCommand();
void Install_DisplayItemLevel();
void Install_SendPlayersCommand();
void Install_AlwaysRegenMapInSP();
void Install_RunLODs();
void Install_AlwaysDisplayLifeMana();
void Install_EnabledTXTFilesWithMSExcel();
void Install_DisplayBaseStatsValue();
void Install_LadderRunewords();
void Install_EnabledCowPortalWhenCowKingWasKill();
#endif
/*================================= END OF FILE =================================*/

6
PlugY/globalVariable.h
View File

@ -4,13 +4,13 @@
Set global variable.
=================================================================*/
#pragma once
#ifndef __GLOBAL_VARIABLE_H__INCLUDED
#define __GLOBAL_VARIABLE_H__INCLUDED
#include "common.h"
extern bool onRealm;
extern bool needToInit;
void Install_VariableOnRealm();
#endif
/*================================= END OF FILE =================================*/

9
PlugY/infinityStash.h
View File

@ -4,7 +4,6 @@
infinity Stash gestion
=================================================================*/
#pragma once
#include "common.h"
@ -22,9 +21,9 @@ extern char* sharedStashFilename;
extern bool displaySharedSetItemNameInGreen;
extern int posXPreviousBtn,posYPreviousBtn,posXNextBtn,posYNextBtn,posXSharedBtn,posYSharedBtn,posXPreviousIndexBtn,posYPreviousIndexBtn,posXNextIndexBtn,posYNextIndexBtn,posXPutGoldBtn,posYPutGoldBtn,posXTakeGoldBtn,posYTakeGoldBtn;
void toggleToSharedStash(Unit* ptChar);
void toggleToSelfStash(Unit* ptChar);
void setCurrentStashIndex(Unit* ptChar, bool isIndex);
void selectPreviousStash(Unit* ptChar);
void selectNextStash(Unit* ptChar);
void selectPreviousIndexStash(Unit* ptChar);
@ -33,9 +32,13 @@ void selectPrevious2Stash(Unit* ptChar);
void selectNext2Stash(Unit* ptChar);
void selectPreviousIndex2Stash(Unit* ptChar);
void selectNextIndex2Stash(Unit* ptChar);
void swapStash(Unit* ptChar, DWORD page, bool toggle);
void renameCurrentStash(Unit* ptChar, char* name);
void insertStash(Unit* ptChar);
bool deleteStash(Unit* ptChar);
void selectStash(Unit* ptChar, Stash* newStash);
void setSelectedStashClient(DWORD stashId, DWORD stashFlags, DWORD flags);
void setSelectedStashClient(DWORD stashId, DWORD stashFlags, DWORD flags, bool bOnlyItems);
Stash* addStash(Unit* ptChar, bool isShared);
DWORD loadStashList(Unit* ptChar, BYTE* data, DWORD maxSize, DWORD* curSize, bool isShared);

6
PlugY/interface_Skills.h
View File

@ -4,10 +4,10 @@
Interface Skills functions
=================================================================*/
#pragma once
#ifndef __INTERFACE_SKILLS_HPP__INCLUDED
#define __INTERFACE_SKILLS_HPP__INCLUDED
#include "common.h"
void Install_InterfaceSkills();
#endif
/*================================= END OF FILE =================================*/

6
PlugY/interface_Stash.h
View File

@ -4,10 +4,10 @@
Interface functions
=================================================================*/
#pragma once
#ifndef __INTERFACE_STASH_HPP__INCLUDED
#define __INTERFACE_STASH_HPP__INCLUDED
#include "common.h"
void Install_InterfaceStash();
#endif
/*================================= END OF FILE =================================*/

6
PlugY/interface_Stats.h
View File

@ -4,10 +4,10 @@
Interface Stats functions
=================================================================*/
#pragma once
#ifndef __INTERFACE_STATS_HPP__INCLUDED
#define __INTERFACE_STATS_HPP__INCLUDED
#include "common.h"
void Install_InterfaceStats();
#endif
/*================================= END OF FILE =================================*/

6
PlugY/language.h
View File

@ -4,9 +4,9 @@
Language management.
=================================================================*/
#pragma once
#ifndef __LANGUAGE_H__INCLUDED
#define __LANGUAGE_H__INCLUDED
#include "common.h"
extern bool active_ChangeLanguage;
extern DWORD selectedLanguage;
@ -36,4 +36,4 @@ extern t_availableLanguages availableLanguages;
void Install_LanguageManagement();
#endif
/*================================= END OF FILE =================================*/

6
PlugY/loadPlayerData.h
View File

@ -4,10 +4,10 @@
Load Player Custom Data.
=================================================================*/
#pragma once
#ifndef __LOADPLAYERDATA_H__INCLUDED
#define __LOADPLAYERDATA_H__INCLUDED
#include "common.h"
void Install_LoadPlayerData();
#endif
/*================================= END OF FILE =================================*/

8
PlugY/mainScreen.h
View File

@ -4,11 +4,9 @@
Add "plugY v1.00" on screen.
=================================================================*/
#pragma once
#ifndef __MAINSCREEN_H__INCLUDED
#define __MAINSCREEN_H__INCLUDED
#include <windows.h>
#include "common.h"
extern bool active_VersionTextChange;
extern char* versionText;
@ -19,4 +17,4 @@ extern BYTE colorOfPlugYVersion;
void Install_PrintPlugYVersion();
void Install_VersionChange();
#endif
/*================================= END OF FILE =================================*/

3
PlugY/modifMemory.h
View File

@ -4,9 +4,10 @@
Modification of code in memory functions.
/*============================================*/
#pragma once
#include <Windows.h>
extern void* currentMemoryPos;
DWORD mem_seek(DWORD newPos);

6
PlugY/newInterface_CubeListing.h
View File

@ -4,10 +4,10 @@
Cube Listing functions
=================================================================*/
#pragma once
#ifndef __NEWINTERFACE_CUBELISTING_H__INCLUDED
#define __NEWINTERFACE_CUBELISTING_H__INCLUDED
#include "common.h"
void listAllCubeFormula();
#endif
/*================================= END OF FILE =================================*/

6
PlugY/newInterface_Runewords.h
View File

@ -4,12 +4,12 @@
New runeword Interface
=================================================================*/
#pragma once
#ifndef __NEWINTERFACE_RUNEWORDS_H__INCLUDED
#define __NEWINTERFACE_RUNEWORDS_H__INCLUDED
#include "common.h"
void STDCALL printRunewordsPage();
DWORD STDCALL mouseRunewordsPageLeftDown(sWinMessage* msg);
DWORD STDCALL mouseRunewordsPageLeftUp(sWinMessage* msg);
#endif
/*================================= END OF FILE =================================*/

6
PlugY/newInterface_Stats.h
View File

@ -4,12 +4,12 @@
New Stat Interface
=================================================================*/
#pragma once
#ifndef __NEWINTERFACE_STATS_H__INCLUDED
#define __NEWINTERFACE_STATS_H__INCLUDED
#include "common.h"
void STDCALL printNewStatsPage();
DWORD STDCALL mouseNewStatsPageLeftDown(sWinMessage* msg);
DWORD STDCALL mouseNewStatsPageLeftUp(sWinMessage* msg);
#endif
/*================================= END OF FILE =================================*/

6
PlugY/newInterface_StatsPageTwo.h
View File

@ -4,12 +4,12 @@
New Stat Interface Page 2
=================================================================*/
#pragma once
#ifndef __NEWINTERFACE_STATSPAGETWO_H__INCLUDED
#define __NEWINTERFACE_STATSPAGETWO_H__INCLUDED
#include "common.h"
void STDCALL printNewStatsPageTwo(int currentPage);
DWORD STDCALL mouseNewStatsPageTwoLeftDown(sWinMessage* msg);
DWORD STDCALL mouseNewStatsPageTwoLeftUp(sWinMessage* msg);
#endif
/*================================= END OF FILE =================================*/

6
PlugY/newInterfaces.h
View File

@ -4,9 +4,9 @@
New Interfaces functions
=================================================================*/
#pragma once
#ifndef __NEW_INTERFACES_H__INCLUDED
#define __NEW_INTERFACES_H__INCLUDED
#include "common.h"
#define MILIEU(X,L,N) (X + ((N<L)? (L-N)/2 : 0))
#define isOnStatsPage(x,y) ((x<400) && (y<553))
@ -24,4 +24,4 @@ extern bool printBackgroundOnMainPage;
void Install_NewInterfaces();
#endif
/*================================= END OF FILE =================================*/

6
PlugY/othersFeatures.h
View File

@ -4,13 +4,13 @@
Others features.
=================================================================*/
#pragma once
#ifndef __OTHERSFEATURES_H__INCLUDED
#define __OTHERSFEATURES_H__INCLUDED
#include "common.h"
extern bool active_othersFeatures;
void Install_OthersFeatures();
void Install_ChangeResolution();
#endif
/*================================= END OF FILE =================================*/

4
PlugY/parameters.h
View File

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

4
PlugY/playerCustomData.h
View File

@ -4,12 +4,12 @@
Data added to Player base-stucture
=================================================================*/
#pragma once
#include "common.h"
extern bool active_PlayerCustomData;
extern bool openSharedStashOnLoading;
struct Unit;
@ -20,6 +20,8 @@ struct Stash
DWORD flags;
struct {
DWORD isShared:1; //
DWORD isIndex:1; //
DWORD isReserved:1; // For swap items comand
};
};
char* name;

3
PlugY/plugYFiles.h
View File

@ -4,9 +4,10 @@
Data added to D2 base-stucture
=================================================================*/
#pragma once
#include "common.h"
extern void* unassignSkillsBtnImages;
extern void* unassignStatsBtnImages;
extern void* stashBtnsImages;

3
PlugY/resource.h
View File

@ -1,13 +1,12 @@
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by PlugY.rc
//
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 106
#define _APS_NEXT_RESOURCE_VALUE 101
#define _APS_NEXT_COMMAND_VALUE 40001
#define _APS_NEXT_CONTROL_VALUE 1001
#define _APS_NEXT_SYMED_VALUE 101

6
PlugY/savePath.h
View File

@ -4,13 +4,13 @@
Changing the current save path.
=================================================================*/
#pragma once
#ifndef __SAVEPATH_H__INCLUDED
#define __SAVEPATH_H__INCLUDED
#include "common.h"
extern char* savePath;
extern bool active_changingSavePath;
void Install_ChangingSavePath();
#endif
/*================================= END OF FILE =================================*/

6
PlugY/savePlayerData.h
View File

@ -4,10 +4,10 @@
Save Player Custom Data.
=================================================================*/
#pragma once
#ifndef __SAVEPLAYERDATA_H__INCLUDED
#define __SAVEPLAYERDATA_H__INCLUDED
#include "common.h"
void Install_SavePlayerData();
#endif
/*================================= END OF FILE =================================*/

2
PlugY/sharedSaveFile.h
View File

@ -4,11 +4,9 @@
Add an extra save file shared by all own characters.
=================================================================*/
#pragma once
#include "common.h"
#include <stdio.h>
BYTE* readSharedSaveFile(char* name, DWORD* size);
void writeSharedSaveFile(char* name, BYTE* data, DWORD size, bool isHardcore);

3
PlugY/skillPerLevelUp.h
View File

@ -4,10 +4,9 @@
Change Skill win per level up.
=================================================================*/
#pragma once
#include <windows.h>
#include "common.h"
extern bool active_SkillPerLevelUpChange;
extern DWORD skillPerLevelUp;

6
PlugY/skillsPoints.h
View File

@ -4,9 +4,9 @@
Unassign Skill Point for futher re-assignment.
=================================================================*/
#pragma once
#ifndef __SKILLSPOINTS_H__INCLUDED
#define __SKILLSPOINTS_H__INCLUDED
#include "common.h"
extern bool active_SkillsPoints;
extern bool unassignSkillsPointsOneByOne;
@ -17,4 +17,4 @@ void client_UnassignAllSkillsPoints();
void Install_SkillsPoints();
#endif
/*================================= END OF FILE =================================*/

3
PlugY/statPerLevelUp.h
View File

@ -4,10 +4,9 @@
Change Stat win per level up.
=================================================================*/
#pragma once
#include <windows.h>
#include "common.h"
extern bool active_StatPerLevelUpChange;
extern DWORD statPerLevelUp;

3
PlugY/statsPoints.h
View File

@ -4,10 +4,9 @@
Unassign Stats Point for futher re-assignment.
=================================================================*/
#pragma once
#include <windows.h>
#include "common.h"
extern bool active_StatsPoints;
extern DWORD keyUsedForUnassignStatPoint;

24
PlugY/targetver.h Normal file
View File

@ -0,0 +1,24 @@
#pragma once
// Les macros suivantes définissent la plateforme minimale requise. La plateforme minimale requise
// est la version de Windows, Internet Explorer etc. qui dispose des fonctionnalités nécessaires pour exécuter
// votre application. Les macros fonctionnent en activant toutes les fonctionnalités disponibles sur les versions de la plateforme jusqu'à la
// version spécifiée.
// Modifiez les définitions suivantes si vous devez cibler une plateforme avant celles spécifiées ci-dessous.
// Reportez-vous à MSDN pour obtenir les dernières informations sur les valeurs correspondantes pour les différentes plateformes.
#ifndef WINVER // Spécifie que la plateforme minimale requise est Windows Vista.
#define WINVER 0x0600 // Attribuez la valeur appropriée à cet élément pour cibler d'autres versions de Windows.
#endif
#ifndef _WIN32_WINNT // Spécifie que la plateforme minimale requise est Windows Vista.
#define _WIN32_WINNT 0x0600 // Attribuez la valeur appropriée à cet élément pour cibler d'autres versions de Windows.
#endif
#ifndef _WIN32_WINDOWS // Spécifie que la plateforme minimale requise est Windows 98.
#define _WIN32_WINDOWS 0x0410 // Attribuez la valeur appropriée à cet élément pour cibler Windows Me ou version ultérieure.
#endif
#ifndef _WIN32_IE // Spécifie que la plateforme minimale requise est Internet Explorer 7.0.
#define _WIN32_IE 0x0700 // Attribuez la valeur appropriée à cet élément pour cibler d'autres versions d'Internet Explorer.
#endif

3
PlugY/uberQuest.h
View File

@ -4,9 +4,10 @@
Uber Quest Management.
=================================================================*/
#pragma once
#include "common.h"
extern bool active_UberQuest;
void Install_UberQuest();

7
PlugY/updateClient.h
View File

@ -4,13 +4,12 @@
Updating Client.
=================================================================*/
#ifndef __UPDATECLIENT_H__INCLUDED
#define __UPDATECLIENT_H__INCLUDED
#pragma once
#include "common.h"
void Install_UpdateClient();
void updateClient(Unit* ptChar, DWORD mFunc, DWORD p1, DWORD p2, DWORD p3);
void updateClient(Unit* ptChar, DWORD mFunc, char* msg);
#endif
/*================================= END OF FILE =================================*/

2
PlugY/updateServer.h
View File

@ -4,11 +4,9 @@
Updating Server.
=================================================================*/
#pragma once
#include "common.h"
#include "D2functions.h"
__inline void updateServer(WORD p) {if (!onRealm) D2SendToServer3(0x3A, p);};
void Install_UpdateServer();

Some files were not shown because too many files have changed in this diff Show More