hash/plugy
1
0
Fork 0
mirror of https://gitlab.com/hashborgir/plugy.git synced 2025-04-28 15:25:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: hash:11.01
Branches Tags
hash:master
hash:v14.03
hash:v14.02
hash:v14.01
hash:v14.00
hash:12.00
hash:11.02
hash:11.01
hash:10.01
hash:11.00
hash:10.00
...
compare: hash:master
Branches Tags
hash:master
hash:v14.03
hash:v14.02
hash:v14.01
hash:v14.00
hash:12.00
hash:11.02
hash:11.01
hash:10.01
hash:11.00
hash:10.00

58 Commits
11.01 ... master

Author SHA1 Message Date
Hash Borgir
e89cfad117 Text justified in tips, works fine. 2024-05-01 15:35:48 -06:00
Hash Borgir
f3b0abf9ab Working, but needs tweak 2024-04-19 05:47:43 -06:00
Hash Borgir
9a858693c5 Working tips timer, just need to display long tips on two lines. 2024-04-19 04:03:20 -06:00
Hash Borgir
6bef4f86c8 Shorter Stash Tips WCHAR tips[1024][256] 2024-04-05 00:25:12 -06:00
Hash Borgir
3b06e3ad08 Initial Commit of HCB PlugY for Ironman 2024-04-05 00:19:46 -06:00
Hash Borgir
8a3841f49b Initial Commit of HCB PlugY for Ironman 2024-04-05 00:17:33 -06:00
ChaosMarc
64792db947
v14.03 by Yohann 2021-09-01 09:40:52 +02:00
ChaosMarc
e9fe6cb433
v14.02 by Yohann 2021-04-24 13:13:48 +02:00
ChaosMarc
a1e3cac784
Readme Translation 2021-01-04 21:32:06 +01:00
ChaosMarc
b6e0436944
v14.01 by Yohann 2021-01-04 21:29:37 +01:00
ChaosMarc
2597bc3946
v14.00 by Yohann 2021-01-04 08:07:29 +01:00
ChaosMarc
c8849ef0fa
Fix: Multiplayer not working 2020-11-16 09:16:48 +01:00
ChaosMarc
9c23f48faf
Fix: Launch parameter not working 2020-11-16 09:13:52 +01:00
markm11
c66c4cfe5b Multiplayer not working #35 2020-11-15 09:17:41 -05:00
markm11
bdb13151cf Fixed issue with not loading plugy files when -direct -txt is used. 2020-11-14 07:43:50 -05:00
markm11
fc8c4a8a15 Files in the \data\global\excel are not working 2020-11-13 19:12:12 -05:00
ChaosMarc
a9ab308da4
Merge pull request #29 from Snapchip/#28 2020-11-09 09:29:56 +01:00
ChaosMarc
ec9e6c7089
Merge pull request #30 from markm11/ChaosMarcMirror 2020-11-09 09:29:09 +01:00
ChaosMarc
9a7c818d37
Merge pull request #31 from markm11/ChaosMarcMirror2 2020-11-09 09:28:34 +01:00
markm11
a44e3be492 Crash when freeing custom libraries 2020-11-06 14:38:54 -05:00
markm11
f834ce7755 Crash when freeing custom libraries 2020-11-06 13:35:41 -05:00
markm11
f0ceac1d92 Unassign Skill Points button crashes every time 2020-11-06 13:22:09 -05:00
Snapchip
f1472e74d1 fixes #28 2020-11-06 12:49:33 +02:00
ChaosMarc
e0472480c4
Fixed PlugYInstaller Project 2020-11-01 12:52:36 +01:00
ChaosMarc
1657f9ca6c
fix french installer translation 2020-10-31 19:50:36 +01:00
ChaosMarc
f6848c515c
fix russian installer translation 2020-10-31 19:03:27 +01:00
ChaosMarc
779ec95c3d
Added german installer translation 2020-10-31 18:59:35 +01:00
ChaosMarc
d0a28e23d1
Encoding + typo fixes 2020-10-31 18:15:25 +01:00
ChaosMarc
2ae254ab43
Fix #23 ActiveSkillsUnassignmentOneForOne -> ActiveSkillsUnassignmentOneByOne 2020-10-31 16:03:28 +01:00
ChaosMarc
17b5d682c8
Update README.md 2020-10-25 16:32:42 +01:00
ChaosMarc
f35d9790d7
Version Bump + Readme Update 2020-10-25 15:05:32 +01:00
ChaosMarc
10df6a86b7
Merge Fix 2020-10-25 14:13:59 +01:00
ChaosMarc
6246f98247
Update to Visual Studio 2019 2020-10-25 14:10:47 +01:00
ChaosMarc
93aaeb0b61
Merged haxifix/PlugY + Code Formatting 2020-10-25 14:10:17 +01:00
ChaosMarc
9c3a7a01c3
fixed POEditor project url 2020-05-22 19:35:47 +02:00
ChaosMarc
bb7eac37f4
Updated README.md 2020-05-22 19:31:41 +02:00
ChaosMarc
e8dc732f2c
Fix #21 and added python script to create LocalizedStrings.ini from poeditor json files 2020-05-22 19:18:59 +02:00
ChaosMarc
c982875959 Added translations in POEditor (https://poeditor.com/) format 2020-05-20 12:44:04 +02:00
ChaosMarc
29cbdbe028
Merge pull request #18 from CaiMiao/master 
Update LocalizedStrings.ini
 2018-12-26 23:21:20 +01:00
Fumii Chuu
c0ab93847c
Update LocalizedStrings.ini 
fix chinese and add japanese string
 2018-12-26 18:42:37 +08:00
ChaosMarc
0116cb44b4
Merge tag '11.02' 2018-05-22 16:22:51 +02:00
ChaosMarc
a0c5ef7c9f
Revert "Create D2Funcs_pre114.h" 
This reverts commit d2b9c9c06b222b5dc83247341c4d3b12212c9338.
 2018-05-22 16:05:53 +02:00
ChaosMarc
3f25bf1b0a
Revert "Update D2Funcs_pre114.h" 
This reverts commit 722e7c2046f3f489393c678fb5ccab90db501ef1.
 2018-05-22 16:05:37 +02:00
ChaosMarc
9a05a42243
Revert "Update D2Funcs_pre114.h" 
This reverts commit 1abbd073f97fcd6e74eabb7c589cebc45ed9010b.
 2018-05-22 16:05:22 +02:00
ChaosMarc
1f7ae685b6
Revert "Update D2Funcs_pre114.h" 
This reverts commit ac348b8cb730a10201b82d20d47cddfcff2d93bc.
 2018-05-22 16:05:03 +02:00
ChaosMarc
58c251230c Fixes typo in german translation mentioned in #7 2017-06-19 15:22:18 +02:00
ChaosMarc
857834bc82 updated to v11.02 by Yohann 2017-06-19 15:01:03 +02:00
ChaosMarc
825a51f608 Removed N° from stash page string (fixes #5) 
The ° symbol broke mods with truncated custom fonts. Also the spelling N° / No. is not applicable to all languages.
 2017-05-08 09:34:13 +02:00
LAutour
ac348b8cb7 Update D2Funcs_pre114.h 2017-02-26 23:52:22 +05:00
LAutour
1abbd073f9 Update D2Funcs_pre114.h 2017-02-25 17:45:08 +05:00
LAutour
722e7c2046 Update D2Funcs_pre114.h 2017-02-24 22:53:56 +05:00
LAutour
b9f766313b Update LocalizedStrings.ini 2017-02-24 22:09:59 +05:00
LAutour
d2b9c9c06b Create D2Funcs_pre114.h 2017-02-24 21:55:49 +05:00
ChaosMarc
d743794477 Fix bullet points in README 2017-01-24 11:15:52 +01:00
ChaosMarc
0e1a9d449e Updated README 2017-01-24 11:13:18 +01:00
ChaosMarc
4a0ba8e2c9 Translated new lines in PlugY_The_Survival_Kit_-_Liesmich.txt 2017-01-24 11:10:15 +01:00
ChaosMarc
d1bf1eb471 Update PlugY_The_Survival_Kit_-_Liesmich.txt (DerWeedologe's original commit 6b98f2566fea7f06675de150856549ef4ac234c8) 2017-01-24 10:41:29 +01:00
ChaosMarc
3d4273028a Update Chinese translation (tytannial's original commit f97c173282d4716aa9b529e977213a5add3418dd) 2017-01-24 10:37:54 +01:00
100 changed files with 10476 additions and 4471 deletions
Show Stats Expand all files Collapse all files

14
.gitignore vendored
View File

@ -26,3 +26,17 @@
*.exe *.exe
*.out *.out
*.app *.app
**/*.zip
.idea
**/.vs
**/Release/
**/*.vcxproj
**/*.vcxproj.filters
**/*.vcxproj.user
**/*.VC.db
**/*.VC.VC.opendb
**/UpgradeLog*
/PlugYRun/PlugYRun.aps
PlugY/Debug/

286
ASLR_fix.patch Normal file
View File

@ -0,0 +1,286 @@
diff --git a/PlugY/D2wrapper.cpp b/PlugY/D2wrapper.cpp
index d13608e..ffd02f2 100644
--- a/PlugY/D2wrapper.cpp
+++ b/PlugY/D2wrapper.cpp
@@ -291,6 +291,7 @@ void loadCustomLibraries()
log_msg("\n\n");
}
+/*
void loadLibrary(LPCSTR libName, int* libVersion, DWORD* libOffset, int shift, DWORD v109b, DWORD v109d, DWORD v110, DWORD v111, DWORD v111b, DWORD v112, DWORD v113c)
{
*libOffset = (DWORD)LoadLibrary(libName);
@@ -386,6 +387,273 @@ void initD2modules()
log_msg("\n\n");
}
+*/
+
+IMAGE_NT_HEADERS* GetHeader(LPBYTE pBase) {
+ if (pBase == NULL)
+ return NULL;
+
+ IMAGE_DOS_HEADER* pDosHeader = (IMAGE_DOS_HEADER*)pBase;
+
+ if (IsBadReadPtr(pDosHeader, sizeof(IMAGE_DOS_HEADER)))
+ return NULL;
+
+ if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
+ return NULL;
+
+ IMAGE_NT_HEADERS* pHeader = (IMAGE_NT_HEADERS*)(pBase + pDosHeader->e_lfanew);
+ if (IsBadReadPtr(pHeader, sizeof(IMAGE_NT_HEADERS)))
+ return NULL;
+
+ if (pHeader->Signature != IMAGE_NT_SIGNATURE)
+ return NULL;
+
+ return pHeader;
+}
+
+void initD2modules()
+{
+ log_msg("***** Get D2 Modules address and version *****\n\n");
+
+ offset_D2Client = (DWORD)LoadLibrary("D2Client.dll");
+ offset_D2CMP = (DWORD)LoadLibrary("D2CMP.dll");
+ offset_D2Common = (DWORD)LoadLibrary("D2Common.dll");
+ offset_D2Game = (DWORD)LoadLibrary("D2Game.dll");
+ offset_D2gfx = (DWORD)LoadLibrary("D2gfx.dll");
+ offset_D2Lang = (DWORD)LoadLibrary("D2Lang.dll");
+ offset_D2Launch = (DWORD)LoadLibrary("D2Launch.dll");
+ offset_D2Net = (DWORD)LoadLibrary("D2Net.dll");
+ offset_D2Win = (DWORD)LoadLibrary("D2Win.dll");
+ offset_Fog = (DWORD)LoadLibrary("Fog.dll");
+ offset_Storm = (DWORD)LoadLibrary("Storm.dll");
+
+ int count_109b = 0;
+ int count_109d = 0;
+ int count_110f = 0;
+ int count_111 = 0;
+ int count_111b = 0;
+ int count_112a = 0;
+ int count_113c = 0;
+ int count_113d = 0;
+ int count_114a = 0;
+ int count_114b = 0;
+ int count_114c = 0;
+ int count_114d = 0;
+
+ IMAGE_NT_HEADERS* pHeader;
+
+ if (offset_D2Client != NULL) {
+ pHeader = GetHeader((LPBYTE)offset_D2Client);
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000C234D) count_109b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000C16CD) count_109d++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000C1C1D) count_110f++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000045E6) count_111++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000045EE) count_111b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000045FA) count_112a++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000045F6) count_113c++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000045DE) count_113d++;
+ }
+
+ if (offset_D2CMP != NULL) {
+ pHeader = GetHeader((LPBYTE)offset_D2CMP);
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00011361) count_109b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00011361) count_109d++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00010E61) count_110f++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C23) count_111++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C23) count_111b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C23) count_112a++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C23) count_113c++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C23) count_113d++;
+ }
+
+ if (offset_D2Common != NULL) {
+ pHeader = GetHeader((LPBYTE)offset_D2Common);
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00074D1D) count_109b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00074E2D) count_109d++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000856DD) count_110f++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C94) count_111++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C8D) count_111b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C97) count_112a++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C8F) count_113c++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000047C7) count_113d++;
+ }
+
+ if (offset_D2Game != NULL) {
+ pHeader = GetHeader((LPBYTE)offset_D2Game);
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000C66AC) count_109b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000C6D5C) count_109d++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000EDC2C) count_110f++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000036E6) count_111++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000373D) count_111b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000374B) count_112a++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000373C) count_113c++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003747) count_113d++;
+ }
+
+ if (offset_D2gfx != NULL) {
+ pHeader = GetHeader((LPBYTE)offset_D2gfx);
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000054EB) count_109b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000054EB) count_109d++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000054A5) count_110f++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001807) count_111++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001807) count_111b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001807) count_112a++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001807) count_113c++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001807) count_113d++;
+ }
+
+ if (offset_D2Lang != NULL) {
+ pHeader = GetHeader((LPBYTE)offset_D2Lang);
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00005148) count_109b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00005138) count_109d++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00005048) count_110f++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A6A) count_111++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A5B) count_111b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A75) count_112a++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A71) count_113c++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A5A) count_113d++;
+ }
+
+ if (offset_D2Launch != NULL) {
+ pHeader = GetHeader((LPBYTE)offset_D2Launch);
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000172C3) count_109b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00017243) count_109d++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00018DC7) count_110f++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A84) count_111++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A85) count_111b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A85) count_112a++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A87) count_113c++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A84) count_113d++;
+ }
+
+ if (offset_D2Net != NULL) {
+ pHeader = GetHeader((LPBYTE)offset_D2Net);
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002BCE) count_109b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002BCE) count_109d++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C6E) count_110f++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001676) count_111++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001676) count_111b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000167E) count_112a++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001676) count_113c++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000167E) count_113d++;
+ }
+
+ if (offset_D2Win != NULL) {
+ pHeader = GetHeader((LPBYTE)offset_D2Win);
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00014F38) count_109b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00014F38) count_109d++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00012EC0) count_110f++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000187E) count_111++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000187E) count_111b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000188E) count_112a++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000187E) count_113c++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001887) count_113d++;
+ }
+
+ if (offset_Fog != NULL) {
+ pHeader = GetHeader((LPBYTE)offset_Fog);
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00013658) count_109b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000142E7) count_109d++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000162B0) count_110f++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003159) count_111++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003142) count_111b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000314A) count_112a++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003162) count_113c++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003142) count_113d++;
+ }
+
+ if (offset_Storm != NULL) {
+ pHeader = GetHeader((LPBYTE)offset_Storm);
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00013658) count_109b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000142E7) count_109d++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000162B0) count_110f++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003159) count_111++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003142) count_111b++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000314A) count_112a++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003162) count_113c++;
+ if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0003C3E0) count_113d++;
+ }
+
+ int minimum_match_dll = 7;
+
+ if (count_109b >= minimum_match_dll) version_Game = V109b;
+ if (count_109d >= minimum_match_dll) version_Game = V109d;
+ if (count_110f >= minimum_match_dll) version_Game = V110;
+ if (count_111 >= minimum_match_dll) version_Game = V111;
+ if (count_111b >= minimum_match_dll) version_Game = V111b;
+ if (count_112a >= minimum_match_dll) version_Game = V112;
+ if (count_113c >= minimum_match_dll) version_Game = V113c;
+ if (count_113d >= minimum_match_dll) version_Game = V113d;
+
+ //version_SmackW32 = version_Game;
+ version_D2Common = version_Game;
+ //version_ijl11 = version_Game;
+ //version_D2Gdi = version_Game;
+ version_D2Win = version_Game;
+ //version_D2sound = version_Game;
+ //version_D2MCPCLI = version_Game;
+ version_D2Launch = version_Game;
+ version_D2gfx = version_Game;
+ version_D2Client = version_Game;
+ version_D2Net = version_Game;
+ version_D2Lang = version_Game;
+ version_D2Game = version_Game;
+ version_D2CMP = version_Game;
+ //version_Bnclient = version;
+ version_Fog = version_Game;
+ version_Storm = version_Game;
+
+ log_msg("DLL match for version 1.09b :\t%d\n", count_109b);
+ log_msg("DLL match for version 1.09d :\t%d\n", count_109d);
+ log_msg("DLL match for version 1.10f :\t%d\n", count_110f);
+ log_msg("DLL match for version 1.11 :\t%d\n", count_111);
+ log_msg("DLL match for version 1.11b :\t%d\n", count_111b);
+ log_msg("DLL match for version 1.12a :\t%d\n", count_112a);
+ log_msg("DLL match for version 1.13c :\t%d\n", count_113c);
+ log_msg("\n");
+
+ offset_Game = (DWORD)GetModuleHandle("Game.exe");
+ if (offset_Game != NULL) {
+ version_Game = GetD2Version((HMODULE)offset_Game);
+ log_msg("Game.exe loaded at:\t%08X (%s)\n", offset_Game, GetVersionString(version_Game));
+ if (version_Game >= V114a)
+ {
+ //version_SmackW32 = version_Game;
+ version_D2Common = version_Game;
+ //version_ijl11 = version_Game;
+ //version_D2Gdi = version_Game;
+ version_D2Win = version_Game;
+ //version_D2sound = version_Game;
+ //version_D2MCPCLI = version_Game;
+ version_D2Launch = version_Game;
+ version_D2gfx = version_Game;
+ version_D2Client = version_Game;
+ version_D2Net = version_Game;
+ version_D2Lang = version_Game;
+ version_D2Game = version_Game;
+ version_D2CMP = version_Game;
+ //version_Bnclient = version;
+ version_Fog = version_Game;
+ version_Storm = version_Game;
+ }
+ }
+
+ //if (offset_Game != NULL) {
+ // pHeader = GetHeader((LPBYTE)offset_Game);
+ // if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00291342) count_114a++;
+ // if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x002854F2) count_114b++;
+ // if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x002850E2) count_114c++;
+ // if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00282985) count_114d++;
+ //}
+
+ log_msg("Version game is:\t(%s)\n\n", GetVersionString(version_Game));
+
+ if (version_Game == UNKNOWN)
+ {
+ MessageBoxA(NULL, "This version of Diablo II is not supported by Plugy. Please upgrade or downgrade to a supported version.", "Plugy 14.03", MB_OK);
+ }
+}
+
//////////////////////////////////// EXPORTS FUNCTIONS ////////////////////////////////////

585
Commons/D2Funcs.h
View File

@ -1,6 +1,7 @@
/*====================================================================== /*======================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Declares the type for a STDCALL or FASTCALL function pointer Declares the type for a STDCALL or FASTCALL function pointer
called N with arguments list P, returning R, namedInDLL D and at @A called N with arguments list P, returning R, namedInDLL D and at @A
@ -20,7 +21,7 @@
//D2S(D2Common,11068, DWORD, D2InvAddItem, (Inventory* ptInventory, Unit* ptItem, DWORD posX, DWORD posY, DWORD vValueC, DWORD bIsClient, BYTE page));//ONLY 1.11b result : boolean 0=echec ; vValueC = 0 for Game.dll, 1 for Clientdll //D2S(D2Common,11068, DWORD, D2InvAddItem, (Inventory* ptInventory, Unit* ptItem, DWORD posX, DWORD posY, DWORD vValueC, DWORD bIsClient, BYTE page));//ONLY 1.11b result : boolean 0=echec ; vValueC = 0 for Game.dll, 1 for Clientdll
//D2S(D2Common,10250, 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 //D2S(D2Common,10250, 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
////D2S(D2Common,10257, Unit*, D2GetItemFromBodyLoc, (Inventory* ptInventory, DWORD bodyloc)); ////D2S(D2Common,10257, Unit*, D2GetItemFromBodyLoc, (Inventory* ptInventory, DWORD bodyloc));
//D2S(D2Common,10273, DWORD, D2Common10273, (Inventory* ptInventory, void* unknow)); //D2S(D2Common,10273, DWORD, D2Common10273, (Inventory* ptInventory, void* unknown));
//D2S(D2Common,10535, Unit*, D2InventoryGetFirstItem, (Inventory* ptInventory));//ONLY 1.11b //D2S(D2Common,10535, Unit*, D2InventoryGetFirstItem, (Inventory* ptInventory));//ONLY 1.11b
//D2S(D2Common,11140, Unit*, D2UnitGetNextItem, (Unit* ptItem));//ONLY 1.11b //D2S(D2Common,11140, Unit*, D2UnitGetNextItem, (Unit* ptItem));//ONLY 1.11b
//D2S(D2Common,10748, Unit*, D2GetRealItem, (Unit* ptUnit));//ONLY 1.11b //D2S(D2Common,10748, Unit*, D2GetRealItem, (Unit* ptUnit));//ONLY 1.11b
@ -148,143 +149,143 @@
//F7(STD, D2Common,00000,00000,00000,00000,10001,00000,00000,00000, DWORD, D2GetActIDFromLevel, (DWORD levelID)); //F8(STD, D2Common,00000,00000,00000,00000,10001,00000,00000,00000,00000, DWORD, D2GetActIDFromLevel, (DWORD levelID));
F7(STD, D2Common,00000,00000,00000,10188,11084,11109,10346,10907, DWORD, D2Common11084, (Room* ptRoom, DWORD zero)); F8(STD, D2Common,00000,00000,00000,10188,11084,11109,10346,10907,21AED0, DWORD, D2Common11084, (Room* ptRoom, DWORD zero));
F7(STD, D2Common,10057,10057,10057,10332,11021,10511,10826,10691, DWORD, D2GetLevelID, (Room* ptRoom)); F8(STD, D2Common,10057,10057,10057,10332,11021,10511,10826,10691,21A1B0, 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)); F8(STD, D2Common,10138,10138,10138,10623,10491,11043,10654,10716,24E810, Room*, D2GetDropRoom, (Room* ptRoom, Position*, Position*, DWORD, DWORD, DWORD, DWORD));
//F7(STD, D2Common,10149,10149,10149,00000,00000,00000,00000,00000, Inventory*, D2GetInventory, (Unit* ptUnit)); //F8(STD, D2Common,10149,10149,10149,00000,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)); F8(STD, D2Common,10242,10242,10242,00000,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)); F8(STD, D2Common,10246,10246,10246,10855,10813,10289,10133,10402,23B950, 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)); F8(STD, D2Common,10243,10243,10243,10461,10827,10936,10646,10490,23AD90, 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 F8(STD, D2Common,10249,10249,10249,10880,11068,10436,11107,10963,23BCC0, 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 F8(STD, D2Common,10250,10250,10250,00000,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,00000, Unit*, D2GetItemFromBodyLoc, (Inventory* ptInventory, DWORD bodyloc)); //F8(STD, D2Common,10257,10257,10257,00000,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)); F8(STD, D2Common,10273,10273,10273,00000,00000,00000,00000,00000,00000, DWORD, D2Common10273, (Inventory* ptInventory, void* unknown));
F7(STD, D2Common,10277,10277,10277,10402,10535,11151,10460,11040, Unit*, D2InventoryGetFirstItem, (Inventory* ptInventory)); F8(STD, D2Common,10277,10277,10277,10402,10535,11151,10460,11040,23B2C0, Unit*, D2InventoryGetFirstItem, (Inventory* ptInventory));
F7(STD, D2Common,10304,10304,10304,10934,11140,10770,10464,10879, Unit*, D2UnitGetNextItem, (Unit* ptItem)); F8(STD, D2Common,10304,10304,10304,10934,11140,10770,10464,10879,23DFA0, Unit*, D2UnitGetNextItem, (Unit* ptItem));
F7(STD, D2Common,10305,10305,10305,11095,10748,10852,11147,10897, Unit*, D2GetRealItem, (Unit* ptUnit)); F8(STD, D2Common,10305,10305,10305,11095,10748,10852,11147,10897,23DFD0, Unit*, D2GetRealItem, (Unit* ptUnit));
//F7(STD, D2Common,10321,10321,10321,00000,00000,00000,00000,00000, SkillData*, D2GetLeftSkill, (Unit* ptChar)); //F8(STD, D2Common,10321,10321,10321,00000,00000,00000,00000,00000,00000, SkillData*, D2GetLeftSkill, (Unit* ptChar));
//F7(STD, D2Common,10322,10322,10322,00000,00000,00000,00000,00000, SkillData*, D2GetRightSkill, (Unit* ptChar)); //F8(STD, D2Common,10322,10322,10322,00000,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 F8(STD, D2Common,10326,10326,00000,00000,00000,00000,00000,00000,00000, DWORD, D2GetPosX, (Unit* ptUnit));//NOT IN 1.10
//F7(STD, D2Common,10328,10328,10328,00000,00000,00000,00000,00000, void, D2SetPosX, (Unit* ptUnit, DWORD pos)); //F8(STD, D2Common,10328,10328,10328,00000,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 F8(STD, D2Common,10329,10329,00000,00000,00000,00000,00000,00000,00000, DWORD, D2GetPosY, (Unit* ptUnit));//NOT IN 1.10
//F7(STD, D2Common,10331,10331,10331,00000,00000,00000,00000,00000, void, D2SetPosY, (Unit* ptUnit, DWORD pos)); //F8(STD, D2Common,10331,10331,10331,00000,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)); F8(STD, D2Common,10332,10332,10332,11080,10056,10543,10141,11166,220870, void, D2GetPosition, (Unit* ptUnit, Position* pos));
F7(STD, D2Common,10339,10339,10339,10455,10864,10941,11060,11025, DWORD, D2GetMaxGoldBank, (Unit* ptUnit)); F8(STD, D2Common,10339,10339,10339,10455,10864,10941,11060,11025,223460, DWORD, D2GetMaxGoldBank, (Unit* ptUnit));
F7(STD, D2Common,10342,10342,10342,10172,10933,10366,10331,10846, Room*, D2GetRoom, (Unit* ptUnit)); F8(STD, D2Common,10342,10342,10342,10172,10933,10366,10331,10846,220BB0, Room*, D2GetRoom, (Unit* ptUnit));
//F7(STD, D2Common,10348,10348,10348,00000,00000,00000,00000,00000, void, D2SetUnitMode, (Unit* ptUnit, DWORD mode)); //F8(STD, D2Common,10348,10348,10348,00000,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)); //F8(STD, D2Common,10394,10394,10394,00000,00000,00000,00000,00000,00000, ObjectsBIN*,D2GetObjectsBIN, (Unit* ptObject));
F7(STD, D2Common,10420,10420,10420,10218,10079,11097,10356,10404, PlayerData*,D2InitPlayerData, (Unit* ptChar)); F8(STD, D2Common,10420,10420,10420,10218,10079,11097,10356,10404,221F90, PlayerData*,D2InitPlayerData, (Unit* ptChar));
//F7(STD, D2Common,10421,10421,10421,10914,10329,00000,00000,00000, DWORD, D2FreePlayerData, (DWORD game1C, Unit* ptChar)); //F8(STD, D2Common,10421,10421,10421,10914,10329,00000,00000,00000,00000, DWORD, D2FreePlayerData, (DWORD game1C, Unit* ptChar));
F7(STD, D2Common,10424,10424,10424,10562,10800,10860,10920,11103, PlayerData*,D2GetPlayerData, (Unit* ptChar)); F8(STD, D2Common,10424,10424,10424,10562,10800,10860,10920,11103,2221A0, PlayerData*,D2GetPlayerData, (Unit* ptChar));
F7(STD, D2Common,10431,10431,10431,00000,00000,00000,00000,00000, DWORD, D2GetDefence, (Unit* ptChar)); F8(STD, D2Common,10431,10431,10431,00000,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)); F8(STD, D2Common,10433,10433,10433,00000,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)); F8(STD, D2Common,10439,10439,10439,10343,11131,10729,10049,11159,222E70, DWORD, D2GetMaxGold, (Unit* ptUnit));
F7(STD, D2Common,00000,00000,00000,10440,10572,10481,11090,10193, DWORD, D2Common10572, (Unit* ptObject, DWORD value)); F8(STD, D2Common,00000,00000,00000,10440,10572,10481,11090,10193,224690, DWORD, D2Common10572, (Unit* ptObject, DWORD value));
//F7(STD, D2Common,10463,10463,10463,00000,00000,00000,00000,00000, DWORD, D2SetStatWithNoTest, ( Stats* ptStats, DWORD statID, DWORD statValue, DWORD statIndex)); //F8(STD, D2Common,10463,10463,10463,00000,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)); //F8(STD, D2Common,10464,10464,10464,00000,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)); //F8(STD, D2Common,10465,10465,10465,00000,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)); //F8(STD, D2Common,10466,10466,10466,00000,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)); //F8(STD, D2Common,10470,10470,10470,00000,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)); F8(STD, D2Common,00000,00000,00000,10471,11160,10866,10258,10040,2222C0, BYTE, D2GetObjectFlags, (Unit* ptObject));
F7(STD, D2Common,00000,00000,00000,10572,11048,10150,10111,10033, void, D2SetObjectFlags, (Unit* ptObject, BYTE flags)); F8(STD, D2Common,00000,00000,00000,10572,11048,10150,10111,10033,222300, void, D2SetObjectFlags, (Unit* ptObject, BYTE flags));
//F7(STD, D2Common,10471,10471,10471,00000,00000,00000,00000,00000, DWORD, D2Common10471, (void*)); //F8(STD, D2Common,10471,10471,10471,00000,00000,00000,00000,00000,00000, DWORD, D2Common10471, (void*));
//F7(STD, D2Common,10472,10472,10472,00000,00000,00000,00000,00000, DWORD, D2Common10472, (void*)); //F8(STD, D2Common,10472,10472,10472,00000,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)); //F8(STD, D2Common,10475,10475,10475,00000,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)); //F8(STD, D2Common,10481,10481,10481,00000,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)); //F8(STD, D2Common,10484,10484,10484,00000,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)); //F8(STD, D2Common,10485,10485,10485,00000,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)); F8(STD, D2Common,10487,10487,10487,00000,00000,00000,00000,00000,00000, DWORD, D2isInState, (Unit* ptChar, DWORD isLODGame));
//F7(STD, D2Common,10517,10517,10517,00000,00000,00000,00000,00000, void, D2SetPlayerStat, (Unit* ptChar, DWORD statID, int amount, DWORD index)); //F8(STD, D2Common,10517,10517,10517,00000,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 F8(STD, D2Common,10518,10518,10518,10109,10627,10762,10551,10645,2272B0, 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 F8(STD, D2Common,10519,10519,10519,11092,10061,10658,10973,10550,225480, int, D2GetPlayerStat, (Unit* ptChar, DWORD statID, DWORD index));//ONLY 1.11b
//F7(STD, D2Common,10520,10520,10520,00000,00000,00000,00000,00000, int, D2GetPlayerStat20, (Unit* ptChar, DWORD statID, DWORD index)); //F8(STD, D2Common,10520,10520,10520,00000,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 F8(STD, D2Common,10521,10521,10521,10733,10550,10494,10587,10216,2253B0, int, D2GetPlayerBaseStat, (Unit* ptChar, DWORD statID, DWORD index));//ONLY 1.11b
//F7(STD, D2Common,10527,10527,10527,00000,00000,00000,00000,00000, DWORD, D2Common10527, (Unit* ptUnit)); //F8(STD, D2Common,10527,10527,10527,00000,00000,00000,00000,00000,00000, DWORD, D2Common10527, (Unit* ptUnit));
F7(STD, D2Common,10539,10539,10539,00000,00000,00000,00000,00000, DWORD, D2haveDefenceBonus, (Unit* ptChar)); F8(STD, D2Common,10539,10539,10539,00000,00000,00000,00000,00000,00000, DWORD, D2haveDefenceBonus, (Unit* ptChar));
F7(STD, D2Common,10540,10540,10540,00000,00000,00000,00000,00000, DWORD, D2haveFireResBonus, (Unit* ptChar)); F8(STD, D2Common,10540,10540,10540,00000,00000,00000,00000,00000,00000, DWORD, D2haveFireResBonus, (Unit* ptChar));
F7(STD, D2Common,10541,10541,10541,00000,00000,00000,00000,00000, DWORD, D2haveColdResBonus, (Unit* ptChar)); F8(STD, D2Common,10541,10541,10541,00000,00000,00000,00000,00000,00000, DWORD, D2haveColdResBonus, (Unit* ptChar));
F7(STD, D2Common,10542,10542,10542,00000,00000,00000,00000,00000, DWORD, D2haveLightResBonus, (Unit* ptChar)); F8(STD, D2Common,10542,10542,10542,00000,00000,00000,00000,00000,00000, DWORD, D2haveLightResBonus, (Unit* ptChar));
F7(STD, D2Common,10543,10543,10543,00000,00000,00000,00000,00000, DWORD, D2havePoisonResBonus, (Unit* ptChar)); F8(STD, D2Common,10543,10543,10543,00000,00000,00000,00000,00000,00000, DWORD, D2havePoisonResBonus, (Unit* ptChar));
F7(STD, D2Common,10546,10546,10546,00000,00000,00000,00000,00000, DWORD, D2haveDefenceMalus, (Unit* ptChar)); F8(STD, D2Common,10546,10546,10546,00000,00000,00000,00000,00000,00000, DWORD, D2haveDefenceMalus, (Unit* ptChar));
F7(STD, D2Common,10547,10547,10547,00000,00000,00000,00000,00000, DWORD, D2haveFireResMalus, (Unit* ptChar)); F8(STD, D2Common,10547,10547,10547,00000,00000,00000,00000,00000,00000, DWORD, D2haveFireResMalus, (Unit* ptChar));
F7(STD, D2Common,10548,10548,10548,00000,00000,00000,00000,00000, DWORD, D2haveColdResMalus, (Unit* ptChar)); F8(STD, D2Common,10548,10548,10548,00000,00000,00000,00000,00000,00000, DWORD, D2haveColdResMalus, (Unit* ptChar));
F7(STD, D2Common,10549,10549,10549,00000,00000,00000,00000,00000, DWORD, D2haveLightResMalus, (Unit* ptChar)); F8(STD, D2Common,10549,10549,10549,00000,00000,00000,00000,00000,00000, DWORD, D2haveLightResMalus, (Unit* ptChar));
F7(STD, D2Common,10550,10550,10550,00000,00000,00000,00000,00000, DWORD, D2havePoisonResMalus, (Unit* ptChar)); F8(STD, D2Common,10550,10550,10550,00000,00000,00000,00000,00000,00000, DWORD, D2havePoisonResMalus, (Unit* ptChar));
//F7(STD, D2Common,10552,10552,10552,00000,00000,00000,00000,00000, DWORD, D2Common10552, (Unit* ptUnit)); //F8(STD, D2Common,10552,10552,10552,00000,00000,00000,00000,00000,00000, DWORD, D2Common10552, (Unit* ptUnit));
//F7(STD, D2Common,10567,10567,10567,00000,00000,00000,00000,00000, DWORD, D2CanBeBroken, (Unit* ptItem)); //F8(STD, D2Common,10567,10567,10567,00000,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)); //F8(STD, D2Common,10573,10573,10573,00000,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)); //F8(STD, D2Common,10574,10574,10574,00000,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, ()); //F8(STD, D2Common,10575,10575,10575,00000,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)); //F8(STD, D2Common,10576,10576,10576,00000,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)); //F8(STD, D2Common,00000,00000,00000,10651,10651,00000,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)); F8(STD, D2Common,10578,10578,10578,10653,10496,10244,10849,10037,2122F0, 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)); F8(STD, D2Common,10600,10600,10600,10573,10262,10887,10695,10994,2335F0, ItemsBIN*, D2GetItemsBIN, (DWORD itemID));
//F7(STD, D2Common,10601,10601,10601,00000,00000,00000,00000,00000, ItemsBIN*, D2GetByCodeItemStatsBIN, (DWORD code, DWORD* itemID)); //F8(STD, D2Common,10601,10601,10601,00000,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)); //F8(STD, D2Common,10604,10604,10604,00000,00000,00000,00000,00000,00000, AffixBIN*, D2GetAffixBIN, (int affixID));
F7(STD, D2Common,10616,10616,10616,10500,10523,10774,10806,10619, GemsBIN*, D2GetGemsBIN, (DWORD gemID)); F8(STD, D2Common,10616,10616,10616,10500,10523,10774,10806,10619,2372C0, GemsBIN*, D2GetGemsBIN, (DWORD gemID));
F7(STD, D2Common,11232,11232,11232,10746,10258,10913,10783,10393, CubeMainBIN*,D2GetCubeMainBIN, (DWORD cubemainID)); F8(STD, D2Common,11232,11232,11232,10746,10258,10913,10783,10393,26A1B0, CubeMainBIN*,D2GetCubeMainBIN, (DWORD cubemainID));
F7(STD, D2Common,11233,11233,11233,10639,11135,10390,10675,10235, int, D2GetNbCubeMainBIN, ()); F8(STD, D2Common,11233,11233,11233,10639,11135,10390,10675,10235,26A200, int, D2GetNbCubeMainBIN, ());
//F7(STD, D2Common,10737,10737,10737,00000,00000,00000,00000,00000, LevelsBIN*, D2GetLevelsBIN, (DWORD levelID)); //F8(STD, D2Common,10737,10737,10737,00000,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)); F8(STD, D2Common,10628,10628,10628,00000,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)); F8(STD, D2Common,10629,10629,10629,00000,00000,00000,00000,00000,00000, DWORD, D2GetMaxLevel, (DWORD classID));
F7(STD, D2Common,10655,10655,10655,10655,10309,10297,10218,10694, DifficultyLevelsBIN*, D2GetDifficultyLevelsBIN, (DWORD difficultyLevel)); F8(STD, D2Common,10655,10655,10655,10655,10309,10297,10218,10694,111D30, DifficultyLevelsBIN*, D2GetDifficultyLevelsBIN, (DWORD difficultyLevel));
//F7(STD, D2Common,10659,10659,10659,00000,00000,00000,00000,00000, TreasureClassBIN*, D2GetTreasureClassBIN, (WORD id, DWORD uk)); //F8(STD, D2Common,10659,10659,10659,00000,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)); //F8(STD, D2Common,10668,10668,10668,10450,10953,00000,00000,00000,00000, SuperUniqueBIN*, D2GetSuperUniqueBIN, (WORD id));
F7(STD, D2Common,10695,10695,10695,10927,10899,10276,10106,10911, DWORD, D2GetItemQuality, (Unit* ptItem)); F8(STD, D2Common,10695,10695,10695,10927,10899,10276,10106,10911,227E70, 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)); F8(STD, D2Common,10707,10707,10707,10911,10303,10989,10202,10458,2280A0, DWORD, D2TestFlags, (Unit* ptUnit, DWORD flags, DWORD line, const char* file));
//F7(STD, D2Common,10708,10708,10708,00000,00000,00000,00000,00000, void, D2SetFlags, (Unit* ptUnit, DWORD flags, DWORD bitNewValue)); //F8(STD, D2Common,10708,10708,10708,00000,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)); //F8(STD, D2Common,10709,10709,10709,00000,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 //F8(STD, D2Common,10711,10711,10711,00000,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)); F8(STD, D2Common,10717,10717,10717,10898,10100,10410,10086,10008,2281E0, DWORD, D2GetItemLevel, (Unit* ptItem));
F7(STD, D2Common,10719,10719,10719,10820,10505,10370,10020,10810, BYTE, D2ItemGetPage, (Unit* ptUnit)); F8(STD, D2Common,10719,10719,10719,10820,10505,10370,10020,10810,228250, BYTE, D2ItemGetPage, (Unit* ptUnit));
F7(STD, D2Common,10720,10720,10720,10485,10608,10223,10012,11026, void, D2ItemSetPage, (Unit* ptItem, BYTE page)); F8(STD, D2Common,10720,10720,10720,10485,10608,10223,10012,11026,228280, void, D2ItemSetPage, (Unit* ptItem, BYTE page));
F7(STD, D2Common,10731,10731,10731,11017,10890,10231,10744,10601, DWORD, D2CheckItemType, (Unit* ptItem, DWORD itype)); F8(STD, D2Common,10731,10731,10731,11017,10890,10231,10744,10601,229BB0, DWORD, D2CheckItemType, (Unit* ptItem, DWORD itype));
F7(STD, D2Common,10732,10732,10732,10692,10685,10280,10620,10075, int, D2GetUniqueID, (Unit* ptItem)); F8(STD, D2Common,10732,10732,10732,10692,10685,10280,10620,10075,229DA0, int, D2GetUniqueID, (Unit* ptItem));
F7(STD, D2Common,10734,10734,10734,00000,00000,00000,00000,00000, void, D2SetAnim, (Unit* ptUnit, int anim)); F8(STD, D2Common,10734,10734,10734,00000,00000,00000,00000,00000,00000, void, D2SetAnim, (Unit* ptUnit, int anim));
//F7(STD, D2Common,10749,10749,10749,00000,00000,00000,00000,00000, void, D2GetWidthHeight, (Unit* ptItem, BYTE* Width, BYTE* Height); //F8(STD, D2Common,10749,10749,10749,00000,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)); //F8(STD, D2Common,10751,10751,10751,00000,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)); //F8(STD, D2Common,10757,10757,10757,00000,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 F8(STD, D2Common,10619,10619,10619,10687,10877,10321,11032,10981,239CB0, int*, D2GetNbRunesBIN, ());//return the point on th number
F7(STD, D2Common,10620,10620,10620,10775,10296,10622,10006,10405, RunesBIN*, D2GetRunesBIN, (int runesID)); F8(STD, D2Common,10620,10620,10620,10775,10296,10622,10006,10405,239D60, RunesBIN*, D2GetRunesBIN, (int runesID));
//F7(STD, D2Common,10792,10792,10792,00000,00000,00000,00000,00000, DWORD, D2CanBeRare, (Unit* ptItem)); //F8(STD, D2Common,10792,10792,10792,00000,00000,00000,00000,00000,00000, DWORD, D2CanBeRare, (Unit* ptItem));
//F7(STD, D2Common,10810,10810,10810,00000,00000,00000,00000,00000, BYTE, D2CheckHasInv, (Unit* ptItem)); //F8(STD, D2Common,10810,10810,10810,00000,00000,00000,00000,00000,00000, BYTE, D2CheckHasInv, (Unit* ptItem));
//F7(STD, D2Common,10813,10813,10813,00000,00000,00000,00000,00000, DWORD, D2GetStaffMods, (Unit* ptItem)); //F8(STD, D2Common,10813,10813,10813,00000,00000,00000,00000,00000,00000, DWORD, D2GetStaffMods, (Unit* ptItem));
//F7(STD, D2Common,10816,10816,10816,10816,11085,00000,00000,00000, DWORD, D2GetNbSocket, (Unit* ptItem)); //F8(STD, D2Common,10816,10816,10816,10816,11085,00000,00000,00000,00000, DWORD, D2GetNbSocket, (Unit* ptItem));
//F7(STD, D2Common,10840,10840,10840,00000,00000,00000,00000,00000, DWORD, D2Common10840, (Unit* ptItem, Unit* ptChar)); //F8(STD, D2Common,10840,10840,10840,00000,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)); //F8(STD, D2Common,10855,10855,10855,00000,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)); //F8(STD, D2Common,10872,10872,10872,00000,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)); //F8(STD, D2Common,10875,10875,10875,00000,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 //F8(STD, D2Common,11163,11163,11163,10880,11068,10436,11107,10963,23BCC0, 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)); F8(STD, D2Common,10881,10881,10881,10956,11156,10218,10987,10665,2313E0, DWORD, D2SaveItem, (Unit* ptItem, saveBitField* data, DWORD startSize, DWORD p4, DWORD p5, DWORD p6));
//F7(STD, D2Common,10916,10916,10916,00000,00000,00000,00000,00000, void, DoNothing916, ()); //F8(STD, D2Common,10916,10916,10916,00000,00000,00000,00000,00000,00000, void, DoNothing916, ());
//F7(STD, D2Common,10940,10940,10940,10027,10105,10953,00000,00000, void, D2Common10027, (Unit* ptChar, DWORD skillID)); //F8(STD, D2Common,10940,10940,10940,10027,10105,10953,00000,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)); //F8(STD, D2Common,10950,10950,10950,00000,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)); //F8(STD, D2Common,10952,10952,10952,10950,10256,10858,00000,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)); F8(STD, D2Common,10953,10953,10953,10099,10255,10210,10302,10335,247280, void, D2SetSkillBaseLevel,(Unit* ptChar, DWORD skillID, DWORD slvl, DWORD bRemove, char*, DWORD));
//F7(STD, D2Common,10963,10963,10963,00000,00000,00000,00000,00000, DWORD, D2GetSkillID, (SkillData* ptSkill, const char* file, DWORD line)); //F8(STD, D2Common,10963,10963,10963,00000,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)); //F8(FAST, D2Common,10966,10966,10966,00000,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)); F8(STD, D2Common,10968,10968,10968,10700,10109,10904,10306,10007,2442A0, DWORD, D2GetSkillLevel, (Unit* ptChar, SkillData* ptSkill, DWORD includingBonus));
//F7(STD, D2Common,11023,11023,11023,00000,00000,00000,00000,00000, DWORD, D2GetCriticalStrikeFromMasteries, (Unit* ptChar, Unit* ptItem, DWORD zero, DWORD two)); //F8(STD, D2Common,11023,11023,11023,00000,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)); //F8(STD, D2Common,11007,11007,11007,00000,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)); //F8(STD, D2Common,11041,11041,11041,00000,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)); //F8(STD, D2Common,11042,11042,11042,00000,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)); //F8(STD, D2Common,11269,11269,11269,00000,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)); //F8(STD, D2Common,11270,11270,11270,00000,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 F8(STD, D2Common,11276,11276,11276,10254,10074,10111,10435,11081,246CA0, 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)); A8(FAST, D2Common,00000,00000,82C80, 15D0, 1800, 1220, 12D0, 17B0, 833E0, 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)); A8(FAST, D2Common,00000,00000,12410,5D7D0,1A100,116C0,1C020,5B0E0,268600, 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)); //A8(FAST, D2Common,00000,00000,12910,5D210,19B40,11100,1BA60,5AB20,268A90, 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)); A8(FAST, D2Common,00000,00000,2B1A0, 11F0, 1380, 1140, 1300, 1160,155C90, ItemTypesBIN*, D2GetItemTypesBIN, (DWORD itemTypesId));
//A7(FAST, D2Common,00000,00000,62FD0,00000,00000,00000,00000,00000, void, D2EncodeValueCheckMax, (saveBitField* data, DWORD value, DWORD bitSize)); //A8(FAST, D2Common,00000,00000,62FD0,00000,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)); A8(FAST, D2Common,00000,00000,642B0, 13F0, 12F0, 1540, 17A0, 17E0,5C4F0, ItemStatCostBIN*,D2GetItemStatCostBIN, (DWORD id));
//A7(FAST, D2Common,00000,00000,764A0,00000,00000,00000,00000,00000, void*, D2Common764A0, (Stats* ptStats, DWORD stat, ItemStatCostBIN* itemStatCost ,DWORD)); //A8(FAST, D2Common,00000,00000,764A0,00000,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)); //A8(STD, D2Common,00000,00000,76E30,00000,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)); //A8(FAST, D2Common,00000,00000,76C10,00000,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)); A8(FAST, D2Common,738A4,739B4,84268, 96E0, 98D0, 9900, 9900, B5E0,117079, void*, D2ReadFile,(DWORD mempool, char* filename, DWORD* size, const char*, DWORD));
//A7(FAST, D2Common,00000,00000, 94D0,00000,00000,00000,00000,00000, void*, D2GetStringIDForTxtFile,(const char * string)); //A8(FAST, D2Common,00000,00000, 94D0,00000,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 A8(STD, D2Common,1F500,1F510,29FA0,71EB0,32AA0,7D2A0,59870,80C40,2552E0, void, D2LoadSuperuniques,(DWORD mempool));//FASCALL UNTIL 1.10
A8(STD, D2Common,00000,00000,00000,00000,00000,00000,81EA0,00000,00000, InventoryBIN*, D2GetInventoryBIN, ());
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//D2Client : 6FAA0000 //D2Client : 6FAA0000
@ -308,26 +309,29 @@ A7(STD, D2Common,1F500,1F510,29FA0,71EB0,32AA0,7D2A0,59870,80C40, void, D2Loa
//E2F(D2Client,5BA90, void, D2ReloadGambleScreen, ());//1.11b //E2F(D2Client,5BA90, void, D2ReloadGambleScreen, ());//1.11b
//E2F(D2Client,1FEB0, void, D2OpenNPCMenu, (Unit* ptNPC));//1.11b by ESI //E2F(D2Client,1FEB0, void, D2OpenNPCMenu, (Unit* ptNPC));//1.11b by ESI
A7(FAST, D2Client, 1000, 1000, 1000,75D00,A9070,BEF70,2B420,A9480, void*, D2LoadImage, (const char* filename, DWORD filetype)); A8(FAST, D2Client, 1000, 1000, 1000,75D00,A9070,BEF70,2B420,A9480,788B0, void*, D2LoadImage, (const char* filename, DWORD filetype));
A7(FAST, D2Client, 1150, 1150, 1140,00000,00000,00000,00000,00000, void, D2FreeImage, (void* image));//6FAA1140 A8(FAST, D2Client, 1150, 1150, 1140,00000,00000,00000,00000,00000,78A00, 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 !! A8(FAST, D2Client, D640, D630, DB50,73620,5E4E0,79670,147A0,B6890,787B0, void, D2SendMsgToAll,(BYTE* data));//1.11 and 1.11b by ESI !!
//A7(STD, D2Client,00000,00000,15A80,00000,00000,00000,00000,00000, int, D2GetAvgChanceMonsterWillHitYou, ());//6FAB5A80 //A8(STD, D2Client,00000,00000,15A80,00000,00000,00000,00000,00000,00000, int, D2GetAvgChanceMonsterWillHitYou, ());//6FAB5A80
A7(STD, D2Client,00000,00000,15A80,00000,00000,00000,00000,00000, DWORD, D2GetLastMonsterIDFight, ());//6FAB5A80 A8(STD, D2Client,00000,00000,15A80,00000,00000,00000,00000,00000,00000, DWORD, D2GetLastMonsterIDFight, ());//6FAB5A80
A7(STD, D2Client,29800,297F0,2FD60,828A0,89320,6B280,BCEA0,BF640, void, D2PrintStatsPage, ()); A8(STD, D2Client,29800,297F0,2FD60,828A0,89320,6B280,BCEA0,BF640,A7D00, void, D2PrintStatsPage, ());
//A7(FAST, D2Client,00000,00000,45990,00000,00000,00000,00000,00000, Unit*, D245990, (Inventory*,DWORD idItem);//6FAE5990 //A8(FAST, D2Client,00000,00000,45990,00000,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 A8(FAST, D2Client,4BB20,4BB20,521C0,B8CB0,21250,88EA0,54E10,2CE40,E4D80, 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 A8(FAST, D2Client,85A60,84DE0,80430,9EEB0,62070,8B7A0,BF5F0,18820,521C0, LPWSTR, D2SetColorPopup, (LPWSTR popupText, DWORD color));//1.11 and 1.11b BY EDI
//A7(FAST, D2Client,00000,00000,869F0,00000,00000,00000,00000,00000, Unit*, D2ClientGetObject, (DWORD itemNum, DWORD type));//6FB269F0 //A8(FAST, D2Client,00000,00000,869F0,00000,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)); A8(FAST, D2Client,B4360,B36E0,B5820,3ACC0,54210,31FA0,88A70,26270,B9A00, DWORD, D2PlaySound, (DWORD id, DWORD, DWORD, DWORD, DWORD));
//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)); //A8(FAST, D2Client,B9970,B8CF0,BB0F0,00000,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, ()); //A8(FAST, D2Client,00000,00000,00000,00000,571C0,18450,46150,790D0,00000, Unit*, D2GetCurrentNPC, ());
A7(FAST, D2Client,00000,00000,00000,73260,5DE40,791A0,143E0,B61F0, void, D2SendToServerXX,(DWORD size, BYTE * data));//by EBX A8(FAST, D2Client,00000,00000,00000,73260,5DE40,791A0,143E0,B61F0,78350, 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)); A8(FAST, D2Client,88940,87CC0,83260,A1F30,65690,8EF00,C2790,1C190,55F20, 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 A8(FAST, D2Client,00000,00000,00000,A6520,710C0,A6640,8CD00,90C10,89980, void, D2ClickOnStashButton, (DWORD x, DWORD y));//BY x=ESI y=EDI
A7(STD, D2Client,897B0,88B30,84110,9E3B0,621C0,8B8F0,BEAF0,18AA0, void*, D2LoadBuySelBtn, ()); A8(STD, D2Client,897B0,88B30,84110,9E3B0,621C0,8B8F0,BEAF0,18AA0,54600, void*, D2LoadBuySelBtn, ());
A7(FAST, D2Client,00000,00000,00000,8E480,5BA90,1CC00,4ABE0,7DC60, void, D2ReloadGambleScreen, ()); //A8(FAST, D2Client,00000,00000,00000,8E480,5BA90,1CC00,4ABE0,7DC60,00000, void, D2ReloadGambleScreen, ());
//A7(FAST, D2Client,00000,00000,00000,00000,1FEB0,5CDD0,00000,00000, void, D2OpenNPCMenu, (Unit* ptNPC));//by ESI //A8(FAST, D2Client,00000,00000,00000,00000,1FEB0,5CDD0,00000,00000,00000, void, D2OpenNPCMenu, (Unit* ptNPC));//by ESI
A8(FAST, D2Client,00000,00000,00000,00000,00000,00000,00000,00000,520C0, void*, D2LoadResImage, (const char* filename));
A8(FAST, D2Client,00000,00000,00000,00000,00000,00000,00000,00000,96990, void*, D2FreeResImages, ());
A8(FAST, D2Client,00000,00000,00000,00000,00000,00000,00000,00000,5C850, void*, D2ReceivePacket, (DWORD a , DWORD b));
A8(STD, D2Client,87220,865A0,81B70,A35F0,669F0,90150,C39E0,1D3E0,56EE0, DWORD, D2PrintInterface, (void* unknown));
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//D2Game : 6FC30000 //D2Game : 6FC30000
@ -349,7 +353,7 @@ A7(FAST, D2Client,00000,00000,00000,8E480,5BA90,1CC00,4ABE0,7DC60, void, D2Relo
////E2F(D2Game,22C00, WORD, D2GetNewAffix, (Unit* ptItem, DWORD testIfSpawnable, DWORD mustSelectOne, DWORD addToItem, DWORD isPrefix, int affixID, WORD autoAffixGroupID));//6FC52C00 ////E2F(D2Game,22C00, WORD, D2GetNewAffix, (Unit* ptItem, DWORD testIfSpawnable, DWORD mustSelectOne, DWORD addToItem, DWORD isPrefix, int affixID, WORD autoAffixGroupID));//6FC52C00
////E2F(D2Game,23610, WORD, D2GetRareAffixName, (Unit* ptItem, DWORD wantPrefix));//6FC53610 ////E2F(D2Game,23610, WORD, D2GetRareAffixName, (Unit* ptItem, DWORD wantPrefix));//6FC53610
////E2F(D2Game,3AD10, DWORD, D2GetSuperUniqueMonsterID, (Game* ptGame, Unit* ptMonster));//6FC6AD10 ////E2F(D2Game,3AD10, DWORD, D2GetSuperUniqueMonsterID, (Game* ptGame, Unit* ptMonster));//6FC6AD10
//E2F(D2Game,EC7E0, DWORD, D2SpawnMonster, (Game* ptGame, Room* ptRoom, DWORD zero1, DWORD x, DWORD y, DWORD minusOne, DWORD superuniqueID, DWORD zero2));//1.11b (wrong param) //E2F(D2Game,EC7E0, DWORD, D2SpawnSuperUnique, (Game* ptGame, Room* ptRoom, DWORD zero1, DWORD x, DWORD y, DWORD minusOne, DWORD superuniqueID, DWORD zero2));//1.11b (wrong param)
//E2S(D2Game,235C0, void, D2Game235C0, (Game* ptGame, Room* ptRoom));//1.11/1.11b //E2S(D2Game,235C0, void, D2Game235C0, (Game* ptGame, Room* ptRoom));//1.11/1.11b
//E2F(D2Game,4C7B0, Unit*, D2GetSkillItem, (Unit* ptChar));//6FC7C7B0 //E2F(D2Game,4C7B0, Unit*, D2GetSkillItem, (Unit* ptChar));//6FC7C7B0
////E2F(D2Game,5A500, DWORD, D2SavePlayer, (Game* ptGame, Unit* ptChar, char* playername, DWORD zero));//6FC8A500 ////E2F(D2Game,5A500, DWORD, D2SavePlayer, (Game* ptGame, Unit* ptChar, char* playername, DWORD zero));//6FC8A500
@ -360,53 +364,57 @@ A7(FAST, D2Client,00000,00000,00000,8E480,5BA90,1CC00,4ABE0,7DC60, void, D2Relo
//E2F(D2Game,C09E0, Unit*, D2CreateUnit, (DWORD type, DWORD id, DWORD x, DWORD y, Game* ptGame, Room* ptRoom, DWORD uk1, DWORD uk2, DWORD uk3));//1.11b //E2F(D2Game,C09E0, Unit*, D2CreateUnit, (DWORD type, DWORD id, DWORD x, DWORD y, Game* ptGame, Room* ptRoom, DWORD uk1, DWORD uk2, DWORD uk3));//1.11b
//E2F(D2Game,34920, void, D2OpenPandPortal, (Game* ptGame, Unit* ptChar));//1.11b //E2F(D2Game,34920, void, D2OpenPandPortal, (Game* ptGame, Unit* ptChar));//1.11b
//E2F(D2Game,34910, void, D2OpenPandFinalPortal, (Game* ptGame, Unit* ptChar));//1.11b //E2F(D2Game,34910, void, D2OpenPandFinalPortal, (Game* ptGame, Unit* ptChar));//1.11b
//E2F(D2Game,85AA0, void, D2MephIA, (Game* ptGame, Unit* ptMonster, DWORD*));//1.11b //E2F(D2Game,85AA0, void, D2MephAI, (Game* ptGame, Unit* ptMonster, DWORD*));//1.11b
//E2F(D2Game,D7BD0, void, D2DiabloIA, (Game* ptGame, Unit* ptMonster, DWORD*));//1.11b //E2F(D2Game,D7BD0, void, D2DiabloAI, (Game* ptGame, Unit* ptMonster, DWORD*));//1.11b
//E2F(D2Game,2BC80, void, D2BaalIA, (Game* ptGame, Unit* ptMonster, DWORD*));//1.11b //E2F(D2Game,2BC80, void, D2BaalAI, (Game* ptGame, Unit* ptMonster, DWORD*));//1.11b
//E2F(D2Game,D2D70, void, D2UberMephIA, (Game* ptGame, Unit* ptMonster, DWORD*));//1.11b //E2F(D2Game,D2D70, void, D2UberMephAI, (Game* ptGame, Unit* ptMonster, DWORD*));//1.11b
//E2F(D2Game,7FE60, void, D2UberDiabloIA, (Game* ptGame, Unit* ptMonster, DWORD*));//1.11b //E2F(D2Game,7FE60, void, D2UberDiabloAI, (Game* ptGame, Unit* ptMonster, DWORD*));//1.11b
//E2F(D2Game,2A300, void, D2UberBaalIA, (Game* ptGame, Unit* ptMonster, DWORD*));//1.11b //E2F(D2Game,2A300, void, D2UberBaalAI, (Game* ptGame, Unit* ptMonster, DWORD*));//1.11b
////E2F(D2Game,92420, void, D2ReloadGambleScreenGame, (Unit* ptNPC, Game* ptGame, Unit* ptChar, DWORD, DWORD one));//1.11b ////E2F(D2Game,92420, void, D2ReloadGambleScreenGame, (Unit* ptNPC, Game* ptGame, Unit* ptChar, DWORD, DWORD one));//1.11b
//E2S(D2Game,E66D0, void, D2SaveGame, (Game* ptGame));//1.11b //E2S(D2Game,E66D0, void, D2SaveGame, (Game* ptGame));//1.11b
F7(FAST, D2Game,10059,10059,10059,10039,10007,10037,10049,10002, void, D2SetNbPlayers, (DWORD nbPlayers)); F8(FAST, D2Game,10059,10059,10059,10039,10007,10037,10049,10002,135780, void, D2SetNbPlayers, (DWORD nbPlayers));
//A7(FAST, D2Game,00000,00000,01DE0,00000,00000,00000,00000,00000, void*, D2GetClientByClientID, (Game* ptGame, DWORD clientID));//6FC31DE0 //A8(FAST, D2Game,00000,00000,01DE0,00000,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 A8(FAST, D2Game,00000,00000, 6C60,E3DA0,E8210,EB060,49930,E5070,12C550, void, D2AddClient, (DWORD clientID));//BY EAX
A7(STD, D2Game,00000,00000, 94E0,E0520,E49A0,A6360,2AAE0,BC700, Game*, D2GetGameByClientID, (DWORD clientID));//6FC394E0 A8(STD, D2Game,00000,00000, 94E0,E0520,E49A0,A6360,2AAE0,BC700,12E860, 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 A8(FAST, D2Game,00000,00000, B0E0,DF250,E36D0,A5080,29820,BB510,12DED0, 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 A8(FAST, D2Game, C380, C650, C710,41420,A0D50,7D220,8A3E0,DB780,13B280, 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 A8(FAST, D2Game, D650, D920, DB50,44D00,A3F20,802E0,8D5F0,DD4F0,13C4A0, 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,00000, void, D2UpdateClientItem, (NetClient* ptNetClient, Unit* ptChar, Unit* ptItem,DWORD,DWORD,DWORD));//6FC3E6F0 //A8(FAST, D2Game,00000,00000,0E6F0,00000,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 //A8(FAST, D2Game,00000,00000,10FB0,00000,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 //A8(FAST, D2Game,00000,00000,110E0,00000,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)); A8(STD, D2Game,00000,00000,00000,27230,109F0,AE930,A22E0,15F40,16CF40, 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 A8(FAST, D2Game,00000,00000,128F0,38D90,43E60,11FF0,D2070,B2F70,15CA40, 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,00000, Unit*, D2CreateItem, (Game* ptGame, ItemGenerationData* itemGenerationData, DWORD));//6FC4ED80 //A8(FAST, D2Game,00000,00000,1ED80,00000,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)); A8(FAST, D2Game,00000,00000,22070, 1090, 1DF0, 11F0, 1280, 1340,63740, Room*, D2TestPositionInRoom, (Room* ptRoom, DWORD x, DWORD y));
//A7(FAST, D2Game,00000,00000,22410,00000,00000,00000,00000,00000, void, D2AddStaffModAffixes, (Unit* ptItem, ItemGenerationData* itemParam));//6FC52410 //A8(FAST, D2Game,00000,00000,22410,00000,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 //A8(FAST, D2Game,00000,00000,22C00,00000,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 //A8(FAST, D2Game,00000,00000,23610,00000,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 //A8(FAST, D2Game,00000,00000,3AD10,00000,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 A8(FAST, D2Game,00000,00000,3F220,4ABE0,EC7E0,40B90,24950,CDE20,1A09E0, DWORD, D2SpawnSuperUnique, (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)); A8(FAST, D2Game,00000,00000,00000,C80F0,EF870,EFB10,EF650,C8D70,1B2F20, Unit*, D2SpawnMonster, (DWORD id, DWORD mode, Game* ptGame, Room* ptRoom, DWORD x, DWORD y, DWORD one, DWORD zero));
//A7(FAST, D2Game,00000,00000,4C7B0,00000,00000,00000,00000,00000, Unit*, D2GetSkillItem, (Unit* ptChar));//6FC7C7B0 A8(STD, D2Game,00000,00000,00000,D6D10,235C0, D410,200E0,59980,142B40, void, D2Game235C0, (Game* ptGame, Room* ptRoom));
//A7(FAST, D2Game,00000,00000,5A500,00000,00000,00000,00000,00000, DWORD, D2SavePlayer, (Game* ptGame, Unit* ptChar, char* playername, DWORD zero));//6FC8A500 //A8(FAST, D2Game,00000,00000,4C7B0,00000,00000,00000,00000,00000,00000, Unit*, D2GetSkillItem, (Unit* ptChar));//6FC7C7B0
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 //A8(FAST, D2Game,00000,00000,5A500,00000,00000,00000,00000,00000,00000, DWORD, D2SavePlayer, (Game* ptGame, Unit* ptChar, char* playername, DWORD zero));//6FC8A500
A7(FAST, D2Game,7BAE0,7BFD0,8BB00,97620,BEF80,93650,E03A0,6DC40, Unit*, D2GameGetObject, (Game* ptGame, DWORD type, DWORD itemNum));//6FCBBB00 A8(FAST, D2Game,4F100,4F500,5B8A0,B9D70,25D50,44950,54810,3A4C0,1335E0, DWORD, D2LoadInventory, (Game* ptGame, Unit* pChar, saveBitField* pdata, DWORD p2, DWORD maxSize, DWORD p4, DWORD *ptNbBytesRead));//6FC8B8A0
//A7(FAST, D2Game,00000,00000,9F320,501C0,F1C50,F1A50,F3220,00000, Unit*, D2GetOwnerMonster, (Unit* ptMonster)); A8(FAST, D2Game,7BAE0,7BFD0,8BB00,97620,BEF80,93650,E03A0,6DC40,152F60, Unit*, D2GameGetObject, (Game* ptGame, DWORD type, DWORD itemNum));//6FCBBB00
//A7(FAST, D2Game,00000,00000,E08D0,00000,00000,00000,00000,00000, void, D2UpdateSkillDataAfterUnassignment, (Game* ptGame, Unit* ptChar, DWORD skillID));//6FD108D0 //A8(FAST, D2Game,00000,00000,9F320,501C0,F1C50,F1A50,F3220,00000,00000, Unit*, D2GetOwnerMonster, (Unit* ptMonster));
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)); //A8(FAST, D2Game,00000,00000,E08D0,00000,00000,00000,00000,00000,00000, void, D2UpdateSkillDataAfterUnassignment, (Game* ptGame, Unit* ptChar, DWORD skillID));//6FD108D0
A7(FAST, D2Game,00000,00000,00000,9B480,34920,D1AA0,70180,941E0, void, D2OpenPandPortal, (Game* ptGame, Unit* ptChar)); A8(FAST, D2Game,00000,00000,00000,99760,C09E0,94E70,E1D90,6FE10,155230, 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,9B470,34910,D1A90,70170,941D0, void, D2OpenPandFinalPortal, (Game* ptGame, Unit* ptChar)); A8(FAST, D2Game,00000,00000,00000,9B480,34920,D1AA0,70180,941E0,165A90, void, D2OpenPandPortal, (Game* ptGame, Unit* ptChar));
A7(FAST, D2Game,00000,00000,00000,84730,85AA0,DBE90,A9610,31920, void, D2MephIA, (Game* ptGame, Unit* ptMonster, DWORD*)); A8(FAST, D2Game,00000,00000,00000,9B470,34910,D1A90,70170,941D0,165AA0, void, D2OpenPandFinalPortal, (Game* ptGame, Unit* ptChar));
A7(FAST, D2Game,00000,00000,00000,75980,D7BD0,CD0F0,85B60,4EAD0, void, D2DiabloIA, (Game* ptGame, Unit* ptMonster, DWORD*)); A8(FAST, D2Game,00000,00000,00000,75980,D7BD0,CD0F0,85B60,4EAD0,1F78B0, void, D2MephAI, (Game* ptGame, Unit* ptMonster, AIParam* args));
A7(FAST, D2Game,00000,00000,00000,EAB20,2BC80,B3B90,B8610,C8850, void, D2BaalIA, (Game* ptGame, Unit* ptMonster, DWORD*)); A8(FAST, D2Game,00000,00000,00000,84730,85AA0,DBE90,A9610,31920,1E9170, void, D2DiabloAI, (Game* ptGame, Unit* ptMonster, AIParam* args));
A7(FAST, D2Game,00000,00000,00000,70320,D2D70,C2A90,7B4E0,49480, void, D2UberMephIA, (Game* ptGame, Unit* ptMonster, DWORD*)); A8(FAST, D2Game,00000,00000,00000,EAB20,2BC80,B3B90,B8610,C8850,1FCFE0, void, D2BaalAI, (Game* ptGame, Unit* ptMonster, AIParam* args));
A7(FAST, D2Game,00000,00000,00000,7F200,7FE60,D6250,A39D0,2C3F0, void, D2UberDiabloIA, (Game* ptGame, Unit* ptMonster, DWORD*)); A8(FAST, D2Game,00000,00000,00000,E92B0,2A300,B2210,B6C80,C6EC0,1FD200, void, D2UberBaalAI, (Game* ptGame, Unit* ptMonster, AIParam* args));
A7(FAST, D2Game,00000,00000,00000,E92B0,2A300,B2210,B6C80,C6EC0, void, D2UberBaalIA, (Game* ptGame, Unit* ptMonster, DWORD*)); A8(FAST, D2Game,00000,00000,00000,70320,D2D70,C2A90,7B4E0,49480,1F81C0, void, D2UberMephAI, (Game* ptGame, Unit* ptMonster, AIParam* args));
//A7(FAST, D2Game,00000,00000,00000,00000,92420,00000,00000,00000, void, D2ReloadGambleScreenGame, (Unit* ptNPC, Game* ptGame, Unit* ptChar, DWORD, DWORD one)); A8(FAST, D2Game,00000,00000,00000,7F200,7FE60,D6250,A39D0,2C3F0,1E9DF0, void, D2UberDiabloAI, (Game* ptGame, Unit* ptMonster, AIParam* args));
A7(STD, D2Game,00000,00000, 89C0,E2390,E66D0,A8090,2C830,BE660, void, D2SaveGame, (Game* ptGame) ); //A8(FAST, D2Game,00000,00000,00000,00000,92420,00000,00000,00000,179430, void, D2ReloadGambleScreenGame, (Unit* ptNPC, Game* ptGame, Unit* ptChar, DWORD, DWORD one));
A8(STD, D2Game,00000,00000, 89C0,E2390,E66D0,A8090,2C830,BE660,12CA10, void, D2SaveGame, (Game* ptGame) );
A8(FAST, D2Game,00000,00000,00000,EF580,F0F70,F0D70,F2540,F1800,1DEB60, void, D2MonsterMove, (Game* ptGame, Unit* ptMonster, Unit* target, DWORD two, DWORD x, DWORD y, DWORD one, DWORD zero) );
A8(FAST, D2Game,00000,00000,00000,FF1B0,F0DB0,F0BB0,F2380,F1430,1DEAD0, void, D2MonsterUseSkill, (Game* ptGame, Unit* ptMonster, DWORD arg, DWORD skill, Unit* target, DWORD x, DWORD y) );
A8(FAST, D2Game,00000,00000,00000,B9340,25450,44140,53F10,39810,132240, void, D2SaveSPChar, (Game* ptGame, Unit* ptChar, char* name, DWORD arg, DWORD secondPass) );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -414,8 +422,8 @@ A7(STD, D2Game,00000,00000, 89C0,E2390,E66D0,A8090,2C830,BE660, void, D2SaveGa
//D2S(D2Net,10020, DWORD, D2SendToServer, (DWORD size, DWORD one, void* data));//ONLY 1.11b //D2S(D2Net,10020, DWORD, D2SendToServer, (DWORD size, DWORD one, void* data));//ONLY 1.11b
//D2S(D2Net,10018, DWORD, D2SendToClient, (DWORD zero, DWORD clientID, void* data, DWORD size));//ONLY 1.11b //D2S(D2Net,10018, DWORD, D2SendToClient, (DWORD zero, DWORD clientID, void* data, DWORD size));//ONLY 1.11b
F7(STD, D2Net, 10005,10005,10005,10035,10020,10036,10024,10015, DWORD, D2SendToServer, (DWORD size, DWORD one, void* data));//(DWORD zero, void* data, DWORD size) for 1.10 and before F8(STD, D2Net, 10005,10005,10005,10035,10020,10036,10024,10015,12AE50, DWORD, D2SendToServer, (DWORD size, DWORD one, void* data));//(DWORD zero, void* data, DWORD size) for 1.10 and before
F7(STD, D2Net, 10006,10006,10006,10018,10018,10015,10002,10012, DWORD, D2SendToClient, (DWORD zero, DWORD clientID, void* data, DWORD size)); F8(STD, D2Net, 10006,10006,10006,10018,10018,10015,10002,10012,12B330, DWORD, D2SendToClient, (DWORD zero, DWORD clientID, void* data, DWORD size));
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -436,29 +444,29 @@ F7(STD, D2Net, 10006,10006,10006,10018,10018,10015,10002,10012, DWORD, D2SendT
////D2S(Fog,10127, DWORD, D2GetBitFieldSize, (saveBitField* data));//6FF536C0 ////D2S(Fog,10127, DWORD, D2GetBitFieldSize, (saveBitField* data));//6FF536C0
////D2S(Fog,10128, void, D2EncodeValue, (saveBitField* data, DWORD value, DWORD bitSize));//6FF536C0 ////D2S(Fog,10128, void, D2EncodeValue, (saveBitField* data, DWORD value, DWORD bitSize));//6FF536C0
////D2S(Fog,10130, DWORD, D2DecodeValue, (saveBitField* data,DWORD readingSize));//6FF53840 ////D2S(Fog,10130, DWORD, D2DecodeValue, (saveBitField* data,DWORD readingSize));//6FF53840
//D2S(Fog,10212, void, D2Fog10212, (DWORD unknow));//1.11b //D2S(Fog,10212, void, D2Fog10212, (DWORD unknown));//1.11b
////D2S(Fog,10217, int, D2GetIDFromLookUpTable, (void* table, char* string, bool));//6FF53840 ////D2S(Fog,10217, int, D2GetIDFromLookUpTable, (void* table, char* string, bool));//6FF53840
//D2S(Fog,10265, int, D2GetInstructionPointer, ());//ONLY 1.11/1.11b NOT 1.10 //D2S(Fog,10265, int, D2GetInstructionPointer, ());//ONLY 1.11/1.11b NOT 1.10
F7(STD, Fog, 10023,10023,10023,00000,00000,00000,00000,00000, void, D2FogAssertOld, (const char* ptMessage, DWORD eip, DWORD line));//(STDCALL until 1.10) F8(STD, Fog, 10023,10023,10023,00000,00000,00000,00000,00000,00000, void, D2FogAssertOld, (const char* ptMessage, DWORD eip, DWORD line));//(STDCALL until 1.10)
F7(FAST, Fog, 00000,00000,00000,10024,10024,10024,10024,10024, void, D2FogAssert, (const char* ptMessage, DWORD eip, DWORD line)); F8(FAST, Fog, 00000,00000,00000,10024,10024,10024,10024,10024,8A60, void, D2FogAssert, (const char* ptMessage, DWORD eip, DWORD line));
F7(FAST, Fog, 10042,10042,10042,10042,10042,10042,10042,10042, void*, D2FogMemAlloc, (DWORD dwMemSize, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero)); F8(FAST, Fog, 10042,10042,10042,10042,10042,10042,10042,10042,B380, void*, D2FogMemAlloc, (DWORD dwMemSize, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
F7(FAST, Fog, 10043,10043,10043,10043,10043,10043,10043,10043, void*, D2FogMemDeAlloc, (void* ptMemLoc, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero)); F8(FAST, Fog, 10043,10043,10043,10043,10043,10043,10043,10043,B3C0, void*, D2FogMemDeAlloc, (void* ptMemLoc, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
F7(FAST, Fog, 10045,10045,10045,10045,10045,10045,10045,10045, void*, D2AllocMem, (DWORD,DWORD dwMemSize, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero)); F8(FAST, Fog, 10045,10045,10045,10045,10045,10045,10045,10045,B430, void*, D2AllocMem, (DWORD,DWORD dwMemSize, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
F7(FAST, Fog, 10046,10046,10046,10046,10046,10046,10046,10046, void*, D2FreeMem, (DWORD,void* ptMemLoc, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero)); F8(FAST, Fog, 10046,10046,10046,10046,10046,10046,10046,10046,B480, void*, D2FreeMem, (DWORD,void* ptMemLoc, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
F7(FAST, Fog, 10102,10102,10102,10102,10102,10102,10102,10102, DWORD, D2MPQOpenFile, (char* ptPath, void** buf)); F8(FAST, Fog, 10102,10102,10102,10102,10102,10102,10102,10102,68E0, DWORD, D2MPQOpenFile, (char* ptPath, void** buf));
F7(FAST, Fog, 10103,10103,10103,10103,10103,10103,10103,10103, DWORD, D2MPQCloseFile, (void* mpqfile)); F8(FAST, Fog, 10103,10103,10103,10103,10103,10103,10103,10103,68F0, DWORD, D2MPQCloseFile, (void* mpqfile));
F7(FAST, Fog, 10104,10104,10104,10104,10104,10104,10104,10104, DWORD, D2MPQReadFile, (void* mpqfile, BYTE* buffer, DWORD nbToRead, DWORD* nbRead,DWORD,DWORD,DWORD)); F8(FAST, Fog, 10104,10104,10104,10104,10104,10104,10104,10104,6900, DWORD, D2MPQReadFile, (void* mpqfile, BYTE* buffer, DWORD nbToRead, DWORD* nbRead,DWORD,DWORD,DWORD));
F7(FAST, Fog, 10105,10105,10105,10105,10105,10105,10105,10105, DWORD, D2MPQGetSizeFile, (void* mpqfile, DWORD* toReset)); F8(FAST, Fog, 10105,10105,10105,10105,10105,10105,10105,10105,6930, DWORD, D2MPQGetSizeFile, (void* mpqfile, DWORD* toReset));
F7(FAST, Fog, 10115,10115,10115,10115,10115,10115,10115,10115, void, D2FogGetSavePath, (char* ptPath, DWORD maxsize)); F8(FAST, Fog, 10115,10115,10115,10115,10115,10115,10115,10115,7050, void, D2FogGetSavePath, (char* ptPath, DWORD maxsize));
F7(FAST, Fog, 10116,10116,10116,10116,10116,10116,10116,10116, void, D2FogGetInstallPath, (char* ptPath, DWORD maxsize)); F8(FAST, Fog, 10116,10116,10116,10116,10116,10116,10116,10116,6BA0, void, D2FogGetInstallPath, (char* ptPath, DWORD maxsize));
//F7(STD, Fog, 10126,10126,10126,10126,10126,10126,10126,10126, DWORD, D2InitBitField, (saveBitField* data, BYTE* buf, DWORD bufsize));//6FF536C0 //F8(STD, Fog, 10126,10126,10126,10126,10126,10126,10126,10126,00000, 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 //F8(STD, Fog, 10127,10127,10127,10127,10127,10127,10127,10127,00000, 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 //F8(STD, Fog, 10128,10128,10128,10128,10128,10128,10128,10128,00000, 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 //F8(STD, Fog, 10130,10130,10130,10130,10130,10130,10130,10130,00000, DWORD, D2DecodeValue, (saveBitField* data,DWORD readingSize));//6FF53840
F7(STD, Fog, 10212,10212,10212,10212,10212,10212,10212,10212, void, D2Fog10212, (DWORD unknow)); F8(STD, Fog, 10212,10212,10212,10212,10212,10212,10212,10212,2BD0B0, void, D2Fog10212, (DWORD unknow));
//F7(STD, Fog, 10217,10217,10217,10217,10217,10217,10217,10217, int, D2GetIDFromLookUpTable, (void* table, char* string, bool));//6FF53840 //F8(STD, Fog, 10217,10217,10217,10217,10217,10217,10217,10217,00000, int, D2GetIDFromLookUpTable, (void* table, char* string, bool));//6FF53840
F7(STD, Fog, 00000,00000,00000,10265,10265,10265,10265,10265, int, D2GetInstructionPointer, ()); F8(STD, Fog, 00000,00000,00000,10265,10265,10265,10265,10265,8090, int, D2GetInstructionPointer, ());
//Fog10213 getIndexFromLookupTable (&table,code,bool) //Fog10213 getIndexFromLookupTable (&table,code,bool)
@ -477,19 +485,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 ////E2F(D2Lang,2CD0, DWORD, D2unicodenwidth, (char* ptChar, DWORD size));//6FC12CD0_unicodenwidth
////E2S(D2Lang,1670, DWORD, D2swprintf, (DWORD bufSize, LPWSTR buf, LPWSTR string, ...));//6FC11670_sprintf ////E2S(D2Lang,1670, DWORD, D2swprintf, (DWORD bufSize, LPWSTR buf, LPWSTR string, ...));//6FC11670_sprintf
//F7(FAST, D2Lang, 10003,10003,10003,00000,00000,00000,00000,10011, LPWSTR, D2GetStringFromString, (const char* ptString));//6FC13BC0 //F8(FAST, D2Lang, 10003,10003,10003,00000,00000,00000,00000,10011,00000, LPWSTR, D2GetStringFromString, (const char* ptString));//6FC13BC0
F7(FAST, D2Lang, 10003,10003,10003,10002,10004,10010,10011,10011, LPWSTR, D2GetStringFromString, (const char* ptString));//6FC13BC0 LAutour F8(FAST, D2Lang, 10003,10003,10003,10002,10004,10010,10011,10011,124E20, LPWSTR, D2GetStringFromString, (const char* ptString));//6FC13BC0 LAutour
F7(FAST, D2Lang, 10004,10004,10004,10005,10000,10005,10003,10004, LPWSTR, D2GetStringFromIndex, (WORD dwIndexNum)); F8(FAST, D2Lang, 10004,10004,10004,10005,10000,10005,10003,10004,124A30, LPWSTR, D2GetStringFromIndex, (WORD dwIndexNum));
//F7(STD, D2Lang, 10006,10006,10006,00000,00000,00000,00000,00000, void, D2GetStringLang, (LPSTR ptLang, DWORD Zero));//6FC13FB0 //F8(STD, D2Lang, 10006,10006,10006,00000,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 F8(STD, D2Lang, 10007,10007,10007,10009,10013,10002,10009,10001,125150, DWORD, D2GetLang, ());//14b 00522A20
F7(STD, D2Lang, 10010,10010,10010,00000,00000,00000,00000,00000, DWORD, D2PrintBigNumber, (LPWSTR ptBuf , DWORD number, DWORD size));//6FC14210 F8(STD, D2Lang, 10010,10010,10010,00000,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 //F8(STD, D2Lang, 10013,10013,10013,00000,00000,00000,00000,10005,00000, 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 //A8(FAST, D2Lang, 00000,00000,029B0,00000,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 //A8(FAST, D2Lang, 00000,00000,02E60,00000,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 //A8(FAST, D2Lang, 00000,00000,03640,00000,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 //A8(FAST, D2Lang, 00000,00000,03A90,00000,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 //A8(FAST, D2Lang, 00000,00000,02CD0,00000,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 //A8(STD, D2Lang, 00000,00000,01670,00000,00000,00000,00000,00000,00000, DWORD, D2swprintf, (DWORD bufSize, LPWSTR buf, LPWSTR string, ...));//6FC11670_sprintf
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Storm : 6FFB0000 //Storm : 6FFB0000
@ -498,10 +506,10 @@ F7(STD, D2Lang, 10010,10010,10010,00000,00000,00000,00000,00000, DWORD, D2Prin
//D2S(Storm,503, void, D2Storm503, (DWORD, DWORD, DWORD)); //+1.11 //D2S(Storm,503, void, D2Storm503, (DWORD, DWORD, DWORD)); //+1.11
//D2S(Storm,511, void, D2FreeWinMessage, (sWinMessage* msg));//1.11/1.11b //D2S(Storm,511, void, D2FreeWinMessage, (sWinMessage* msg));//1.11/1.11b
//F7(STD, Storm, 253, 253, 253, 253, 253, 253, 000, 000, void, D2StormMPQCloseFile, (void* mpqfile)); //F8(STD, Storm, 253, 253, 253, 253, 253, 253, 000, 000,00000, 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)) F8(STD, Storm, 268, 268, 268, 268, 268, 268, 268, 268, 192F0, 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)); F8(STD, Storm, 503, 503, 503, 503, 503, 503, 503, 503, 13750, void, D2Storm503, (DWORD, DWORD, DWORD));
F7(STD, Storm, 511, 511, 511, 511, 511, 511, 511, 511, void, D2FreeWinMessage, (sWinMessage* msg)); F8(STD, Storm, 511, 511, 511, 511, 511, 511, 511, 511, 20290, void, D2FreeWinMessage, (sWinMessage* msg));
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -513,12 +521,12 @@ F7(STD, Storm, 511, 511, 511, 511, 511, 511, 511, 511, void, D2FreeWi
//D2S(D2gfx,10000, void, D2FillArea,(DWORD x1, DWORD y1, DWORD x2, DWORD y2, DWORD color, DWORD transTbl));//ONLY 1.11b //D2S(D2gfx,10000, void, D2FillArea,(DWORD x1, DWORD y1, DWORD x2, DWORD y2, DWORD color, DWORD transTbl));//ONLY 1.11b
//D2S(D2gfx,10044, void, D2PrintImage,(sDrawImageInfo* data, DWORD x, DWORD y, DWORD p4, DWORD p5, DWORD p6) );//ONLY 1.11b //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,() ); F8(STD, D2gfx, 10005,10005,10005,10000,10063,10043,10031,10012,F5160, DWORD, D2GetResolution,() );
//F7,STD, D2gfx, 10023,10023,10023,00000,00000,00000,00000,00000, DWORD, D2CreateMainWindow,(DWORD,DWORD) ); //F8,STD, D2gfx, 10023,10023,10023,00000,00000,00000,00000,00000,00000, DWORD, D2CreateMainWindow,(DWORD,DWORD) );
//F7(STD, D2gfx, 10026,10026,10026,00000,00000,00000,00000,00000, DWORD, D2ShowWindow,() ); //F8(STD, D2gfx, 10026,10026,10026,00000,00000,00000,00000,00000,00000, DWORD, D2ShowWindow,() );
//F7,STD, D2gfx, 10027,10027,10027,00000,00000,00000,00000,00000, HWND, D2GetWindowHandle,() );//6FA749C0 //F8,STD, D2gfx, 10027,10027,10027,00000,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)); F8(STD, D2gfx, 10055,10055,10055,10028,10000,10062,10014,10028,F6300, 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) ); F8(STD, D2gfx, 10072,10072,10072,10047,10044,10024,10041,10042,F6480, void, D2PrintImage,(sDrawImageInfo* data, DWORD x, DWORD y, DWORD p4, DWORD p5, DWORD p6) );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -532,36 +540,42 @@ F7(STD, D2gfx, 10072,10072,10072,10047,10044,10024,10041,10042, void, D2PrintI
//D2F(D2Win,10132, DWORD, D2PrintTextPopup,(LPWSTR s, DWORD x, DWORD y, DWORD uk, DWORD type, DWORD color) );//6F8AB080 //D2F(D2Win,10132, DWORD, D2PrintTextPopup,(LPWSTR s, DWORD x, DWORD y, DWORD uk, DWORD type, DWORD color) );//6F8AB080
//D2S(D2Win,10113, void*, D2CreateTextBox,(DWORD* data) );//ONLY 1.11b //D2S(D2Win,10113, void*, D2CreateTextBox,(DWORD* data) );//ONLY 1.11b
F7(FAST, D2Win, 10046,10046,10046,10061,10075,10015,10022,10051, void, D2PrintLineOnTextBox,(void* screen, char* s, DWORD color) ); F8(FAST, D2Win, 10046,10046,10046,10061,10075,10015,10022,10051,FCFF0, void, D2PrintLineOnTextBox,(void* screen, char* s, DWORD color) );
F7(FAST, D2Win, 10117,10117,10117,10020,10064,10001,10150,10076, void, D2PrintString,(LPWSTR s, DWORD x, DWORD y, DWORD color, DWORD bfalse) ); F8(FAST, D2Win, 10117,10117,10117,10020,10064,10001,10150,10076,102320, void, D2PrintString,(LPWSTR s, DWORD x, DWORD y, DWORD color, DWORD bfalse) );
F7(FAST, D2Win, 10121,10121,10121,10034,10128,10132,10028,10150, DWORD, D2GetPixelLen,(LPWSTR s) ); F8(FAST, D2Win, 10121,10121,10121,10034,10128,10132,10028,10150,101820, DWORD, D2GetPixelLen,(LPWSTR s) );
F7(FAST, D2Win, 10127,10127,10127,10141,10170,10010,10184,10047, DWORD, D2SetFont,(DWORD fontID) ); F8(FAST, D2Win, 10127,10127,10127,10141,10170,10010,10184,10047,102EF0, DWORD, D2SetFont,(DWORD fontID) );
F7(FAST, D2Win, 10129,10129,10129,10118,10039,10031,10085,10137, void, D2PrintPopup,(LPWSTR s, DWORD x, DWORD y, DWORD color, DWORD center) ); F8(FAST, D2Win, 10129,10129,10129,10118,10039,10031,10085,10137,102280, void, D2PrintPopup,(LPWSTR s, DWORD x, DWORD y, DWORD color, DWORD center) );
F7(FAST, D2Win, 10131,10131,10131,00000,00000,00000,00000,00000, void, D2GetPixelRect,(LPWSTR s, DWORD* x, DWORD* y) );//6F8AB260 F8(FAST, D2Win, 10131,10131,10131,00000,00000,00000,00000,00000,00000, void, D2GetPixelRect,(LPWSTR s, DWORD* x, DWORD* y) );//6F8AB260
F7(FAST, D2Win, 10132,10132,10132,00000,00000,00000,00000,00000, DWORD, D2PrintTextPopup,(LPWSTR s, DWORD x, DWORD y, DWORD uk, DWORD type, DWORD color) );//6F8AB080 F8(FAST, D2Win, 10132,10132,10132,00000,00000,00000,00000,00000,00000, DWORD, D2PrintTextPopup,(LPWSTR s, DWORD x, DWORD y, DWORD uk, DWORD type, DWORD color) );//6F8AB080
F7(STD, D2Win, 10017,10017,10017,10147,10113,10098,10098,10164, void*, D2CreateTextBox,(DWORD* data) ); F8(STD, D2Win, 10017,10017,10017,10147,10113,10098,10098,10164,F93C0, void*, D2CreateTextBox,(DWORD* data) );
// Add a call wrapper for the following:
// D2Win.0x6F8AA2A0 (#10121) // int __fastcall D2Win_10121_GetTextWidth(const Unicode* wszText)
F8(FAST, D2Win, 10121, 10121, 10121, 10121, 10121, 10121, 10121, 10121, AA2A0, DWORD, D2Win_GetTextWidth, (const wchar_t* wszText));
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//D2CMP : ????0000 //D2CMP : ????0000
//D2S(D2CMP,10014, DWORD, D2CMP10014, (void* image) );//ONLY 1.11 //D2S(D2CMP,10014, DWORD, D2CMP10014, (void* image) );//ONLY 1.11
F7(STD, D2CMP, 10032,10032,10032,10021,10014,10106,10065,10020, DWORD, D2CMP10014, (void* image) ); F8(STD, D2CMP, 10032,10032,10032,10021,10014,10106,10065,10020,201A50, DWORD, D2CMP10014, (void* image) );
//ONLY UNTIL 1.10 : //ONLY UNTIL 1.10 :
A7(FAST, D2Client, BA00, B9F0, C080,00000,00000,00000,00000,00000, DWORD, D2isLODGame, ());//6FAAC080 A8(FAST, D2Client, BA00, B9F0, C080,00000,00000,00000,00000,00000,00000, DWORD, D2isLODGame, ());//6FAAC080
A7(FAST, D2Client, 00000,00000, C090,00000,00000,00000,00000,00000, BYTE, D2GetDifficultyLevel, ());//6FAAC090 1.09 should be BA10 (b) BA00 (d) A8(FAST, D2Client, 00000,00000, C090,00000,00000,00000,00000,00000,00000, BYTE, D2GetDifficultyLevel, ());//6FAAC090 1.09 should be BA10 (b) BA00 (d)
A7(STD, D2Client, B6670,B59F0,B7BC0,00000,00000,00000,00000,00000, DWORD, D2GetMouseX, ());//6FB57BC0 A8(STD, D2Client, B6670,B59F0,B7BC0,00000,00000,00000,00000,00000,00000, DWORD, D2GetMouseX, ());//6FB57BC0
A7(STD, D2Client, B6680,B5A00,B7BD0,00000,00000,00000,00000,00000, DWORD, D2GetMouseY, ());//6FB57BD0 A8(STD, D2Client, B6680,B5A00,B7BD0,00000,00000,00000,00000,00000,00000, DWORD, D2GetMouseY, ());//6FB57BD0
A7(STD, D2Client, 8DC40,8CFC0,883D0,00000,00000,00000,00000,00000, Unit*, D2GetClientPlayer, ());//6FB283D0 A8(STD, D2Client, 8DC40,8CFC0,883D0,00000,00000,00000,00000,00000,63DD0, Unit*, D2GetClientPlayer, ());//6FB283D0
A7(FAST, D2Client, B920, B910, BF60,00000,00000,00000,00000,00000, void, D2CleanStatMouseUp, ());//6FAABF60 A8(FAST, D2Client, B920, B910, BF60,00000,00000,00000,00000,00000,4DA70, void, D2CleanStatMouseUp, ());//6FAABF60
A7(FAST, D2Client, D210, D200, D990,00000,00000,00000,00000,00000, void, D2SendToServer3, (BYTE type, WORD p));//6FAAD990 A8(FAST, D2Client, D210, D200, D990,00000,00000,00000,00000,00000,00000, void, D2SendToServer3, (BYTE type, WORD p));//6FAAD990
//A7(FAST, D2Client, 00000,00000, DA20,00000,00000,00000,00000,00000, void, D2SendToServer5, (BYTE type, DWORD p));//6FAADA20 //A8(FAST, D2Client, 00000,00000, DA20,00000,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 //A8(FAST, D2Client, 00000,00000, D9E0,00000,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 //A8(FAST, D2Client, 00000,00000, DA40,00000,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 //A8(FAST, D2Client, 00000,00000, DA70,00000,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 A8(FAST, D2Game, 7C2C0,7C7B0,8C2E0,00000,00000,00000,00000,00000,1531C0, NetClient*, D2GetClient, (Unit* ptUnit, char* lpszErrFile, DWORD ErrLine));//6FCBC2E0
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// VARIABLES //////// //////// VARIABLES ////////
@ -582,24 +596,25 @@ A7(FAST, D2Game, 7C2C0,7C7B0,8C2E0,00000,00000,00000,00000,00000, NetClient*, D2
//E2C(D2Client,11B418,DWORD, MouseX);//0x320 = 800 //1.11b //E2C(D2Client,11B418,DWORD, MouseX);//0x320 = 800 //1.11b
//E2C(D2Client,11C1E0,Unit*, ptClientChar);//1.11b //E2C(D2Client,11C1E0,Unit*, ptClientChar);//1.11b
//C7(D2Common,000000,000000, 96A20, 9B74C, 9EE8C, 9B500, 99E1C, DataTables*,SgptDataTables); //03836A20 - 037A0000 //01EE6A20 //C8(D2Common,000000,000000, 96A20, 9B74C, 9EE8C, 9B500, 99E1C,000000,000000, DataTables*,SgptDataTables); //03836A20 - 037A0000 //01EE6A20
C7(D2Client, D50E8, D40E0, D40F0, F5C60, F4FC8, DC6E4, DBC4C, F7038, DWORD, ResolutionY);//0x258 = 600 C8(D2Client, D50E8, D40E0, D40F0, F5C60, F4FC8, DC6E4, DBC4C, F7038,311470, DWORD, ResolutionY);//0x258 = 600
C7(D2Client, D50EC, D40E4, D40F4, F5C5C, F4FC4, DC6E0, DBC48, F7034, DWORD, ResolutionX);//0x320 = 800 C8(D2Client, D50EC, D40E4, D40F4, F5C5C, F4FC4, DC6E0, DBC48, F7034,31146C, DWORD, ResolutionX);//0x320 = 800
C7(D2Client,125AD8,124958,11A74C,11BD28,11BEFC,11BD2C,11B9A4,11D358, DWORD, NegWindowStartY);//0xFFFFFFC4 = -60 C8(D2Client,125AD8,124958,11A74C,11BD28,11BEFC,11BD2C,11B9A4,11D358,3A285C, DWORD, NegWindowStartY);//0xFFFFFFC4 = -60
C7(D2Client,125AD4,124954,11A748,11BD24,11BEF8,11BD28,11B9A0,11D354, DWORD, WindowStartX);//0x50 = 80 C8(D2Client,125AD4,124954,11A748,11BD24,11BEF8,11BD28,11B9A0,11D354,3A2858, DWORD, WindowStartX);//0x50 = 80
//C7(D2Launch, 55818, 56088, 2CD5C,000000, 2CD5C,000000,000000,00000, DWORD, GameTypeMode);//0x50 = 80 //6FA3CD5C-6FA10000 //C8(D2Launch, 55818, 56088, 2CD5C,000000, 2CD5C,000000,000000,00000,000000, DWORD, GameTypeMode);//0x50 = 80 //6FA3CD5C-6FA10000
C7(D2Game, F2A80, F2918,113FB8,111718,1115E0,1105E0,1107B8,1105E0, NetClient*, ClientTable); C8(D2Game, F2A80, F2918,113FB8,111718,1115E0,1105E0,1107B8,1105E0,4842A8, NetClient*, ClientTable);
//C7(D2Client,000000,000000,000000,000000,104225,000000,000000,00000, DWORD, CurrentNPCNum); //C8(D2Client,000000,000000,000000,000000,104225,000000,000000,00000,000000, DWORD, CurrentNPCNum);
C7(D2Client,000000,000000,000000, FB3F4,11A2F4,10330C,119854,1087B4, DWORD, IsLodGame); C8(D2Client,000000,000000,000000, FB3F4,11A2F4,10330C,119854,1087B4,3A04F4, DWORD, IsLodGame);
C7(D2Client,000000,000000,10795C,11BFB8,11C2A8,11BFF4,000000,000000, BYTE, DifficultyLevel); C8(D2Client,000000,000000,10795C,11BFB8,11C2A8,11BFF4,000000,000000,000000, BYTE, DifficultyLevel);
//C7(D2Client,000000,000000,10795C,11BFB8,11C2A8,11BFF4,000000,11D1D8, BYTE, DifficultyLevel); //C8(D2Client,000000,000000,10795C,11BFB8,11C2A8,11BFF4,000000,11D1D8,000000, BYTE, DifficultyLevel);
C7(D2Client,000000,000000,000000,10A40C,11B414,101634,11B824,11C94C, DWORD, MouseY);//0x258 = 600 C8(D2Client,000000,000000,000000,10A40C,11B414,101634,11B824,11C94C,3A6AAC, DWORD, MouseY);//0x258 = 600
C7(D2Client,000000,000000,000000,10A410,11B418,101638,11B828,11C950, DWORD, MouseX);//0x320 = 800 C8(D2Client,000000,000000,000000,10A410,11B418,101638,11B828,11C950,3A6AB0, DWORD, MouseX);//0x320 = 800
C7(D2Client,000000,000000,000000,11C4F0,11C1E0,11C3D0,11BBFC,11D050, Unit*, ptClientChar); C8(D2Client,000000,000000,000000,11C4F0,11C1E0,11C3D0,11BBFC,11D050,3A6A70, Unit*, ptClientChar);
C8(D2Client,11E0F4,11CF54,112D04,11B9A8,11BB30,11BF48,11C028,11CAA4,3BB5E8, DWORD, InputCommandLen);
C8(D2Client,11CE50,11BCB0,111A58,11C590,11D590,11FC40,11EC80,11D650,3BB638, WCHAR, InputCommand);
C8(D2Client, DB918, DA828,000000,000000,000000,000000,000000,000000,000000, DWORD, NbStatDesc);
C7(D2Client, DB918, DA828,000000,000000,000000,000000,000000,000000, DWORD, NbStatDesc); C8(D2Client, DAF98, D9EA8,000000,000000,000000,000000,000000,000000,000000, DWORD, StatDescTable);
C7(D2Client, DAF98, D9EA8,000000,000000,000000,000000,000000,000000, DWORD, StatDescTable);
/* NEXT NOT TESTED IN 1.10 (1.09b fct) /* NEXT NOT TESTED IN 1.10 (1.09b fct)
D2_STD(D2Common10066, void, D2RemoveFromRoom, (DrlgRoom1* hRoom, DWORD untitype, DWORD unitID), 0x6FD7CFD0); D2_STD(D2Common10066, void, D2RemoveFromRoom, (DrlgRoom1* hRoom, DWORD untitype, DWORD unitID), 0x6FD7CFD0);

177
Commons/D2UnitStruct.h
View File

@ -16,6 +16,14 @@ struct Unit;
struct SkillsBIN; struct SkillsBIN;
struct SkillData; struct SkillData;
struct ObjectsBIN; struct ObjectsBIN;
struct NetClient;
struct Game;
struct ActMap;
struct ActData;
struct Level;
struct RoomEx;
struct Room;
/*=================================================================*/ /*=================================================================*/
/* Skill Structure. */ /* Skill Structure. */
@ -59,7 +67,7 @@ struct Position
DWORD y; DWORD y;
}; };
struct Room//size=0x80 /*struct Room//size=0x80
{ {
//ptRoom +48 0 = spawn new units (monster, objects e.tc), 1 = don't spawn any new units //ptRoom +48 0 = spawn new units (monster, objects e.tc), 1 = don't spawn any new units
DWORD seed1; //+00 DWORD seed1; //+00
@ -79,17 +87,107 @@ struct Room//size=0x80
BYTE isGenerated2:1;//??? BYTE isGenerated2:1;//???
}; };
}; };
}; };*/
struct ActMap//ptGame+BC size=0x60 struct RoomEx //size=5C
{ {
DWORD isNotManaged; DWORD __00[2]; //0x00
DWORD uk4; RoomEx** roomExNear; //0x08
DWORD uk8;//size = 0x488 DWORD __0C[5]; //0x0C
Room* ptFirstRoom; struct {
INT32 roomNumber; //0x00
void* __04; //0x04
PINT32 subNumber; //0x08
} *pType2Info; //0x20
RoomEx* ptNextRoomEx; //0x24
UINT32 roomFlags; //0x28
UINT32 roomsNearCount; //0x2C
Room* ptRoom; //0x30
INT32 posX; //0x34
INT32 posY; //0x38
INT32 sizeX; //0x3C
INT32 sizeY; //0x40
DWORD __44; //0x44
UINT32 presetType; //0x48
void* ptWarpTiles; //0x4C
DWORD __50[2]; //0x50
Level* ptLevel; //0x58
};
struct Room //size=0x80
{
Room** ptNearRooms; //0x00
DWORD __04[3]; //0x04
RoomEx* ptRoomEx; //0x10
DWORD __14[3]; //0x14
void* coll; //0x20
INT32 nbNearRooms; //0x24
DWORD __28[9]; //0x28
DWORD startX; //0x4C
DWORD startY; //0x50
DWORD sizeX; //0x54
DWORD sizeY; //0x58
DWORD __5C[6]; //0x5C
Unit* ptFirstUnit; //0x74
DWORD __78; //0x78
Room* ptNextRoom; //0x7C
};
struct Level //size=0x234
{
DWORD type; //+000
DWORD flags; //+004
DWORD __004_010[2]; //+008
RoomEx* ptFirstRoomEx; //+010
DWORD __014_01C[2]; //+014
INT32 posX; //+01C
INT32 posY; //+020
INT32 sizeX; //+024
INT32 sizeY; //+028
DWORD __0C2_1AC[96]; //+02C
Level* ptNextLevel; //+1AC
DWORD __1B0; //+1B0
ActData* ptActData; //+1B4
DWORD __1B8_1C0[2]; //+1B8
DWORD levelType; //+1C0
DWORD seed1; //+1C4
DWORD seed2; //+1C8
DWORD uk_1CC; //+1CC
UINT32 levelNo; //+1D0
DWORD __1D4_234[96]; //+1D4
};
struct ActData //size=0x488
{
DWORD seed1; //+000
DWORD seed2; //+004
DWORD nbRooms; //+008
DWORD __00C_0094[34]; //+00C
DWORD nTalRashaTombLevel; //094
DWORD __098; //+098
Game* ptGame; //+09C
DWORD __0A0_450[237]; //+0A0
BYTE difficulty; //+450
BYTE __451_46C[27]; //+451
ActMap* ptActMap; //+46C
DWORD __470_484[5]; //+470
DWORD nBossMummyTombLevel;//+484
};
struct ActMap //size=0x60
{
DWORD isNotManaged; //+00
DWORD __04; //+04
DWORD townLevel; //+08
DWORD seed; //+0C
Room* ptFirstRoom; //+10
DWORD actNumber; //+14
DWORD __18_48[12]; //+18
ActData* ptActData; //+48
DWORD __50_5C[4]; //+4C
void* ptMemoryPool; //+5C
}; };
struct NetClient;
//ptGame : 04E4007C //ptGame : 04E4007C
struct Game struct Game
{ //Offset from Code. { //Offset from Code.
@ -104,7 +202,9 @@ struct Game
WORD unknown2; //+78 WORD unknown2; //+78
BYTE uk4[0x0E]; //+7A BYTE uk4[0x0E]; //+7A
NetClient* ptClient; //+88 NetClient* ptClient; //+88
BYTE uk8C[0x30]; //+8C BYTE __8C[0x1C]; //+8C
DWORD gameFrame; //+A8
BYTE __AC[0x10]; //+AC
ActMap* mapAct[5]; //+BC ActMap* mapAct[5]; //+BC
BYTE ukD0[0x1024]; //+D0 BYTE ukD0[0x1024]; //+D0
DWORD* game10F4; //+10F4 DWORD* game10F4; //+10F4
@ -132,7 +232,7 @@ struct Path //(8 dword)
struct Inventory struct Inventory
{ //Offset from Code. Size: 30 à 40 { //Offset from Code. Size: 30 to 40
DWORD tag; //+00 = 0x01020304 DWORD tag; //+00 = 0x01020304
BYTE uk1[0x04]; //+04 =? 0 BYTE uk1[0x04]; //+04 =? 0
Unit* ptChar; //+08 Unit* ptChar; //+08
@ -200,24 +300,49 @@ struct Stats //sizeof(Stats)=0x64
DWORD unknow2; //+60 (=0) DWORD unknow2; //+60 (=0)
}; };
struct AIControl
{
DWORD specialState; // +00 SpecialState - stuff like terror, confusion goes here
void* aiFunction; // +04 fpAiFunction(); - the primary ai function to call (void * __fastcall)(pGame,pUnit,pAiTickArgs);
DWORD aiFlags; // +08 AiFlags
DWORD ownerGUID; // +0C OwnerGUID - the global unique identifier of the boss or minion owner
DWORD ownerType; // +10 eOwnerType - the unit type of the boss or minion owner
DWORD args[3]; // +14 dwArgs[3] - three dwords holding custom data used by ai func to store counters (etc)
void* cmdCurrent; // +20 pCmdCurrents
void* cmdLast; // +24 pCmdLast
Game* ptGame; // +28 pGame
DWORD ownerGUID2; // +2C OwnerGUID - the same as +008
DWORD ownerType2; // +30 eOwnerType - the same as +00C
void* minionList; // +34 pMinionList - list of all minions, for boss units (SetBoss in MonStats, Unique, SuperUnique etc)
DWORD trapNo; // +3C eTrapNo - used by shadows for summoning traps (so they stick to one type usually)
};
struct MonsterData // sizeof(MonsterData)=0x60 struct MonsterData // sizeof(MonsterData)=0x60
{ //Offset from Code. { //Offset from Code.
BYTE uk[0x16]; //+00 MonStatsBIN* ptMonStats; //+000 - pMonStats - record in monstats.txt
union { BYTE components[0x10]; //+004 - Components[16] - bytes holding the component Ids for each component; Order: HD, TR, LG, RA, LA, RH, LH, SH, S1, S2, S3, S4, S5, S6, S7, S8
WORD flags; //+16 WORD seed; //+014 - NameSeed
struct { union
WORD fuk1:1; {
WORD isSuperUnique:1; BYTE flags; //+016 - TypeFlags
WORD isChampion:1; struct
WORD isUnique:1; {
WORD fuk2:13; BYTE isOther:1; // MONTYPE_OTHER(set for some champs, uniques)
BYTE isSuperUnique:1; // MONTYPE_SUPERUNIQUE
BYTE isChampion:1; // MONTYPE_CHAMPION
BYTE isUnique:1; // MONTYPE_UNIQUE
BYTE isMinion:1; // MONTYPE_MINION
BYTE isPossessed:1; // MONTYPE_POSSESSED
BYTE isGhostly:1; // MONTYPE_GHOSTLY
BYTE isMultishot:1; // MONTYPE_MULTISHOT
}; };
}; };
BYTE uk1[0x0E]; //+18 BYTE lastMode; //+017 - eLastMode
WORD superUniqueID; //+26 DWORD duriel; //+018 - dwDuriel - set only for duriel
void* unknow1; //+28 BYTE monUModList[10]; //+01C - MonUModList[9] - nine bytes holding the Ids for each MonUMod assigned to the unit
BYTE uk2[0x38]; //+28 DWORD superUniqueID; //+026
AIControl* ptAiGeneral; //+02A
BYTE uk2[0x32]; //+02E
}; };
struct ObjectData struct ObjectData
@ -300,7 +425,7 @@ ITEMFLAG_RUNEWORD = 0x04000000
WORD prefix[3]; //+38 WORD prefix[3]; //+38
WORD suffix[3]; //+3E WORD suffix[3]; //+3E
BYTE equipLoc; //+44 BYTE equipLoc; //+44
/* emplacement si équipé /* location if equipped
* 00 = noequip/inBelt * 00 = noequip/inBelt
* 01 = head * 01 = head
* 02 = neck * 02 = neck
@ -404,7 +529,7 @@ struct Unit
}; //+04 }; //+04
DWORD nUnitId; //+08 DWORD nUnitId; //+08
DWORD nItemNum; //+0C DWORD nItemNum; //+0C
DWORD CurrentAnim; //+10 DWORD mode; //+10
union{ union{
MonsterData* ptMonsterData; MonsterData* ptMonsterData;
ObjectData* ptObjectData; ObjectData* ptObjectData;
@ -452,7 +577,7 @@ struct Unit
BYTE uk10[0x0C]; //+D4 BYTE uk10[0x0C]; //+D4
Unit* ptFirstMonster; //+E0 Unit* ptFirstMonster; //+E0
Unit* Unit1; //+E4 Unit* Unit1; //+E4
Unit* Unit2; //+E8 Unit* ptNextUnitInRoom; //+E8
BYTE uk11[0x08]; //+EC BYTE uk11[0x08]; //+EC
union{ union{
CBPlayerData* ptCBPlayerData; CBPlayerData* ptCBPlayerData;

25
Commons/VersionInfo.cpp
View File

@ -7,7 +7,6 @@
//#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers //#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
#include "VersionInfo.h" #include "VersionInfo.h"
#include <windows.h>
#pragma comment(lib, "Version.Lib") #pragma comment(lib, "Version.Lib")
@ -15,18 +14,22 @@ const char* VersionStrings[16] = { "1.00","1.07","1.08","1.09","1.09b","1.09d","
const char* GetVersionString(int version) const char* GetVersionString(int version)
{ {
if (version < 0 || version >= sizeof(VersionStrings))
return "UNKNOWN";
return VersionStrings[version]; return VersionStrings[version];
} }
eGameVersion GetD2Version(LPCVOID pVersionResource) eGameVersion GetD2Version(LPCVOID pVersionResource)
{ {
if (!pVersionResource) return UNKNOWN;
UINT uLen; UINT uLen;
VS_FIXEDFILEINFO* ptFixedFileInfo; VS_FIXEDFILEINFO* ptFixedFileInfo;
if (!VerQueryValue(pVersionResource, "\\", (LPVOID*)&ptFixedFileInfo, &uLen)) if (!VerQueryValue(pVersionResource, "\\", (LPVOID*)&ptFixedFileInfo, &uLen))
return UNKNOW; return UNKNOWN;
if (uLen == 0) if (uLen == 0)
return UNKNOW; return UNKNOWN;
WORD major = HIWORD(ptFixedFileInfo->dwFileVersionMS); WORD major = HIWORD(ptFixedFileInfo->dwFileVersionMS);
WORD minor = LOWORD(ptFixedFileInfo->dwFileVersionMS); WORD minor = LOWORD(ptFixedFileInfo->dwFileVersionMS);
@ -34,7 +37,7 @@ eGameVersion GetD2Version(LPCVOID pVersionResource)
WORD subrevision = LOWORD(ptFixedFileInfo->dwFileVersionLS); WORD subrevision = LOWORD(ptFixedFileInfo->dwFileVersionLS);
if (major != 1) if (major != 1)
return UNKNOW; return UNKNOWN;
if (minor == 0 && revision == 7 && subrevision == 0) return V107; if (minor == 0 && revision == 7 && subrevision == 0) return V107;
if (minor == 0 && revision == 8 && subrevision == 28) return V108; if (minor == 0 && revision == 8 && subrevision == 28) return V108;
if (minor == 0 && revision == 9 && subrevision == 19) return V109; if (minor == 0 && revision == 9 && subrevision == 19) return V109;
@ -50,14 +53,14 @@ eGameVersion GetD2Version(LPCVOID pVersionResource)
if (minor == 14 && revision == 1 && subrevision == 68) return V114b; if (minor == 14 && revision == 1 && subrevision == 68) return V114b;
if (minor == 14 && revision == 2 && subrevision == 70) return V114c; if (minor == 14 && revision == 2 && subrevision == 70) return V114c;
if (minor == 14 && revision == 3 && subrevision == 71) return V114d; if (minor == 14 && revision == 3 && subrevision == 71) return V114d;
return UNKNOW; return UNKNOWN;
} }
eGameVersion GetD2Version(char* gameExe) eGameVersion GetD2Version(char* gameExe)
{ {
DWORD len = GetFileVersionInfoSize(gameExe, NULL); DWORD len = GetFileVersionInfoSize(gameExe, NULL);
if (len == 0) if (len == 0)
return UNKNOW; return UNKNOWN;
BYTE* pVersionResource = new BYTE[len]; BYTE* pVersionResource = new BYTE[len];
GetFileVersionInfo(gameExe, NULL, len, pVersionResource); GetFileVersionInfo(gameExe, NULL, len, pVersionResource);
@ -67,19 +70,15 @@ eGameVersion GetD2Version(char* gameExe)
return version; return version;
} }
eGameVersion GetD2Version() eGameVersion GetD2Version(HMODULE hModule)
{ {
HMODULE hModule = GetModuleHandle(NULL);
HRSRC hResInfo = FindResource(hModule, MAKEINTRESOURCE(VS_VERSION_INFO), RT_VERSION); HRSRC hResInfo = FindResource(hModule, MAKEINTRESOURCE(VS_VERSION_INFO), RT_VERSION);
if (!hResInfo) return UNKNOWN;
HGLOBAL hResData = LoadResource(hModule, hResInfo); HGLOBAL hResData = LoadResource(hModule, hResInfo);
if (!hResData) return UNKNOWN;
LPVOID pVersionResource = LockResource(hResData); LPVOID pVersionResource = LockResource(hResData);
//DWORD dwSize = SizeofResource(hInst, hResInfo);
//LPVOID pVersionResource = LocalAlloc(LMEM_FIXED, dwSize);
//CopyMemory(pVersionResource, pRes, dwSize);
eGameVersion version = GetD2Version(pVersionResource); eGameVersion version = GetD2Version(pVersionResource);
FreeResource(hResData); FreeResource(hResData);
//LocalFree(pVersionResource);
return version; return version;
} }

6
Commons/VersionInfo.h
View File

@ -6,9 +6,11 @@
=================================================================*/ =================================================================*/
#pragma once #pragma once
#include <windows.h>
enum eGameVersion enum eGameVersion
{ {
UNKNOW = -1, UNKNOWN = -1,
V100 = 0, V100 = 0,
V107, V107,
V108, V108,
@ -29,6 +31,6 @@ enum eGameVersion
const char* GetVersionString(int version); const char* GetVersionString(int version);
eGameVersion GetD2Version(char* gamePath); eGameVersion GetD2Version(char* gamePath);
eGameVersion GetD2Version(); eGameVersion GetD2Version(HMODULE hModule);
///////////////////////// END OF FILE /////////////////////// ///////////////////////// END OF FILE ///////////////////////

99
Commons/d2BinFile.h
View File

@ -154,9 +154,20 @@ struct ObjectsBIN
}; };
struct ExperienceBIN//size=0x20
{
DWORD Amazon;
DWORD Sorceress;
DWORD Necromancer;
DWORD Paladin;
DWORD Barbarian;
DWORD Druid;
DWORD Assassin;
DWORD ExpRatio;
};
struct LevelsBIN//size=0x220 struct LevelsBIN//size=0x220
{ {
}; };
struct GemsBIN //size: 0xC0=192 (source : fct of dll) struct GemsBIN //size: 0xC0=192 (source : fct of dll)
@ -206,7 +217,7 @@ struct GemsBIN //size: 0xC0=192 (source : fct of dll)
DWORD shieldmod3max; //+BC DWORD shieldmod3max; //+BC
}; };
struct ItemsBIN //size: 0x1A8=424 (source : fct of dll) (nblines : 134 CA 8B) Gold:20B struct ItemsBIN //size: 0x1A8=424 (source : fct of dll)
{ {
char FlippyFile[0x20]; //+00 char FlippyFile[0x20]; //+00
char InvFile[0x20]; //+20 char InvFile[0x20]; //+20
@ -380,33 +391,40 @@ struct RunesBIN //size: 0x120=288 (1.10 ok)
struct CharStatsBIN //size= 0xC4=196 struct CharStatsBIN //size= 0xC4=196
{ {
WCHAR nameU[0x10]; WCHAR nameU[0x10]; //+00
char name[0x10]; char name[0x10]; //+20
BYTE baseSTR; //+20 BYTE baseSTR; //+30
BYTE baseDEX; BYTE baseDEX; //+31
BYTE baseENE; BYTE baseENE; //+32
BYTE baseVIT; BYTE baseVIT; //+33
BYTE baseStamina; BYTE baseStamina; //+34
BYTE HPAdd; BYTE hpadd; //+35
BYTE percentStr; BYTE percentStr; //+36
BYTE percentDex; BYTE percentInt; //+37
BYTE percentInt; BYTE percentDex; //+38
BYTE percentVit; BYTE percentVit; //+39
WORD manaRegen; BYTE manaRegen; //+3A
DWORD toHitFactor; BYTE __3B; //+3B
BYTE walkVelocity;//+30 DWORD toHitFactor; //+3C
BYTE runVelocity; BYTE walkVelocity; //+40
BYTE runDrain; BYTE runVelocity; //+41
BYTE lifePerLevel; BYTE runDrain; //+42
BYTE staminaPerLevel; BYTE lifePerLevel; //+43
BYTE manaPerLevel; BYTE staminaPerLevel; //+44
BYTE lifePerVitality; BYTE manaPerLevel; //+45
BYTE staminaPerVitality; BYTE lifePerVitality; //+46
BYTE manaPerMagic; BYTE staminaPerVitality; //+47
BYTE blockFactor; BYTE manaPerMagic; //+48
WORD startSkill; BYTE blockFactor; //+49
DWORD baseWClass; WORD __4A_startSkill; //+4A
DWORD unknown1[3]; DWORD baseWClass; //+4C
BYTE StatPerLevel; //+50
BYTE __51; //+51
WORD StrAllSkills; //+52
WORD StrSkillTab1; //+54
WORD StrSkillTab2; //+56
WORD StrSkillTab3; //+58
WORD StrClassOnly; //+5A
DWORD item1; DWORD item1;
BYTE item1Loc; BYTE item1Loc;
BYTE item1Count; BYTE item1Count;
@ -553,19 +571,28 @@ struct UniqueItemsBIN //size=0x14C (332)
struct { struct {
BYTE ukf:2; BYTE ukf:2;
BYTE carry1:1; BYTE carry1:1;
BYTE ladder:1;
}; };
}; };
BYTE uk3[0x11F]; //+2D BYTE uk3[0x11F]; //+2D
}; };
struct SetsBIN //size=0x128 (source : fct of dll)
{
WORD setNum; //+00
WORD setNameIndex; //+02
BYTE uk3[0x124]; //+04
};
struct SetItemsBIN //size=0x1B8 (source : fct of dll) struct SetItemsBIN //size=0x1B8 (source : fct of dll)
{ {
WORD setId; //+00 WORD setNum; //+00
char index[0x20]; //+02 char index[0x20]; //+02
BYTE uk1; //+04 BYTE uk1; //+04
WORD setNameId; //+24 WORD setNameId; //+24
BYTE uk2[0x192]; //+26 BYTE uk2[0x6]; //+26
WORD setId; //+2C
BYTE uk3[0x18A]; //+2E
}; };
@ -895,7 +922,10 @@ struct MonStatsBIN //size=0x1A8 (424)
{ {
BYTE uk1[0x6]; //+00 BYTE uk1[0x6]; //+00
WORD monsterNameID; //+06 WORD monsterNameID; //+06
BYTE uk2[0x1A0]; //+08 BYTE uk2[0x168]; //+08
WORD skill[8]; //+170
BYTE skillArg[8]; //+180
BYTE uk3[0x20]; //+188
}; //+1A8 }; //+1A8
struct ItemTypesBIN //size=0xE4 (228) (source : fct of dll) struct ItemTypesBIN //size=0xE4 (228) (source : fct of dll)
@ -1179,7 +1209,10 @@ struct DataTables//01EE6A20 * 01FDA2D0 //second comments=1.11
BYTE uk8[0x18]; //+BE0 BYTE uk8[0x18]; //+BE0
ItemTypesBIN* itemTypes; //+BF8 ItemTypesBIN* itemTypes; //+BF8
DWORD nbItemTypes; //+BFC DWORD nbItemTypes; //+BFC
BYTE uk9[0x18]; //+C00 BYTE uk9[0x0C]; //+C00
SetsBIN* sets; //+C0C //1.11 and 1.10
DWORD nbSets; //+C10 //1.11 and 1.10
BYTE uk9b[0x4]; //+C14
SetItemsBIN* setItems; //+C18 //1.11 and 1.10 SetItemsBIN* setItems; //+C18 //1.11 and 1.10
DWORD nbSetItems; //+C1C //1.11 and 1.10 DWORD nbSetItems; //+C1C //1.11 and 1.10
BYTE uk10[0x4]; //+C20 BYTE uk10[0x4]; //+C20

15
Commons/d2Struct.h
View File

@ -15,9 +15,9 @@ struct Room;
#pragma pack(1) #pragma pack(1)
struct sWinMessage struct sWinMessage
{ {
void* msg; DWORD msg;
DWORD type; DWORD type;
DWORD uk1; DWORD key;
WORD x; WORD x;
WORD y; WORD y;
DWORD uk3; DWORD uk3;
@ -95,6 +95,17 @@ struct ItemGenerationData //size=0x84
}; };
}; };
struct AIParam {
void* control; //+0x00
void* u_0x04; //+0x04
Unit* target; //+0x08
void* u_0x0C; //+0x0C
void* u_0x10; //+0x10
DWORD distanceToTarget; //+0x14
BOOL engagedInCombat; //+0x18
MonStatsBIN* ptMonStatsBIN; //+0x1C
void* ptMonStats2BIN; //+0x20
};
/*=================================================================*/ /*=================================================================*/
/* Data Structure to Update Client */ /* Data Structure to Update Client */

60
Commons/d2constants.h
View File

@ -18,29 +18,29 @@ enum D2TypeSize { D2TS_UNITSIZE = 0x011C };
enum D2DifficultyModes { D2DM_NORMAL, D2DM_NIGHTMARE, D2DM_HELL }; enum D2DifficultyModes { D2DM_NORMAL, D2DM_NIGHTMARE, D2DM_HELL };
enum D2PlayerClass { D2PC_AMAZON, D2PC_SORCERESS, D2PC_NECROMANCER, D2PC_PALADIN, D2PC_BARBARIAN, D2PC_DRUID, D2PC_ASSASSIN }; enum D2PlayerClass { D2PC_AMAZON, D2PC_SORCERESS, D2PC_NECROMANCER, D2PC_PALADIN, D2PC_BARBARIAN, D2PC_DRUID, D2PC_ASSASSIN };
// add the prefix "ÿc" before the number directly in the text.
enum D2Color enum D2Color
{ {
BLACK=6,
// BLACK_BIS=14,
DARK_GRAY=5,
GRAY=16,
LIGHT_GRAY=15,
// WHITE_BIS=13,
WHITE=0, WHITE=0,
RED=1, BRIGHT_WHITE=18,
GOLD=4,
DARK_YELLOW=7,
YELLOW=9,
ORANGE=8,
DARKEST_GREEN=10,
DARK_GREEN=12,
GREEN=2, GREEN=2,
BLUE=3, BLUE=3,
GOLD=4, PURPLE=11,
DARK_GRAY=5, RED=1,
// INVISIBLE=6, CRYSTAL_RED=19,
DARK_YELLOW=7, // VERY_WIERD=17,
ORANGE=8,
YELLOW=9,
DARKEST_GREEN=0xA,
PURPLE=0xB,
DARK_GREEN=0xC,
// WHITE_BIS=0xD,
// INVISIBLE2=0xE,
LIGHT_GRAY=0xF,
GRAY=0x10,
// VERY_WIERD=0x11,
BRIGHT_WHITE=0x12,
CRYSTAL_RED=0x13,
// WIERD_YELLOW=0x14
}; };
enum D2Lang enum D2Lang
@ -824,6 +824,30 @@ enum D2UnitType
UNIT_ROOMTILE UNIT_ROOMTILE
}; };
enum D2UnitMode
{
UNIT_MODE_DEATH = 0,
UNIT_MODE_NEUTRAL,
UNIT_MODE_WALK,
UNIT_MODE_RUN,
UNIT_MODE_GET_HIT,
UNIT_MODE_TOWN_NEUTRAL,
UNIT_MODE_TOWN_WALK,
UNIT_MODE_ATTACK1,
UNIT_MODE_ATTACK2,
UNIT_MODE_BLOCK,
UNIT_MODE_CAST,
UNIT_MODE_THROW,
UNIT_MODE_KICK,
UNIT_MODE_SKILL1,
UNIT_MODE_SKILL2,
UNIT_MODE_SKILL3,
UNIT_MODE_SKILL4,
UNIT_MODE_DEAD,
UNIT_MODE_SEQUENCE,
UNIT_MODE_KNOCK_BACK
};
enum D2BodyLoc enum D2BodyLoc
{ {
LOC_HEAD =1, LOC_HEAD =1,

1
Commons/updatingConst.h
View File

@ -48,6 +48,7 @@ enum UpdateServerConst
US_RENAME, US_RENAME,
US_PAGENAME, US_PAGENAME,
US_SET_INDEX, US_SET_INDEX,
US_SET_MAIN_INDEX,
US_RESET_INDEX, US_RESET_INDEX,
US_INSERT_PAGE, US_INSERT_PAGE,
US_DELETE_PAGE, US_DELETE_PAGE,

887
HD_fix.patch Normal file
View File

@ -0,0 +1,887 @@
diff --git a/PlugY/InfinityStash.cpp b/PlugY/InfinityStash.cpp
index 22e9c35..ea09d36 100644
--- a/PlugY/InfinityStash.cpp
+++ b/PlugY/InfinityStash.cpp
@@ -26,6 +26,7 @@ bool active_sharedStash = false;
bool separateHardSoftStash = false;
bool active_sharedGold=false;
char* sharedStashFilename = NULL;
+DWORD saveFileStackSize = 0x2000;
typedef int (*TchangeToSelectedStash)(Unit* ptChar, Stash* newStash, DWORD bOnlyItems, DWORD bIsClient);
@@ -422,7 +423,7 @@ void saveStashList(Unit* ptChar, Stash* ptStash, BYTE** data, DWORD* maxSize, DW
while(ptStash)
{
- if (*curSize + 0x2000 > *maxSize)
+ if (*curSize + saveFileStackSize > *maxSize)
{
BYTE* oldData = *data;
*maxSize *= 2;
diff --git a/PlugY/Interface_Skills.cpp b/PlugY/Interface_Skills.cpp
index 90178f7..8a07c2a 100644
--- a/PlugY/Interface_Skills.cpp
+++ b/PlugY/Interface_Skills.cpp
@@ -49,9 +49,10 @@ Unit* STDCALL skillsPageMouseDown(sWinMessage* msg)
if (active_SkillsPoints && !onRealm && D2isLODGame() && isOnButtonUnassignSkill(D2GetMouseX(),D2GetMouseY()))
{
log_msg("push down left button unassign skill\n");
- btnSkillIsDown = 1;
+ //btnSkillIsDown = 1;
D2PlaySound(4,0,0,0,0);
freeMessage(msg);
+ updateServer(US_UNASSIGN_SKILLS);
return NULL;
}
return ptChar;
@@ -233,6 +234,7 @@ void Install_InterfaceSkills()
//6FAE1112 > C745 18 00000000 MOV DWORD PTR SS:[EBP+18],0
//004ABC1A |> C746 18 00000000 MOV DWORD PTR DS:[ESI+18],0
+ /* Conflicts with D2ExpRes
// Manage mouse up
mem_seek R8(D2Client, 7BC40, 7BC40, 78466, 17558, 8C078, 80248, 795F8, 30AA8, ABC96);
MEMJ_REF4( D2FreeWinMessage, caller_skillsPageMouseUp);//0xFFF93B0A
@@ -243,6 +245,7 @@ void Install_InterfaceSkills()
//6FB295F7 .^E9 8828F9FF JMP <JMP.&Storm.#511>
//6FAE0AA7 .^E9 E0B2FDFF JMP <JMP.&Storm.#511>
//004ABC95 |. E8 F645F7FF CALL Game.00420290
+ */
log_msg("\n");
diff --git a/PlugY/Interface_Stats.cpp b/PlugY/Interface_Stats.cpp
index 85e6029..1d3a4cf 100644
--- a/PlugY/Interface_Stats.cpp
+++ b/PlugY/Interface_Stats.cpp
@@ -13,6 +13,7 @@
#include "common.h"
#include <stdio.h>
+/*
static struct
{
union{
@@ -35,6 +36,7 @@ static struct
#define getYNextPageBtn() RY(D2GetResolution()?0x40:0x70)
#define getHNextPageBtn() 32
#define isOnNextPageBtn(x,y) isOnRect(x, y, getXNextPageBtn(), getYNextPageBtn(), getLNextPageBtn(), getHNextPageBtn())
+*/
@@ -49,7 +51,7 @@ void STDCALL printStatsPageBtns()
sDrawImageInfo data;
ZeroMemory(&data,sizeof(data));
- if (printBackgroundOnMainPage && D2GetResolution())
+ if (printBackgroundOnMainPage)
{
setImage(&data, statsBackgroundImages);
setFrame(&data, 1);
@@ -57,16 +59,14 @@ void STDCALL printStatsPageBtns()
}
setImage(&data, D2LoadBuySelBtn());
- if (D2GetResolution())
- {
- setFrame(&data, 12 + isDownBtn.previousPage);
- D2PrintImage(&data, getXPreviousPageBtn(), getYPreviousPageBtn(), -1, 5, 0);
- }
+ setFrame(&data, 12 + isDownBtn.previousPage);
+ D2PrintImage(&data, getXPreviousPageBtn(), getYPreviousPageBtn(), -1, 5, 0);
+
setFrame(&data, 14 + isDownBtn.nextPage);
D2PrintImage(&data, getXNextPageBtn(), getYNextPageBtn(), -1, 5, 0);
D2SetFont(1);
- if (D2GetResolution() && isOnPreviousPageBtn(mx,my)) //print popup "previous page"
+ if (isOnPreviousPageBtn(mx,my)) //print popup "previous page"
{
lpText = getLocalString(STR_PREVIOUS_PAGE);
D2PrintPopup(lpText, getXPreviousPageBtn()+getLPreviousPageBtn()/2, getYPreviousPageBtn()-getHPreviousPageBtn(), WHITE, 1);
@@ -84,6 +84,12 @@ Unit* STDCALL statsPageMouseDown(sWinMessage* msg)
if (!active_newInterfaces || !D2isLODGame() ) return ptChar;
+ if (statsLeftDown(msg)) {
+ freeMessage(msg);
+ return NULL;
+ }
+
+ /*
if (D2GetResolution() && isOnPreviousPageBtn(msg->x,msg->y))
{
log_msg("push down left button previous page\n");
@@ -100,6 +106,7 @@ Unit* STDCALL statsPageMouseDown(sWinMessage* msg)
freeMessage(msg);
return NULL;
}
+ */
return ptChar;
}
@@ -110,6 +117,13 @@ Unit* STDCALL statsPageMouseUp(sWinMessage* msg)
if (!active_newInterfaces || !D2isLODGame() ) return ptChar;
+ if (statsLeftUp(msg)) {
+ isDownBtn.all=0;
+ freeMessage(msg);
+ return NULL;
+ }
+
+ /*
if (D2GetResolution() && isOnPreviousPageBtn(msg->x,msg->y))
{
log_msg("push up left button previous page\n");
@@ -134,6 +148,7 @@ Unit* STDCALL statsPageMouseUp(sWinMessage* msg)
return NULL;
}
}
+ */
isDownBtn.all=0;
return ptChar;
diff --git a/PlugY/LocalizedStrings.cpp b/PlugY/LocalizedStrings.cpp
index 70595ee..3c76d87 100644
--- a/PlugY/LocalizedStrings.cpp
+++ b/PlugY/LocalizedStrings.cpp
@@ -51,7 +51,7 @@ LPCWSTR getLocalTypeString(DWORD code)
{
if (sLocalizedTypeStrings[i].code == code)
{
- log_msg("Code=%08X\n", code);
+ //log_msg("Code=%08X\n", code);
if (sLocalizedTypeStrings[i].itemStr)
return StripGender(D2GetStringFromString(sLocalizedTypeStrings[i].itemStr));
LPWSTR text = StripGender(sLocalizedTypeStrings[i].typeLocalizedString);
@@ -300,6 +300,8 @@ void loadLocalizedStrings(int language)
LOAD(STR_SHARED_GOLD_QUANTITY);
LOAD(STR_PREVIOUS_PAGE);
LOAD(STR_NEXT_PAGE);
+ LOAD(STR_PREVIOUS_RUNE);
+ LOAD(STR_NEXT_RUNE);
LOAD(STR_ITEM_LEVEL);
LOAD(STR_PAGE_TYPE_CHANGE);
diff --git a/PlugY/LocalizedStrings.h b/PlugY/LocalizedStrings.h
index 9fb08e7..0e7b83d 100644
--- a/PlugY/LocalizedStrings.h
+++ b/PlugY/LocalizedStrings.h
@@ -37,6 +37,8 @@ enum eStringList
STR_SHARED_GOLD_QUANTITY,
STR_PREVIOUS_PAGE,
STR_NEXT_PAGE,
+ STR_PREVIOUS_RUNE,
+ STR_NEXT_RUNE,
STR_ITEM_LEVEL,
STR_PAGE_TYPE_CHANGE,
//
diff --git a/PlugY/NewInterface_CubeListing.cpp b/PlugY/NewInterface_CubeListing.cpp
index 1c54331..d50c8bc 100644
--- a/PlugY/NewInterface_CubeListing.cpp
+++ b/PlugY/NewInterface_CubeListing.cpp
@@ -233,12 +233,6 @@ DWORD print(CubeMainBIN* curForm, LPWSTR buf, LPINT len, DWORD)//maxsize)
printInputItem(&curForm->input6, buf, len, &realNbInputs);
printInputItem(&curForm->input7, buf, len, &realNbInputs);
- if (realNbInputs != curForm->numinputs)
- {
- PRINT(BUF, L" *** ERROR : numInputs(%d) != realNbInputs(%d) ***", curForm->numinputs, realNbInputs);
- return 1;
- }
-
PRINT(BUF,L" => ");
int realNbOutputs=0;
@@ -269,6 +263,9 @@ DWORD print(CubeMainBIN* curForm, LPWSTR buf, LPINT len, DWORD)//maxsize)
// if (curForm->version == 100)
// sprintf(BUF, " [expansion only]");
+ if (realNbInputs != curForm->numinputs)
+ PRINT(BUF, L" *** ERROR : numInputs(%d) != realNbInputs(%d) ***", curForm->numinputs, realNbInputs);
+
return 1;
}
#undef BUF
diff --git a/PlugY/NewInterface_Runewords.cpp b/PlugY/NewInterface_Runewords.cpp
index 99d1f38..13efd9f 100644
--- a/PlugY/NewInterface_Runewords.cpp
+++ b/PlugY/NewInterface_Runewords.cpp
@@ -12,6 +12,7 @@
#include "common.h"
#include <stdio.h>
+/*
#define NB_RUNES_PER_PAGE 25
#define getXCloseBtn() 360
@@ -53,6 +54,7 @@ static struct
};
};
} isDownBtn;
+*/
void printRuneword(RunesBIN* runesData, DWORD pos)
@@ -64,7 +66,7 @@ void printRuneword(RunesBIN* runesData, DWORD pos)
D2SetFont(6);
DWORD nbPixel = D2GetPixelLen(lpText);
DWORD x1 = (nbPixel >= 195) ? 0 : 195-nbPixel;
- D2PrintString(lpText, x1, 10 + pos*20, GOLD, 0);//MILIEU(0x00,0x70,nbPixel)
+ D2PrintString(lpText, posXRunesList + RX(x1), posYRunesList + 10 + pos*20, GOLD, 0);//MILIEU(0x00,0x70,nbPixel)
typesList[0]=L'\0';
DWORD numItype=0;
@@ -80,7 +82,7 @@ void printRuneword(RunesBIN* runesData, DWORD pos)
}
nbPixel = D2GetPixelLen(typesList);
x1 = (nbPixel >= 195) ? 0 : 195-nbPixel;
- D2PrintString(typesList, x1, 20 + pos*20, WHITE, 0);//MILIEU(0x70,0xA0,nbPixel)
+ D2PrintString(typesList, posXRunesList + RX(x1), posYRunesList + 20 + pos*20, WHITE, 0);//MILIEU(0x70,0xA0,nbPixel)
runesList[0]=L'\0';
DWORD numRune=0;
@@ -115,7 +117,7 @@ void printRuneword(RunesBIN* runesData, DWORD pos)
}
// x1 = (nbPixel < 145) ? 155 : 300-nbPixel;
- D2PrintString(runesList, x1, y1 + pos*20, WHITE, 0);//MILIEU(0xD0,0xA0,nbPixel)
+ D2PrintString(runesList, posXRunesList + RX(x1), posYRunesList + y1 + pos*20, WHITE, 0);//MILIEU(0xD0,0xA0,nbPixel)
}
@@ -123,48 +125,58 @@ void printRuneword(RunesBIN* runesData, DWORD pos)
//6FB21FAA
void STDCALL printRunewordsPage()
{
- if (!D2isLODGame() || !D2GetResolution()) return D2PrintStatsPage();
+ if (!D2isLODGame()) return D2PrintStatsPage();
LPWSTR lpText;
- bDontPrintBorder = true;
+ bDontPrintBorder = D2GetResolution()? true : false;
//Init data for print image
sDrawImageInfo data;
ZeroMemory(&data,sizeof(data));
//print background
-/* setImage(&data, newStatsInterfaceImages);
+ fillRect(RX(0), RY(ResolutionY), 512, 768, 0, 5);
+ setImage(&data, newStatsInterfaceImages);
setFrame(&data, 0);
- D2PrintImage(&data, 0, 256, -1, 5, 0);
+ D2PrintImage(&data, RX(0), RY(ResolutionY-256), -1, 5, 0);
setFrame(&data, 1);
- D2PrintImage(&data, 256,256, -1, 5, 0);
+ D2PrintImage(&data, RX(256),RY(ResolutionY-256), -1, 5, 0);
setFrame(&data, 2);
- D2PrintImage(&data, 0, 512, -1, 5, 0);
+ D2PrintImage(&data, RX(0), RY(ResolutionY-256*2), -1, 5, 0);
setFrame(&data, 3);
- D2PrintImage(&data, 256,512, -1, 5, 0);
+ D2PrintImage(&data, RX(256),RY(ResolutionY-256*2), -1, 5, 0);
setFrame(&data, 4);
- D2PrintImage(&data, 0, 552, -1, 5, 0);
+ D2PrintImage(&data, RX(0), RY(ResolutionY-256*3), -1, 5, 0);
setFrame(&data, 5);
- D2PrintImage(&data, 256,552, -1, 5, 0);
-*/
- fillRect(0,0,400,552,0,5);
+ D2PrintImage(&data, RX(256),RY(ResolutionY-256*3), -1, 5, 0);
+
+ if (printBackgroundOnMainPage)
+ {
+ setImage(&data, statsBackgroundImages);
+ setFrame(&data, 1);
+ D2PrintImage(&data, getXPreviousPageBtn()-7, getYPreviousPageBtn()+8, -1, 5, 0);
+ D2PrintImage(&data, getXPrevRunesBtn()-7, getYPrevRunesBtn()+8, -1, 5, 0);
+ }
//print button close
setImage(&data, D2LoadBuySelBtn());
setFrame(&data, 10 + isDownBtn.close);
D2PrintImage(&data, getXCloseBtn(), getYCloseBtn(), -1, 5, 0);
+ //print previous page button
+ setFrame(&data, 12 + isDownBtn.previousPage);
+ D2PrintImage(&data, getXPreviousPageBtn(), getYPreviousPageBtn(), -1, 5, 0);
+
//print next page button
- setFrame(&data, isDownBtn.nextPage);
+ setFrame(&data, 14 + isDownBtn.nextPage);
D2PrintImage(&data, getXNextPageBtn(), getYNextPageBtn(), -1, 5, 0);
//print previous runes button
- setImage(&data, stashBtnsImages);
- setFrame(&data, isDownBtn.prevRunes);
+ setFrame(&data, 12 + isDownBtn.prevRunes);
D2PrintImage(&data, getXPrevRunesBtn(), getYPrevRunesBtn(), -1, 5, 0);
//print previous runes button
- setFrame(&data, 2 + isDownBtn.nextRunes);
+ setFrame(&data, 14 + isDownBtn.nextRunes);
D2PrintImage(&data, getXNextRunesBtn(), getYNextRunesBtn(), -1, 5, 0);
D2SetFont(6);
@@ -181,11 +193,11 @@ void STDCALL printRunewordsPage()
{
if (!runesData->Complete || runesData->Server) continue;
nbRunesCompleted++;
- if ( (curRunesPage * NB_RUNES_PER_PAGE < nbRunesCompleted) &&
- (nbRunesCompleted <= (curRunesPage+1) * NB_RUNES_PER_PAGE) )
+ if ( (curRunesPage * runesPerPage < nbRunesCompleted) &&
+ (nbRunesCompleted <= (curRunesPage+1) * runesPerPage) )
printRuneword(runesData, curNbRunes++);
}
- maxRunesPage = nbRunesCompleted ? (nbRunesCompleted-1) / NB_RUNES_PER_PAGE : 0;
+ maxRunesPage = nbRunesCompleted ? (nbRunesCompleted-1) / runesPerPage : 0;
//////////////////// POPUP PRINTING ////////////////////
@@ -197,11 +209,26 @@ void STDCALL printRunewordsPage()
{
D2PrintPopup(D2GetStringFromIndex(0x1030), getXCloseBtn()+getLCloseBtn()/2, getYCloseBtn()-getHCloseBtn(), WHITE, 1);
}
+ else if (isOnPreviousPageBtn(x,y)) //print popup "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 = getLocalString(STR_NEXT_PAGE);
D2PrintPopup(lpText, getXNextPageBtn()+getLNextPageBtn()/2, getYNextPageBtn()-getHNextPageBtn(), WHITE, 1);
}
+ else if (isOnPrevRunesBtn(x,y)) // print popup "previous rune"
+ {
+ lpText = getLocalString(STR_PREVIOUS_RUNE);
+ D2PrintPopup(lpText, getXPrevRunesBtn()+getLPrevRunesBtn()/2, getYPrevRunesBtn()-getHPrevRunesBtn(), WHITE, 1);
+ }
+ else if (isOnNextRunesBtn(x,y)) // print popup "next rune"
+ {
+ lpText = getLocalString(STR_NEXT_RUNE);
+ D2PrintPopup(lpText, getXNextRunesBtn()+getLNextRunesBtn()/2, getYNextRunesBtn()-getHNextRunesBtn(), WHITE, 1);
+ }
}
//////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/PlugY/NewInterface_Stats.cpp b/PlugY/NewInterface_Stats.cpp
index 10fa32d..d73c5da 100644
--- a/PlugY/NewInterface_Stats.cpp
+++ b/PlugY/NewInterface_Stats.cpp
@@ -13,6 +13,7 @@
#include <stdio.h>
+/*
#define getXCloseBtn() 360
#define getLCloseBtn() 32
#define getYCloseBtn() (ResolutionY - 60)
@@ -92,6 +93,7 @@ void** ptD2AssignStatsPointsBtnImages = (void**)0x6FBB5BB4;
+/*
static struct
{
union{
@@ -111,6 +113,7 @@ static struct
};
};
} isDownBtn;
+*/
void print2Lines(WORD id, LPWSTR lpText, DWORD x, DWORD l, DWORD y)
diff --git a/PlugY/NewInterface_StatsPageTwo.cpp b/PlugY/NewInterface_StatsPageTwo.cpp
index dfdc8a1..6215dd6 100644
--- a/PlugY/NewInterface_StatsPageTwo.cpp
+++ b/PlugY/NewInterface_StatsPageTwo.cpp
@@ -12,6 +12,7 @@
#include "common.h"
#include <stdio.h>
+/*
#define getXCloseBtn() RX(0x110)
#define getLCloseBtn() 32
#define getYCloseBtn() RY(0x40)
@@ -29,11 +30,13 @@
#define getYNextPageBtn() RY(0x40)
#define getHNextPageBtn() 32
#define isOnNextPageBtn(x,y) isOnRect(x, y, getXNextPageBtn(), getYNextPageBtn(), getLNextPageBtn(), getHNextPageBtn())
+*/
const char * STATS_INTERFACE_FILENAME = "PlugY\\statsinterface.txt";
#define BUFSIZE 0x400
+/*
static struct
{
union{
@@ -45,6 +48,7 @@ static struct
};
};
} isDownBtn;
+*/
struct statsInterfaceBIN
@@ -337,8 +341,7 @@ void STDCALL printNewStatsPageTwo(int currentPage)
WCHAR text[BUFSIZE];
LPWSTR lpText;
- bDontPrintBorder = false;
-
+ bDontPrintBorder = D2GetResolution()? true : false;
Unit* ptChar = D2GetClientPlayer();
d2_assert(!ptChar, "Printing stats page : no character selected",__FILE__,__LINE__);
@@ -349,16 +352,20 @@ void STDCALL printNewStatsPageTwo(int currentPage)
ZeroMemory(&data,sizeof(data));
//print background
- fillRect(RX(0),RY(480),320,432,0,5);//552
+ fillRect(RX(0), RY(ResolutionY), 512, 768, 0, 5);
setImage(&data, newStatsInterfaceImages);
setFrame(&data, 0);
- D2PrintImage(&data, RX(0), RY(224), -1, 5, 0);
+ D2PrintImage(&data, RX(0), RY(ResolutionY-256), -1, 5, 0);
setFrame(&data, 1);
- D2PrintImage(&data, RX(256),RY(224), -1, 5, 0);//256
+ D2PrintImage(&data, RX(256),RY(ResolutionY-256), -1, 5, 0);
setFrame(&data, 2);
- D2PrintImage(&data, RX(0), RY(48), -1, 5, 0);//432
+ D2PrintImage(&data, RX(0), RY(ResolutionY-256*2), -1, 5, 0);
setFrame(&data, 3);
- D2PrintImage(&data, RX(256),RY(48), -1, 5, 0);
+ D2PrintImage(&data, RX(256),RY(ResolutionY-256*2), -1, 5, 0);
+ setFrame(&data, 4);
+ D2PrintImage(&data, RX(0), RY(ResolutionY-256*3), -1, 5, 0);
+ setFrame(&data, 5);
+ D2PrintImage(&data, RX(256),RY(ResolutionY-256*3), -1, 5, 0);
D2SetFont(1);
for (int i=0; i<nbStatsInterface; i++)
@@ -392,10 +399,12 @@ void STDCALL printNewStatsPageTwo(int currentPage)
D2PrintString(text, x, y, WHITE, 0);
*/
- //print background previous/next page buttons
- setImage(&data, statsBackgroundImages);
- setFrame(&data, D2GetResolution()?1:0);
- D2PrintImage(&data, getXPreviousPageBtn()-7, getYPreviousPageBtn()+8, -1, 5, 0);
+ if (printBackgroundOnMainPage) {
+ //print background previous/next page buttons
+ setImage(&data, statsBackgroundImages);
+ setFrame(&data, 1);
+ D2PrintImage(&data, getXPreviousPageBtn()-7, getYPreviousPageBtn()+8, -1, 5, 0);
+ }
//print button close
setImage(&data, D2LoadBuySelBtn());
diff --git a/PlugY/NewInterfaces.cpp b/PlugY/NewInterfaces.cpp
index 2bcb2f1..91003fb 100644
--- a/PlugY/NewInterfaces.cpp
+++ b/PlugY/NewInterfaces.cpp
@@ -22,11 +22,39 @@ bool active_newInterfaces=false;
bool selectMainPageOnOpenning=true;
bool printBackgroundOnMainPage=true;
+int posXNextPageBtn = -1;
+int posYNextPageBtn = -1;
+int posXPrevPageBtn = -1;
+int posYPrevPageBtn = -1;
+int posXClosePageBtn = -1;
+int posYClosePageBtn = -1;
+int posXNextRuneBtn = -1;
+int posYNextRuneBtn = -1;
+int posXPrevRuneBtn = -1;
+int posYPrevRuneBtn = -1;
+int posXRunesList = -1;
+int posYRunesList = -1;
+int runesPerPage = -1;
+
+DWORD getXNextPageBtn() {return RX(posXNextPageBtn);}
+DWORD getYNextPageBtn() {return RY(posYNextPageBtn);}
+DWORD getXPreviousPageBtn() {return RX(posXPrevPageBtn);}
+DWORD getYPreviousPageBtn() {return RY(posYPrevPageBtn);}
+DWORD getXCloseBtn() {return RX(posXClosePageBtn);}
+DWORD getYCloseBtn() {return RY(posYClosePageBtn);}
+DWORD getXNextRunesBtn() {return RX(posXNextRuneBtn);}
+DWORD getYNextRunesBtn() {return RY(posYNextRuneBtn);}
+DWORD getXPrevRunesBtn() {return RX(posXPrevRuneBtn);}
+DWORD getYPrevRunesBtn() {return RY(posYPrevRuneBtn);}
+
DWORD bDontPrintBorder=false;
int selectedPage=0;
int lastPage=0;
int extraHiddenPage=0;
+int curRunesPage=0;
+int maxRunesPage=0xFFFF;
+BtnState isDownBtn={0};
void GoNextStatPage()
{
@@ -44,8 +72,12 @@ void GoPreviousStatPage()
void GoStatPage(int page)
{
- if ( (page >= 0) && (page <= lastPage + (D2GetResolution()? extraHiddenPage : 0)) )
+ if ( (page >= 0) && (page <= (lastPage + extraHiddenPage)) )
selectedPage = page;
+ else if (page < 0)
+ selectedPage = lastPage + extraHiddenPage;
+ else
+ selectedPage = 0;
}
int GetCurrentPage()
@@ -83,6 +115,16 @@ DWORD STDCALL mouseCustomPageLeftDown(sWinMessage* msg)
DWORD STDCALL mouseCustomPageLeftUp(sWinMessage* msg)
{
if(onRealm) return -1;
+
+ if (selectedPage == 0) return -1;
+ if (!isOnStatsPage(msg->x,msg->y)) return 1;
+ statsLeftUp(msg);
+ D2CleanStatMouseUp();
+ freeMessage(msg);
+ isDownBtn.all=0;
+ return 0;
+
+ /*
if ( (selectedPage > 0) && (selectedPage <= lastPage) )
return mouseNewStatsPageTwoLeftUp(msg);
else if (selectedPage == lastPage+1)
@@ -91,6 +133,87 @@ DWORD STDCALL mouseCustomPageLeftUp(sWinMessage* msg)
return mouseNewStatsPageLeftUp(msg);
else
return -1;
+ */
+}
+
+DWORD STDCALL statsLeftDown(sWinMessage* msg)
+{
+ if (isOnCloseBtn(msg->x,msg->y) && selectedPage != 0)
+ {
+ log_msg("push down left button close\n");
+ isDownBtn.close = 1;
+ D2PlaySound(4,0,0,0,0);
+ return 1;
+ }
+ else if (isOnPreviousPageBtn(msg->x,msg->y))
+ {
+ log_msg("push down left button previous page\n");
+ isDownBtn.previousPage = 1;
+ D2PlaySound(4,0,0,0,0);
+ return 1;
+ }
+ else if (isOnNextPageBtn(msg->x,msg->y))
+ {
+ log_msg("push down left button next page\n");
+ isDownBtn.nextPage = 1;
+ D2PlaySound(4,0,0,0,0);
+ return 1;
+ }
+ else if (isOnPrevRunesBtn(msg->x,msg->y) && selectedPage == (lastPage + extraHiddenPage))
+ {
+ log_msg("push down left button prev runes\n");
+ isDownBtn.prevRunes = 1;
+ D2PlaySound(4,0,0,0,0);
+ return 1;
+ }
+ else if (isOnNextRunesBtn(msg->x,msg->y) && selectedPage == (lastPage + extraHiddenPage))
+ {
+ log_msg("push down left button next runes\n");
+ isDownBtn.nextRunes = 1;
+ D2PlaySound(4,0,0,0,0);
+ return 1;
+ }
+ return 0;
+}
+
+DWORD STDCALL statsLeftUp(sWinMessage* msg)
+{
+ if (isOnCloseBtn(msg->x,msg->y) && selectedPage != 0)
+ {
+ log_msg("push up left button close\n");
+ if (isDownBtn.close)
+ D2TogglePage(2,1,0);
+ return 1;
+ }
+ else if (isOnPreviousPageBtn(msg->x,msg->y))
+ {
+ log_msg("push up left button previous page\n");
+ if (isDownBtn.previousPage)
+ GoStatPage(selectedPage-1);
+ return 1;
+ }
+ else if (isOnNextPageBtn(msg->x,msg->y))
+ {
+ log_msg("push up left button next page\n");
+ if (isDownBtn.nextPage)
+ GoStatPage(selectedPage+1);
+ return 1;
+ }
+ else if (isOnPrevRunesBtn(msg->x,msg->y) && selectedPage == (lastPage + extraHiddenPage))
+ {
+ log_msg("push up left button prev runes\n");
+ if (isDownBtn.prevRunes && curRunesPage)
+ curRunesPage--;
+ return 1;
+ }
+ else if (isOnNextRunesBtn(msg->x,msg->y) && selectedPage == (lastPage + extraHiddenPage))
+ {
+ log_msg("push up left button next runes\n");
+ if (isDownBtn.nextRunes && (curRunesPage < maxRunesPage))
+ curRunesPage++;
+ return 1;
+ }
+ return 0;
}
FCT_ASM ( caller_DontPrintBorder_114 )
@@ -474,6 +597,7 @@ void Install_NewInterfaces()
//00498636 |. 6A 48 PUSH 48
//00498638 |. 8D45 B8 LEA EAX,DWORD PTR SS:[EBP-48]
+ /* Conflicts with D2ExpRes
// Manage mouse down (Play sound)
mem_seek R8(D2Client, 2A9DC, 2A9CC, 312A5, 82736, 891B6, 6B116, BCD36, BF4D6, A7731);
memt_byte( 0x8D, 0xE8 ); // CALL
@@ -486,6 +610,7 @@ void Install_NewInterfaces()
//6FB6CD36 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//6FB6F4D6 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//004A7731 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
+ */
// Manage mouse up
mem_seek R8(D2Client, 2ABBB, 2ABAB, 3148D, 836D9, 8A159, 6C0B9, BDCB9, C0459, A78DA);
diff --git a/PlugY/Parameters.cpp b/PlugY/Parameters.cpp
index b4dc915..392c112 100644
--- a/PlugY/Parameters.cpp
+++ b/PlugY/Parameters.cpp
@@ -58,6 +58,7 @@ const char* S_dllFilenames2 = "DllToLoad2";
const char* S_active_Commands = "ActiveCommands";
const char* S_active_CheckMemory = "ActiveCheckMemory";
const char* S_active_othersFeatures = "ActiveAllOthersFeatures";
+const char* S_saveFileStackSize = "SaveFileStackSize";
const char* S_WINDOWED = "WINDOWED";
const char* S_ActiveWindowed = "ActiveWindowed";
@@ -214,6 +215,19 @@ const char* S_INTERFACE = "INTERFACE";
const char* S_active_newInterfaces = "ActiveNewStatsInterface";
const char* S_selectMainPageOnOpenning = "SelectMainPageOnOpenning";
const char* S_printBackgroundOnMainPage = "PrintButtonsBackgroundOnMainStatsPage";
+const char* S_posXNextPageBtn = "PosXNextPageBtn";
+const char* S_posYNextPageBtn = "PosYNextPageBtn";
+const char* S_posXPrevPageBtn = "PosXPrevPageBtn";
+const char* S_posYPrevPageBtn = "PosYPrevPageBtn";
+const char* S_posXClosePageBtn = "PosXClosePageBtn";
+const char* S_posYClosePageBtn = "PosYClosePageBtn";
+const char* S_posXNextRuneBtn = "PosXNextRuneBtn";
+const char* S_posYNextRuneBtn = "PosYNextRuneBtn";
+const char* S_posXPrevRuneBtn = "PosXPrevRuneBtn";
+const char* S_posYPrevRuneBtn = "PosYPrevRuneBtn";
+const char* S_posXRunesList = "PosXRunesList";
+const char* S_posYRunesList = "PosYRunesList";
+const char* S_runesPerPage = "RunesPerPage";
const char* S_EXTRA = "EXTRA";
const char* S_active_RunLODs = "ActiveLaunchAnyNumberOfLOD";
@@ -316,6 +330,10 @@ void init_General(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFi
active_othersFeatures = atoi(buffer) != 0;
log_msg("active_othersFeatures\t\t= %u\n", active_othersFeatures);
+ GET_PRIVATE_PROFILE_STRING(S_GENERAL, S_saveFileStackSize, "8192");
+ saveFileStackSize = atoi(buffer);
+ log_msg("SaveFileStackSize\t\t\t= %u\n", saveFileStackSize);
+
log_msg("\n");
}
@@ -1032,6 +1050,52 @@ void init_NewInterfaces(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDef
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_printBackgroundOnMainPage, "1");
printBackgroundOnMainPage = atoi(buffer) != 0;
log_msg("printBackgroundOnMainPage\t= %u\n", printBackgroundOnMainPage);
+
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posXNextPageBtn, "161");
+ posXNextPageBtn = atoi(buffer);
+ log_msg("posXNextPageBtn\t= %d\n", posXNextPageBtn);
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posYNextPageBtn, "64");
+ posYNextPageBtn = atoi(buffer);
+ log_msg("posYNextPageBtn\t= %d\n", posYNextPageBtn);
+
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posXPrevPageBtn, "119");
+ posXPrevPageBtn = atoi(buffer);
+ log_msg("posXPrevPageBtn\t= %d\n", posXPrevPageBtn);
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posYPrevPageBtn, "64");
+ posYPrevPageBtn = atoi(buffer);
+ log_msg("posYPrevPageBtn\t= %d\n", posYPrevPageBtn);
+
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posXClosePageBtn, "360");
+ posXClosePageBtn = atoi(buffer);
+ log_msg("posXClosePageBtn\t= %d\n", posXClosePageBtn);
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posYClosePageBtn, "64");
+ posYClosePageBtn = atoi(buffer);
+ log_msg("posYClosePageBtn\t= %d\n", posYClosePageBtn);
+
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posXNextRuneBtn, "302");
+ posXNextRuneBtn = atoi(buffer);
+ log_msg("posXNextRuneBtn\t= %d\n", posXNextRuneBtn);
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posYNextRuneBtn, "64");
+ posYNextRuneBtn = atoi(buffer);
+ log_msg("posYNextRuneBtn\t= %d\n", posYNextRuneBtn);
+
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posXPrevRuneBtn, "260");
+ posXPrevRuneBtn = atoi(buffer);
+ log_msg("posXPrevRuneBtn\t= %d\n", posXPrevRuneBtn);
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posYPrevRuneBtn, "64");
+ posYPrevRuneBtn = atoi(buffer);
+ log_msg("posYPrevRuneBtn\t= %d\n", posYPrevRuneBtn);
+
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posXRunesList, "50");
+ posXRunesList = atoi(buffer);
+ log_msg("posXRunesList\t= %d\n", posXRunesList);
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posYRunesList, "45");
+ posYRunesList = atoi(buffer);
+ log_msg("posYRunesList\t= %d\n", posYRunesList);
+
+ GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_runesPerPage, "30");
+ runesPerPage = atoi(buffer);
+ log_msg("runesPerPage\t= %d\n", runesPerPage);
}
log_msg("\n");
}
diff --git a/PlugY/infinityStash.h b/PlugY/infinityStash.h
index 0ca6b4d..123705d 100644
--- a/PlugY/infinityStash.h
+++ b/PlugY/infinityStash.h
@@ -18,6 +18,7 @@ extern bool active_sharedStash;
extern bool active_sharedGold;
extern bool separateHardSoftStash;
extern char* sharedStashFilename;
+extern DWORD saveFileStackSize;
extern bool displaySharedSetItemNameInGreen;
extern int posXPreviousBtn;
diff --git a/PlugY/newInterfaces.h b/PlugY/newInterfaces.h
index de51f26..c4c4ff3 100644
--- a/PlugY/newInterfaces.h
+++ b/PlugY/newInterfaces.h
@@ -9,20 +9,94 @@
#include "common.h"
#define MILIEU(X,L,N) (X + ((N<L)? (L-N)/2 : 0))
-#define isOnStatsPage(x,y) ((x<400) && (y<553))
+#define isOnStatsPage(x,y) (x<RX(512))
extern DWORD bDontPrintBorder;
+extern int selectedPage;
extern int extraHiddenPage;
+extern int curRunesPage;
+extern int maxRunesPage;
void GoNextStatPage();
void GoPreviousStatPage();
void GoStatPage(int page);
int GetCurrentPage();
+struct BtnState
+{
+ union{
+ DWORD all;
+ struct{
+ DWORD AssSTR:1;
+ DWORD AssDEX:1;
+ DWORD AssVIT:1;
+ DWORD AssENE:1;
+ DWORD UnaSTR:1;
+ DWORD UnaDEX:1;
+ DWORD UnaVIT:1;
+ DWORD UnaENE:1;
+ DWORD close:1;
+ DWORD previousPage:1;
+ DWORD nextPage:1;
+ DWORD prevRunes:1;
+ DWORD nextRunes:1;
+ };
+ };
+};
+extern BtnState isDownBtn;
+
extern bool active_newInterfaces;
extern bool selectMainPageOnOpenning;
extern bool printBackgroundOnMainPage;
+extern int posXNextPageBtn;
+extern int posYNextPageBtn;
+extern int posXPrevPageBtn;
+extern int posYPrevPageBtn;
+extern int posXClosePageBtn;
+extern int posYClosePageBtn;
+extern int posXNextRuneBtn;
+extern int posYNextRuneBtn;
+extern int posXPrevRuneBtn;
+extern int posYPrevRuneBtn;
+extern int posXRunesList;
+extern int posYRunesList;
+extern int runesPerPage;
+
+DWORD getXNextPageBtn();
+DWORD getYNextPageBtn();
+DWORD getXPreviousPageBtn();
+DWORD getYPreviousPageBtn();
+DWORD getXCloseBtn();
+DWORD getYCloseBtn();
+DWORD getXNextRunesBtn();
+DWORD getYNextRunesBtn();
+DWORD getXPrevRunesBtn();
+DWORD getYPrevRunesBtn();
+
+#define getLCloseBtn() 32
+#define getHCloseBtn() 32
+#define isOnCloseBtn(x,y) isOnRect(x, y, getXCloseBtn(), getYCloseBtn(), getLCloseBtn(), getHCloseBtn())
+
+#define getLPreviousPageBtn() 32
+#define getHPreviousPageBtn() 32
+#define isOnPreviousPageBtn(x,y) isOnRect(x, y, getXPreviousPageBtn(), getYPreviousPageBtn(), getLPreviousPageBtn(), getHPreviousPageBtn())
+
+#define getLNextPageBtn() 32
+#define getHNextPageBtn() 32
+#define isOnNextPageBtn(x,y) isOnRect(x, y, getXNextPageBtn(), getYNextPageBtn(), getLNextPageBtn(), getHNextPageBtn())
+
+#define getLPrevRunesBtn() 32
+#define getHPrevRunesBtn() 32
+#define isOnPrevRunesBtn(x,y) isOnRect(x, y, getXPrevRunesBtn(), getYPrevRunesBtn(), getLPrevRunesBtn(), getHPrevRunesBtn())
+
+#define getLNextRunesBtn() 32
+#define getHNextRunesBtn() 32
+#define isOnNextRunesBtn(x,y) isOnRect(x, y, getXNextRunesBtn(), getYNextRunesBtn(), getLNextRunesBtn(), getHNextRunesBtn())
+
+DWORD STDCALL statsLeftDown(sWinMessage* msg);
+DWORD STDCALL statsLeftUp(sWinMessage* msg);
+
void Install_NewInterfaces();
/*================================= END OF FILE =================================*/
\ No newline at end of file
diff --git a/PlugY/parameters.h b/PlugY/parameters.h
index d426c99..1cf884c 100644
--- a/PlugY/parameters.h
+++ b/PlugY/parameters.h
@@ -6,7 +6,7 @@
=================================================================*/
#pragma once
-#define PLUGY_VERSION "14.03"
+#define PLUGY_VERSION "14.03 HD"
enum TargetMod
{

20
PlugY/Backup/PlugY.sln Normal file
View File

@ -0,0 +1,20 @@

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
Debug|Win32 = Debug|Win32
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{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
EndGlobalSection
EndGlobal

24
PlugY/BigStash.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Use a more big stash Use a more big stash
@ -44,15 +45,26 @@ InventoryBIN* STDCALL modifStashGrid(InventoryBIN* ptInventoryBin)
return ptInventoryBin; return ptInventoryBin;
} }
FCT_ASM ( caller_modifStashGrid ) FCT_ASM ( caller_modifStashGrid )
POP ESI PUSH DWORD PTR SS:[ESP+0x14]
PUSH DWORD PTR SS:[ESP+0x14]
PUSH DWORD PTR SS:[ESP+0x14]
PUSH DWORD PTR SS:[ESP+0x14]
PUSH DWORD PTR SS:[ESP+0x14]
CALL D2CompileTxtFile CALL D2CompileTxtFile
PUSH EAX PUSH EAX
CALL modifStashGrid CALL modifStashGrid
JMP ESI RETN 0x14
}} }}
//FCT_ASM ( caller_modifStashGrid )
// POP ESI
// CALL D2CompileTxtFile
// PUSH EAX
// CALL modifStashGrid
// JMP ESI
//}}
FCT_ASM ( caller_changeTradeStash ) FCT_ASM ( caller_changeTradeStash )
CMP onRealm,0 CMP onRealm,0
JNZ normalTradeStash JNZ normalTradeStash
@ -77,7 +89,7 @@ void Install_BigStash()
log_msg("Patch D2Common & D2Client for make 10x10 squares in the stash. (BigStash)\n"); log_msg("Patch D2Common & D2Client for make 10x10 squares in the stash. (BigStash)\n");
// modification of stash grid // modification of stash grid
mem_seek R7(D2Common, C9F3, CA03, 14ED3, 5FCB5, 2A505, 1BDB5, 82CA5, 6CC25); mem_seek R8(D2Common, C9F3, CA03, 14ED3, 5FCB5, 2A505, 1BDB5, 82CA5, 6CC25, 25C0F8);
MEMC_REF4( D2CompileTxtFile, caller_modifStashGrid); MEMC_REF4( D2CompileTxtFile, caller_modifStashGrid);
//01B64ED2 |. E8 99AEFFFF CALL D2Common.#10578 //01B64ED2 |. E8 99AEFFFF CALL D2Common.#10578
//6FDAFCB4 |. E8 A7C3FCFF CALL D2Common.#10653 //6FDAFCB4 |. E8 A7C3FCFF CALL D2Common.#10653
@ -85,9 +97,10 @@ void Install_BigStash()
//6FD6BDB4 |. E8 97600200 CALL D2Common.#10244 ; \#10244 //6FD6BDB4 |. E8 97600200 CALL D2Common.#10244 ; \#10244
//6FDD2CA4 |. E8 97C2FDFF CALL D2Common.#10849 ; \#10849 //6FDD2CA4 |. E8 97C2FDFF CALL D2Common.#10849 ; \#10849
//6FDBCC24 |. E8 B7FEF9FF CALL D2Common.#10037 ; \#10037 //6FDBCC24 |. E8 B7FEF9FF CALL D2Common.#10037 ; \#10037
//0065C0F7 |. E8 F461FBFF CALL Game.006122F0 ; \Game.006122F0
// modification of stash background // modification of stash background
mem_seek R7(D2Client, 45B1C, 45B1C, 4C61C, A643C, 749BC, A9D7C, 8CC1C, 943FC); mem_seek R8(D2Client, 45B1C, 45B1C, 4C61C, A643C, 749BC, A9D7C, 8CC1C, 943FC, 89EB5);
memt_byte( 0x68, 0xE8 ); // CALL caller_changeTradeStash memt_byte( 0x68, 0xE8 ); // CALL caller_changeTradeStash
MEMT_REF4( 0x00000104, caller_changeTradeStash); MEMT_REF4( 0x00000104, caller_changeTradeStash);
//6FAEC61C |. 68 04010000 PUSH 104 //6FAEC61C |. 68 04010000 PUSH 104
@ -96,6 +109,7 @@ void Install_BigStash()
//6FB59D7C |. 68 04010000 PUSH 104 //6FB59D7C |. 68 04010000 PUSH 104
//6FB3CC1C |. 68 04010000 PUSH 104 //6FB3CC1C |. 68 04010000 PUSH 104
//6FB443FC |. 68 04010000 PUSH 104 //6FB443FC |. 68 04010000 PUSH 104
//00489EB5 |. 68 04010000 PUSH 104 ; |Arg2 = 00000104
log_msg("\n"); log_msg("\n");

262
PlugY/Commands.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Updating server. Updating server.
@ -14,6 +15,8 @@
#include "extraOptions.h" #include "extraOptions.h"
#include "windowed.h" #include "windowed.h"
#include "common.h" #include "common.h"
#include "savePlayerData.h"
#include <stdio.h>
bool active_Commands=true; bool active_Commands=true;
@ -22,6 +25,8 @@ bool active_savegame=false;
#define MAX_CMD_SIZE 200 #define MAX_CMD_SIZE 200
const char * CMD_PLAYERS="players set to";
const char * CMD_SAVE="/save"; const char * CMD_SAVE="/save";
const char * CMD_SELECTPAGE="/page"; const char * CMD_SELECTPAGE="/page";
@ -32,13 +37,19 @@ const char * CMD_UNLOCK_MOUSE2 = "/unlock";
const char * CMD_RENAME_CHAR="/renamechar"; const char * CMD_RENAME_CHAR="/renamechar";
const char * CMD_REPAGE_NAME = "/renamepage"; const char * CMD_RENAME_PAGE = "/renamepage";
const char * CMD_SHORT_RENAME_PAGE = "/rp";
const char * CMD_SET_INDEX = "/setindex"; const char * CMD_SET_INDEX = "/setindex";
const char * CMD_SET_MAIN_INDEX = "/setmainindex";
const char * CMD_RESET_INDEX = "/resetindex"; const char * CMD_RESET_INDEX = "/resetindex";
const char * CMD_INSERT_PAGE = "/insertpage"; const char * CMD_INSERT_PAGE = "/insertpage";
const char * CMD_SHORT_INSERT_PAGE = "/ip";
const char * CMD_DELETE_PAGE = "/deletepage"; const char * CMD_DELETE_PAGE = "/deletepage";
const char * CMD_SWAP = "/swap"; const char * CMD_SHORT_DELETE_PAGE = "/dp";
const char * CMD_TOGGLE = "/toggle"; const char * CMD_SWAP_PAGE = "/swappage";
const char * CMD_SHORT_SWAP_PAGE = "/sp";
const char * CMD_TOGGLE_PAGE = "/togglepage";
const char * CMD_SHORT_TOGGLE_PAGE = "/tp";
const char * CMD_DISPLAY_MANA_LIFE = "/dml"; const char * CMD_DISPLAY_MANA_LIFE = "/dml";
const char * CMD_DISPLAY_LIFE_MANA = "/dlm"; const char * CMD_DISPLAY_LIFE_MANA = "/dlm";
@ -169,29 +180,29 @@ void gambleReload(Unit* ptChar)
*/ */
void gambleReload(Unit* ptChar) /*void gambleReload(Unit* ptChar)
{ {
Unit* ptNPC = D2GetCurrentNPC(); Unit* ptNPC = D2GetCurrentNPC();
if (ptNPC) if (ptNPC)
{ {
D2TogglePage(0xC,1,0); D2TogglePage(0xC,1,0);
__asm { //Game* ptGame = ptChar->ptGame;
NOP //DWORD caller = offset_D2Game + 0x74900;
NOP //__asm {
NOP // PUSH 0
NOP // PUSH 6
NOP // PUSH 2
NOP // PUSH ptGame
NOP // MOV ECX, ptChar
NOP // CALL caller
NOP //}
NOP //0330CD70 . 837C24 08 0D CMP DWORD PTR SS:[ESP+8],0D
} D2OpenNPCMenu(ptNPC);
// D2OpenNPCMenu(ptNPC);
D2ReloadGambleScreen(); D2ReloadGambleScreen();
} }
} }
//6FACFFD4 |. E8 77F90000 CALL D2Client.6FADF950 //6FACFFD4 |. E8 77F90000 CALL D2Client.6FADF950
*/
void savePlayers(Unit* ptChar) void savePlayers(Unit* ptChar)
{ {
@ -259,7 +270,57 @@ void updateSharedGold(DWORD goldAmount)
PCPY->sharedGold = goldAmount; PCPY->sharedGold = goldAmount;
} }
bool renameCharacter(Unit* ptChar, const char* newName) bool renamePage(Unit* ptChar, char* newName)
{
Stash* ptStash = PCPY->currentStash;
if (!ptStash)
return 0;
log_msg("Rename current page on Client : '%s' -> '%s'\n", ptStash->name, newName);
int len = strlen(newName);
// trim text
while (newName[0] == ' ')
{
newName++;
len--;
}
while (len > 0 && newName[len-1] == ' ')
{
newName[len-1] = NULL;
len--;
}
// Fix max length
if (len > 20)
{
newName[20] = NULL;
len = 20;
}
// Check if new name is default name
char defautText[50];
wcstombs(defautText, getDefaultStashName(ptChar), 50);
if (!strcmp(newName, defautText))
{
newName[0] = NULL;
len = 0;
}
// Check if the name change
if (newName[0] == NULL && (ptStash->name == NULL || ptStash->name[0] == NULL))
return 0;
if (ptStash->name && !strcmp(newName, ptStash->name))
return 0;
// Rename the page
log_msg("Rename current page valid : '%s' (%s)\n", newName, defautText);
renameCurrentStash(ptChar, newName);
for (int i = 0; i <= len; i++)
updateServer(US_PAGENAME + (newName[i] << 8));
return 0;
}
bool renameCharacter(Unit* ptChar, char* newName)
{ {
int len = strlen(newName); int len = strlen(newName);
if (len < 2 || len > 15) if (len < 2 || len > 15)
@ -270,7 +331,10 @@ bool renameCharacter(Unit* ptChar, const char* newName)
if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c == '_'))) if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c == '_')))
return 1; return 1;
} }
log_msg("Rename Character : %s -> %s\n", PCPlayerData->name, newName);
// Move current save file // Move current save file
backupSaveFiles(PCPlayerData->name, -1);
{ {
char szCurrentFile[MAX_PATH]; char szCurrentFile[MAX_PATH];
char szNewFile[MAX_PATH]; char szNewFile[MAX_PATH];
@ -278,7 +342,7 @@ bool renameCharacter(Unit* ptChar, const char* newName)
//Get temporary savefile name. //Get temporary savefile name.
D2FogGetSavePath(szCurrentFile, MAX_PATH); D2FogGetSavePath(szCurrentFile, MAX_PATH);
D2FogGetSavePath(szNewFile, MAX_PATH); D2FogGetSavePath(szNewFile, MAX_PATH);
strcat(szCurrentFile, ptChar->ptPlayerData->name); strcat(szCurrentFile, PCPlayerData->name);
strcat(szNewFile, newName); strcat(szNewFile, newName);
strcat(szCurrentFile, "."); strcat(szCurrentFile, ".");
strcat(szNewFile, "."); strcat(szNewFile, ".");
@ -286,7 +350,8 @@ bool renameCharacter(Unit* ptChar, const char* newName)
int newLen = strlen(szNewFile); int newLen = strlen(szNewFile);
strcpy(&szCurrentFile[curLen], "d2s"); strcpy(&szCurrentFile[curLen], "d2s");
strcpy(&szNewFile[newLen], "d2s"); strcpy(&szNewFile[newLen], "d2s");
MoveFile(szCurrentFile, szNewFile); if (!MoveFile(szCurrentFile, szNewFile))
return 0;
strcpy(&szCurrentFile[curLen], "d2x"); strcpy(&szCurrentFile[curLen], "d2x");
strcpy(&szNewFile[newLen], "d2x"); strcpy(&szNewFile[newLen], "d2x");
MoveFile(szCurrentFile, szNewFile); MoveFile(szCurrentFile, szNewFile);
@ -312,16 +377,19 @@ bool renameCharacter(Unit* ptChar, const char* newName)
strcpy(&szNewFile[newLen], "map"); strcpy(&szNewFile[newLen], "map");
MoveFile(szCurrentFile, szNewFile); MoveFile(szCurrentFile, szNewFile);
} }
// Update server // Update server
for (int i = 0; i <= len; i++) for (int i = 0; i <= len; i++)
updateServer(US_RENAME + (newName[i] << 8)); updateServer(US_RENAME + (newName[i] << 8));
// Update client // Update client
log_msg("Rename on Client : %s -> %s\n", ptChar->ptPlayerData->name, newName); log_msg("Rename on Client : %s -> %s\n", PCPlayerData->name, newName);
strcpy(ptChar->ptPlayerData->name, newName); strcpy(PCPlayerData->name, newName);
updateServer(US_SAVE); updateServer(US_SAVE);
return 0; return 0;
} }
/****************************************************************************************************/ /****************************************************************************************************/
int STDCALL commands (char* ptText) int STDCALL commands (char* ptText)
@ -334,6 +402,14 @@ int STDCALL commands (char* ptText)
strncpy(command,ptText,MAX_CMD_SIZE-1); strncpy(command,ptText,MAX_CMD_SIZE-1);
_strlwr(command); _strlwr(command);
if (!strncmp(command, CMD_PLAYERS, strlen(CMD_PLAYERS)))
{
int nb = atoi(&command[strlen(CMD_PLAYERS)]);
if (nb > 0 && nb <= 64)
nbPlayersCommand = nb;
return 1;
}
if (!strcmp(command, CMD_SAVE)) if (!strcmp(command, CMD_SAVE))
{ {
if (onRealm) return 1; if (onRealm) return 1;
@ -364,41 +440,25 @@ int STDCALL commands (char* ptText)
if (!strncmp(command, CMD_RENAME_CHAR, strlen(CMD_RENAME_CHAR))) if (!strncmp(command, CMD_RENAME_CHAR, strlen(CMD_RENAME_CHAR)))
{ {
const char* param = &command[strlen(CMD_RENAME_CHAR)]; char* param = &ptText[strlen(CMD_RENAME_CHAR)];
if (param[0] != ' ') if (param[0] != ' ')
return 1; return 1;
param++; param++;
return renameCharacter(ptChar, param); return renameCharacter(ptChar, param);
} }
if (!strncmp(command, CMD_REPAGE_NAME,strlen(CMD_REPAGE_NAME))) if (!strncmp(command, CMD_RENAME_PAGE, strlen(CMD_RENAME_PAGE)))
{ {
if (!active_multiPageStash) return 1; if (!active_multiPageStash) return 1;
char* param = &command[strlen(CMD_REPAGE_NAME)]; char* param = &ptText[strlen(CMD_RENAME_PAGE)];
Stash* ptStash = PCPY->currentStash; return renamePage(ptChar, param);
if (!ptStash) }
return 0;
int len = strlen(param); if (!strncmp(command, CMD_SHORT_RENAME_PAGE, strlen(CMD_SHORT_RENAME_PAGE)))
while (len > 0 && param[0] == ' ')
{ {
param++; if (!active_multiPageStash) return 1;
len--; char* param = &ptText[strlen(CMD_SHORT_RENAME_PAGE)];
} return renamePage(ptChar, param);
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 (!strcmp(command, CMD_SET_INDEX))
@ -408,6 +468,13 @@ int STDCALL commands (char* ptText)
return 0; return 0;
} }
if (!strcmp(command, CMD_SET_MAIN_INDEX))
{
if (!active_multiPageStash) return 1;
updateServer(US_SET_MAIN_INDEX);
return 0;
}
if (!strcmp(command, CMD_RESET_INDEX)) if (!strcmp(command, CMD_RESET_INDEX))
{ {
if (!active_multiPageStash) return 1; if (!active_multiPageStash) return 1;
@ -423,18 +490,36 @@ int STDCALL commands (char* ptText)
return 0; return 0;
} }
if (!strcmp(command, CMD_SHORT_INSERT_PAGE))
{
if (!active_multiPageStash) return 1;
insertStash(ptChar);
updateServer(US_INSERT_PAGE);
return 0;
}
if (!strcmp(command, CMD_DELETE_PAGE)) if (!strcmp(command, CMD_DELETE_PAGE))
{ {
if (!active_multiPageStash) return 1; if (!active_multiPageStash) return 1;
if (deleteStash(ptChar)) if (deleteStash(ptChar, true))
updateServer(US_DELETE_PAGE); updateServer(US_DELETE_PAGE);
return 0; return 0;
} }
if (!strncmp(command, CMD_SWAP, strlen(CMD_SWAP))) if (!strcmp(command, CMD_SHORT_DELETE_PAGE))
{ {
if (!active_multiPageStash) return 1; if (!active_multiPageStash) return 1;
int page = atoi(&command[strlen(CMD_SWAP)]) - 1; if (deleteStash(ptChar, true))
updateServer(US_DELETE_PAGE);
return 0;
}
if (!strncmp(command, CMD_SWAP_PAGE, strlen(CMD_SWAP_PAGE)))
{
if (!active_multiPageStash) return 1;
int page = atoi(&command[strlen(CMD_SWAP_PAGE)]) - 1;
if (page < 0 && PCPY->currentStash->nextStash)
page = PCPY->currentStash->nextStash->id;
if (page < 0) if (page < 0)
return 1; return 1;
updateServer(US_SWAP3 + ((page & 0xFF000000) >> 16)); updateServer(US_SWAP3 + ((page & 0xFF000000) >> 16));
@ -444,10 +529,38 @@ int STDCALL commands (char* ptText)
return 0; return 0;
} }
if (!strncmp(command, CMD_TOGGLE, strlen(CMD_TOGGLE))) if (!strncmp(command, CMD_SHORT_SWAP_PAGE, strlen(CMD_SHORT_SWAP_PAGE)))
{
if (!active_multiPageStash) return 1;
int page = atoi(&command[strlen(CMD_SHORT_SWAP_PAGE)]) - 1;
if (page < 0 && PCPY->currentStash->nextStash)
page = PCPY->currentStash->nextStash->id;
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_PAGE, strlen(CMD_TOGGLE_PAGE)))
{ {
if (!active_sharedStash) return 1; if (!active_sharedStash) return 1;
int page = atoi(&command[strlen(CMD_TOGGLE)]) - 1; int page = atoi(&command[strlen(CMD_TOGGLE_PAGE)]) - 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;
}
if (!strncmp(command, CMD_SHORT_TOGGLE_PAGE, strlen(CMD_SHORT_TOGGLE_PAGE)))
{
if (!active_sharedStash) return 1;
int page = atoi(&command[strlen(CMD_SHORT_TOGGLE_PAGE)]) - 1;
if (page < 0) if (page < 0)
return 1; return 1;
updateServer(US_SWAP3 + ((page & 0xFF000000) >> 16)); updateServer(US_SWAP3 + ((page & 0xFF000000) >> 16));
@ -496,6 +609,45 @@ int STDCALL commands (char* ptText)
// return 0; // return 0;
//} //}
//if (!strcmp(command,"t"))
//{
// //test();
// FILE* file = fopen("D:\\tmp.txt", "wb+");
// for (int i = 0; i<= 0xFFFF; i++)
// {
// fwprintf( file, L"== %04X ===================================\n%s\n", i, D2GetStringFromIndex(i) );
// }
// fclose(file);
// return 0;
//}
if (!strcmp(command,"aa"))
{
#pragma pack(1)
struct {
BYTE displayType;//0x15 main msg; 0x14: char popup
BYTE un;
BYTE zero;
char string[0xFF];
char null;
char u1[0x100];
char u2[0x100];
char u3[0x100];
} data;
#pragma pack()
//D2SetNbPlayers(nbPlayersCommand);
memset(&data,0,sizeof(data));
data.displayType=0x15;
data.un=1;
data.zero=0;//*(BYTE*)(offset_D2Client+0x112CFC); in 1.10
data.null=NULL;
sprintf(data.string, "players %u", nbPlayersCommand);
D2SendMsgToAll((BYTE*)&data);
return 0;
}
return 1; return 1;
} }
@ -549,9 +701,9 @@ void Install_Commands()
active_savegame = version_D2Common >= V111; active_savegame = version_D2Common >= V111;
// Run custom commmand // Run custom commmand
mem_seek R7(D2Client, 2C120, 2C110, 32BDD, C1EE6, 91C16, 86926, 70AE6, B1FD6); mem_seek R8(D2Client, 2C120, 2C110, 32BDD, C1EE6, 91C16, 86926, 70AE6, B1FD6, 7C548);
memt_byte( 0x83, 0xE8 ); // CALL memt_byte( 0x83, 0xE8 ); // CALL
MEMT_REF4( 0xC08508C4 , version_D2Client == V113d ? caller_Commands_113d : version_D2Client >= V111 ? caller_Commands_111 : caller_Commands); MEMT_REF4( 0xC08508C4 , version_D2Client >= V113d ? caller_Commands_113d : version_D2Client >= V111 ? caller_Commands_111 : caller_Commands);
//6FB71EE6 . 83C4 08 ADD ESP,8 //6FB71EE6 . 83C4 08 ADD ESP,8
//6FB71EE7 . 85C0 TEST EAX,EAX //6FB71EE7 . 85C0 TEST EAX,EAX
//6FB41C16 |. 83C4 08 ADD ESP,8 //6FB41C16 |. 83C4 08 ADD ESP,8
@ -564,6 +716,8 @@ void Install_Commands()
//6FB20AE9 |. 85C0 TEST EAX,EAX //6FB20AE9 |. 85C0 TEST EAX,EAX
//6FB61FD6 |. 83C4 08 ADD ESP,8 //6FB61FD6 |. 83C4 08 ADD ESP,8
//6FB61FD9 |. 85C0 TEST EAX,EAX //6FB61FD9 |. 85C0 TEST EAX,EAX
//0047C548 |. 83C4 08 ADD ESP,8
//0047C54B |. 85C0 TEST EAX,EAX
log_msg("\n"); log_msg("\n");

377
PlugY/D2functions.cpp
View File

@ -1,6 +1,7 @@
/*================================================ /*================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
This file implements some common and useful This file implements some common and useful
function related to some Diablo II mechanisms. function related to some Diablo II mechanisms.
@ -16,9 +17,9 @@ s_shifting shifting;
#define E2S(F, A, R, N, P) T##N N; #define E2S(F, A, R, N, P) T##N N;
#define E2F(F, A, R, N, P) T##N N; #define E2F(F, A, R, N, P) T##N N;
#define E2C(F, A, T, N) T* pt##N; #define E2C(F, A, T, N) T* pt##N;
#define F7(X, Z, A,B,C,D,E,F,G,H, R, N, P) T##N N; #define F8(X, Z, A,B,C,D,E,F,G,H,I, R, N, P) T##N N;
#define A7(X, Z, A,B,C,D,E,F,G,H, R, N, P) T##N N; #define A8(X, Z, A,B,C,D,E,F,G,H,I, R, N, P) T##N N;
#define C7(Z, A,B,C,D,E,F,G,H, T, N) T* pt##N; #define C8(Z, A,B,C,D,E,F,G,H,I, T, N) T* pt##N;
#include "../Commons/D2Funcs.h" #include "../Commons/D2Funcs.h"
DataTables* SgptDataTables; DataTables* SgptDataTables;
@ -34,9 +35,9 @@ DataTables* SgptDataTables;
////E2F(D2Client,0, void, D2SendToServer13,(BYTE type, DWORD p1, DWORD p2, DWORD p3));//6FAADA70 ////E2F(D2Client,0, void, D2SendToServer13,(BYTE type, DWORD p1, DWORD p2, DWORD p3));//6FAADA70
//E2F(D2Game,0, NetClient*, D2GetClient, (Unit* ptUnit, char* lpszErrFile, DWORD ErrLine));//6FCBC2E0 //E2F(D2Game,0, NetClient*, D2GetClient, (Unit* ptUnit, char* lpszErrFile, DWORD ErrLine));//6FCBC2E0
//E2F(D2Client,0, void, D2CleanStatMouseUp, ());//6FAABF60 //E2F(D2Client,0, void, D2CleanStatMouseUp, ());//6FAABF60
#undef F7 #undef F8
#undef A7 #undef A8
#undef C7 #undef C8
#undef D2S #undef D2S
#undef D2F #undef D2F
#undef E2S #undef E2S
@ -58,9 +59,10 @@ TD2SetSkillBaseLevel V2SetSkillBaseLevel;
TD2SetSkillBaseLevelOnClient V2SetSkillBaseLevelOnClient; TD2SetSkillBaseLevelOnClient V2SetSkillBaseLevelOnClient;
TD2PrintStat V2PrintStat; TD2PrintStat V2PrintStat;
TD2CompileCubeInput V2CompileCubeInput; TD2CompileCubeInput V2CompileCubeInput;
TD2CompileCubeOutput V2CompileCubeOutput; //TD2CompileCubeOutput V2CompileCubeOutput;
TD2BroadcastFunction V2BroadcastFunction; TD2BroadcastFunction V2BroadcastFunction;
TD2GetGameByClientID V2GetGameByClientID; TD2GetGameByClientID V2GetGameByClientID;
TD2SpawnSuperUnique V2SpawnSuperUnique;
TD2SpawnMonster V2SpawnMonster; TD2SpawnMonster V2SpawnMonster;
TD2VerifIfNotCarry1 V2VerifIfNotCarry1; TD2VerifIfNotCarry1 V2VerifIfNotCarry1;
TD2GameGetObject V2GameGetObject; TD2GameGetObject V2GameGetObject;
@ -80,6 +82,10 @@ TD2GetItemStatCostBIN V2GetItemStatCostBIN;
TD2SendPacket V2SendPacket; TD2SendPacket V2SendPacket;
TD2LoadInventory V2LoadInventory; TD2LoadInventory V2LoadInventory;
TD2SaveGame V2SaveGame; TD2SaveGame V2SaveGame;
TD2MonsterUseSkill V2MonsterUseSkill;
TD2LinkPortal V2LinkPortal;
TD2Game235C0 V2Game235C0;
TD2ReadFile V2ReadFile;
//DWORD* ptNbStatDesc //DWORD* ptNbStatDesc
//DWORD* ptStatDescTable; //DWORD* ptStatDescTable;
@ -228,7 +234,7 @@ __declspec(naked) void* STDCALL compileTxtFile_9(DWORD unused, const char* filen
PUSH EDX PUSH EDX
MOV ECX,DWORD PTR SS:[ESP+0x230] MOV ECX,DWORD PTR SS:[ESP+0x230]
LEA EDX,DWORD PTR SS:[ESP+0x28] LEA EDX,DWORD PTR SS:[ESP+0x28]
CALL D2ReadFile CALL V2ReadFile
TEST EAX,EAX TEST EAX,EAX
JNZ continue_compileTxtFile JNZ continue_compileTxtFile
PUSH 0 PUSH 0
@ -267,7 +273,7 @@ __declspec(naked) void* STDCALL compileTxtFile_10(DWORD unused, const char* file
PUSH EDX PUSH EDX
MOV ECX,DWORD PTR SS:[ESP+0x230] MOV ECX,DWORD PTR SS:[ESP+0x230]
LEA EDX,DWORD PTR SS:[ESP+0x28] LEA EDX,DWORD PTR SS:[ESP+0x28]
CALL D2ReadFile CALL V2ReadFile
TEST EAX,EAX TEST EAX,EAX
JNZ continue_compileTxtFile JNZ continue_compileTxtFile
PUSH 0 PUSH 0
@ -282,6 +288,109 @@ continue_compileTxtFile:
JMP ECX JMP ECX
}} }}
DWORD compileTxtFile114_1;
DWORD compileTxtFile114_2;
DWORD compileTxtFile114_3;
DWORD compileTxtFile114_5;
DWORD compileTxtFile114_6;
DWORD compileTxtFile114_7;
__declspec(naked) void* STDCALL compileTxtFile_114(DWORD unused, const char* filename, BINField* ptFields, DWORD* ptRecordCount, DWORD recordLength)
{_asm{
PUSH EBP
MOV EBP,ESP
SUB ESP,0x11C
PUSH EBX
PUSH ESI
PUSH EDI
MOV EAX,DWORD PTR SS:[EBP+0x10]
MOV ECX,DWORD PTR SS:[EBP+0x14]
PUSH EBX
PUSH ESI
MOV ESI,DWORD PTR SS:[EBP+0x8]
PUSH EDI
MOV EDI,DWORD PTR SS:[EBP+0xC]
MOV DWORD PTR SS:[EBP-0x11C],ESI
MOV DWORD PTR SS:[EBP-0x10C],EDI
MOV DWORD PTR SS:[EBP-0x110],EAX
MOV DWORD PTR SS:[EBP-0x118],ECX
MOV DWORD PTR SS:[EBP-0x108],0
PUSH __LINE__
PUSH S_compileTxtFile
LEA EAX,DWORD PTR SS:[EBP-0x108]
PUSH EAX
MOV ECX,unused
MOV EDX,filename
CALL V2ReadFile
TEST EAX,EAX
JNZ continue_compileTxtFile
PUSH __LINE__
CALL D2GetInstructionPointer
PUSH EAX
PUSH S_errorReadTxtFile
CALL D2FogAssert
ADD ESP,0xC
PUSH -1
CALL exit
continue_compileTxtFile:
// EAX : file
// ECX : -
// EDX : -
// EBX : -
// MOV ESI,DWORD PTR SS:[EBP+8]
// MOV EDI,DWORD PTR SS:[EBP+C]
MOV ESI,DWORD PTR SS:[EBP+0xC]
MOV ECX,DWORD PTR SS:[EBP-0x108]
PUSH ECX ; /Arg2
PUSH EAX ; |Arg1
CALL compileTxtFile114_1 ; \Game.006BD640
MOV EDI,EAX
PUSH EDI ; /Arg1
CALL compileTxtFile114_2 ; \Game.006BCDE0
MOV EBX,EAX
MOV ESI,EBX
IMUL ESI,DWORD PTR SS:[EBP+0x18]
PUSH 0 ; /Arg3 = 00000000
PUSH 0x904 ; |Arg2 = 00000904
PUSH compileTxtFile114_3 ; |Arg1 = 006E6370 ASCII ".\DATATBLS\DataTbls.cpp"
MOV EDX,ESI ; |
XOR ECX,ECX ; |
CALL D2AllocMem ; \Game.0040B430
PUSH ESI
PUSH 0
PUSH EAX
MOV DWORD PTR SS:[EBP-0x10C],EAX
CALL compileTxtFile114_5
MOV EDX,DWORD PTR SS:[EBP+0x18]
MOV EAX,DWORD PTR SS:[EBP-0x10C]
MOV ECX,DWORD PTR SS:[EBP-0x110]
ADD ESP,0xC
PUSH EDX
PUSH EBX
PUSH EAX
PUSH ECX
PUSH EDI
CALL compileTxtFile114_6
PUSH EDI ; /Arg1
CALL compileTxtFile114_7 ; \Game.006BCDA0
MOV EAX, DWORD PTR SS:[EBP-0x10C]
MOV ECX,DWORD PTR SS:[EBP-0x118]
TEST ECX,ECX
JE fin
MOV DWORD PTR DS:[ECX],EBX
fin:
POP EDI
POP ESI
POP EBX
MOV ESP,EBP
POP EBP
RETN 0x14
}}
__declspec(naked) void* STDCALL compileTxtFile_111(DWORD unused, const char* filename, BINField* ptFields, DWORD* ptRecordCount, DWORD recordLength) __declspec(naked) void* STDCALL compileTxtFile_111(DWORD unused, const char* filename, BINField* ptFields, DWORD* ptRecordCount, DWORD recordLength)
{_asm{ {_asm{
SUB ESP,0x20C SUB ESP,0x20C
@ -303,7 +412,7 @@ __declspec(naked) void* STDCALL compileTxtFile_111(DWORD unused, const char* fil
PUSH EDX PUSH EDX
PUSH EAX PUSH EAX
LEA EAX,DWORD PTR SS:[ESP+0x20] LEA EAX,DWORD PTR SS:[ESP+0x20]
CALL D2ReadFile CALL V2ReadFile
TEST EAX,EAX TEST EAX,EAX
JNZ continue_compileTxtFile JNZ continue_compileTxtFile
PUSH __LINE__ PUSH __LINE__
@ -435,6 +544,22 @@ FCT_ASM ( D2GetItemStatCostBIN_111 )
JMP V2GetItemStatCostBIN JMP V2GetItemStatCostBIN
}} }}
FCT_ASM( D2SendToServer3_114 )
PUSH EDI
PUSH EBX
PUSH ECX
MOV BYTE PTR SS:[ESP],CL
MOV WORD PTR SS:[ESP+1],DX
MOV EDI,3
LEA EDX,DWORD PTR SS:[ESP]
PUSH EDX
CALL D2SendToServerXX
POP ECX
POP EBX
POP EDI
RETN
}}
FCT_ASM ( D2SendToServer3_111 ) FCT_ASM ( D2SendToServer3_111 )
PUSH EBX PUSH EBX
PUSH ECX PUSH ECX
@ -449,6 +574,19 @@ FCT_ASM ( D2SendToServer3_111 )
RETN RETN
}} }}
FCT_ASM ( D2PrintStat_114 )
PUSH ESI
MOV ESI,DWORD PTR SS:[ESP+0x14]
PUSH DWORD PTR SS:[ESP+0x10]
PUSH DWORD PTR SS:[ESP+0x10]
PUSH DWORD PTR SS:[ESP+0x10]
PUSH EDX
PUSH ECX
CALL V2PrintStat
POP ESI
RETN 0x10
}}
FCT_ASM ( D2PrintStat_111 ) FCT_ASM ( D2PrintStat_111 )
PUSH ESI PUSH ESI
MOV ESI,DWORD PTR SS:[ESP+0x14] MOV ESI,DWORD PTR SS:[ESP+0x14]
@ -462,6 +600,16 @@ FCT_ASM ( D2PrintStat_111 )
RETN 0x10 RETN 0x10
}} }}
FCT_ASM ( D2SendPacket_114 )
PUSH EDI
PUSH DWORD PTR SS:[ESP+8]
PUSH EDX
MOV EDI,ECX
CALL V2SendPacket
POP EDI
RETN 4
}}
FCT_ASM ( D2SendPacket_111 ) FCT_ASM ( D2SendPacket_111 )
POP EAX POP EAX
PUSH EDX PUSH EDX
@ -485,15 +633,22 @@ FCT_ASM ( D2CompileCubeInput_111 )
RETN 8 RETN 8
}} }}
FCT_ASM ( D2CompileCubeOutput_111 ) FCT_ASM ( D2CompileCubeInput_114 )
PUSH EBX PUSH ECX
MOV EBX,ECX MOV EAX,EDX
PUSH EDX CALL V2CompileCubeInput
CALL V2CompileCubeOutput
POP EBX
RETN 8 RETN 8
}} }}
//FCT_ASM ( D2CompileCubeOutput_111 )
// PUSH EBX
// MOV EBX,ECX
// PUSH EDX
// CALL V2CompileCubeOutput
// POP EBX
// RETN 8
//}}
FCT_ASM ( D2BroadcastFunction_111 ) FCT_ASM ( D2BroadcastFunction_111 )
PUSH EDI PUSH EDI
PUSH EBX PUSH EBX
@ -506,7 +661,7 @@ FCT_ASM ( D2BroadcastFunction_111 )
RETN 4 RETN 4
}} }}
FCT_ASM ( D2SpawnMonster_111 ) FCT_ASM ( D2SpawnSuperUnique_111 )
PUSH DWORD PTR SS:[ESP+0x18] PUSH DWORD PTR SS:[ESP+0x18]
PUSH DWORD PTR SS:[ESP+0x14] PUSH DWORD PTR SS:[ESP+0x14]
PUSH DWORD PTR SS:[ESP+0x14] PUSH DWORD PTR SS:[ESP+0x14]
@ -514,11 +669,11 @@ FCT_ASM ( D2SpawnMonster_111 )
PUSH ECX PUSH ECX
MOV ECX,DWORD PTR SS:[ESP+0x18] MOV ECX,DWORD PTR SS:[ESP+0x18]
MOV EAX,DWORD PTR SS:[ESP+0x28] MOV EAX,DWORD PTR SS:[ESP+0x28]
CALL V2SpawnMonster CALL V2SpawnSuperUnique
RETN 0x18 RETN 0x18
}} }}
FCT_ASM ( D2SpawnMonster_111b ) FCT_ASM ( D2SpawnSuperUnique_111b )
PUSH DWORD PTR SS:[ESP+0x10] PUSH DWORD PTR SS:[ESP+0x10]
PUSH DWORD PTR SS:[ESP+0x10] PUSH DWORD PTR SS:[ESP+0x10]
PUSH DWORD PTR SS:[ESP+0x10] PUSH DWORD PTR SS:[ESP+0x10]
@ -527,6 +682,37 @@ FCT_ASM ( D2SpawnMonster_111b )
MOV EAX,DWORD PTR SS:[ESP+0x18] MOV EAX,DWORD PTR SS:[ESP+0x18]
MOV EDX,DWORD PTR SS:[ESP+0x2C] MOV EDX,DWORD PTR SS:[ESP+0x2C]
MOV ECX,DWORD PTR SS:[ESP+0x28]//superuniqueID MOV ECX,DWORD PTR SS:[ESP+0x28]//superuniqueID
CALL V2SpawnSuperUnique
RETN 0x18
}}
FCT_ASM( D2SpawnSuperUnique_114 )
PUSH EBX
PUSH EDI
MOV EBX, DWORD PTR SS:[ESP+0x1C]
MOV EDI, ECX
PUSH DWORD PTR SS:[ESP+0x20]
PUSH DWORD PTR SS:[ESP+0x1C]
PUSH DWORD PTR SS:[ESP+0x1C]
PUSH DWORD PTR SS:[ESP+0x1C]
PUSH DWORD PTR SS:[ESP+0x1C]
PUSH EDX
CALL V2SpawnSuperUnique
POP EDI
POP EBX
RETN 0x18
}}
FCT_ASM ( D2SpawnMonster_114 )
PUSH DWORD PTR SS:[ESP+0x18]
PUSH DWORD PTR SS:[ESP+0x18]
PUSH EDX
PUSH ECX
PUSH DWORD PTR SS:[ESP+0x20]
PUSH DWORD PTR SS:[ESP+0x20]
MOV EDX,DWORD PTR SS:[ESP+0x20]
MOV ECX,DWORD PTR SS:[ESP+0x1C]
CALL V2SpawnMonster CALL V2SpawnMonster
RETN 0x18 RETN 0x18
}} }}
@ -593,6 +779,63 @@ FCT_ASM ( D2SaveGame_1XX )
JMP V2SaveGame JMP V2SaveGame
}} }}
FCT_ASM ( D2MonsterUseSkill_111 )
PUSH EBX
PUSH EDX
MOV EBX,ECX
MOV ECX,EDX
MOV EAX,DWORD PTR SS:[ESP+0xC]
PUSH DWORD PTR SS:[ESP+0x1C]
PUSH DWORD PTR SS:[ESP+0x1C]
PUSH DWORD PTR SS:[ESP+0x1C]
PUSH DWORD PTR SS:[ESP+0x1C]
CALL V2MonsterUseSkill
// Game sets monsters AiControl args[0] to 0 after this call
POP EDX
MOV EDX,DWORD PTR DS:[EDX+0x14]
MOV EDX,DWORD PTR DS:[EDX+0x28]
MOV DWORD PTR DS:[EDX+0x14],0
POP EBX
RETN 0x14
}}
FCT_ASM( D2LinkPortal_114 )
PUSH ECX
MOV ECX,DWORD PTR SS:[ESP+0x8]
PUSH DWORD PTR SS:[ESP+0x14]
PUSH DWORD PTR SS:[ESP+0x14]
PUSH DWORD PTR SS:[ESP+0x14]
CALL V2LinkPortal
POP ECX
RETN 0x10
}}
FCT_ASM( D2Game235C0_114 )
POP EAX
POP ECX
POP EDX
PUSH EAX
JMP V2Game235C0
}}
FCT_ASM( D2ReadFile_111 )
MOV EAX,EDX
PUSH DWORD PTR SS:[ESP+4]
PUSH ECX
CALL V2ReadFile
RETN 0xC
}}
/*FCT_ASM( D2SaveSPGame_111 )
PUSH DWORD PTR SS:[ESP+0x8]
PUSH DWORD PTR SS:[ESP+0x8]
PUSH EDX
PUSH ECX
CALL V2SaveSPGame
RETN 8
}}*/
#define SETFCTADDR(F, I, N) setFctAddr((DWORD*)&N, (HMODULE)offset_##F, (LPCSTR)I) #define SETFCTADDR(F, I, N) setFctAddr((DWORD*)&N, (HMODULE)offset_##F, (LPCSTR)I)
void setFctAddr(DWORD* addr, HMODULE module, LPCSTR index) void setFctAddr(DWORD* addr, HMODULE module, LPCSTR index)
{ {
@ -607,7 +850,7 @@ void setFctAddr(DWORD* addr, HMODULE module, LPCSTR index)
*addr = NULL; *addr = NULL;
} }
bool initD2functions() void initD2functions()
{ {
// #define D2S(F, I, R, N, P) N = (F##I)GetProcAddress((HMODULE)offset_##F, (LPCSTR)I); // #define D2S(F, I, R, N, P) N = (F##I)GetProcAddress((HMODULE)offset_##F, (LPCSTR)I);
// #define D2F(F, I, R, N, P) N = (F##I)GetProcAddress((HMODULE)offset_##F, (LPCSTR)I); // #define D2F(F, I, R, N, P) N = (F##I)GetProcAddress((HMODULE)offset_##F, (LPCSTR)I);
@ -616,33 +859,38 @@ bool initD2functions()
#define E2S(F, A, R, N, P) N = (T##N)(offset_##F + 0x##A); #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 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 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 F8(X, Z, A,B,C,D,E,F,G,H,I, R, N, P) if (version_##Z > V113d) { N = (T##N)R8(Z,A,B,C,D,E,F,G,H,I); } else 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 A8(X, Z, A,B,C,D,E,F,G,H,I, R, N, P) N = (T##N)R8(Z,A,B,C,D,E,F,G,H,I);
#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); #define C8(Z, A,B,C,D,E,F,G,H,I, T, N) pt##N = (T*)R8(Z,A,B,C,D,E,F,G,H,I);
#include "../Commons/D2Funcs.h" #include "../Commons/D2Funcs.h"
SgptDataTables = *(DataTables**) R7(D2Common, 0000, 0000, 96A20, 9B74C, 9EE8C, 9B500, 99E1C, A33F0); SgptDataTables = *(DataTables**) R8(D2Common, 0000, 0000, 96A20, 9B74C, 9EE8C, 9B500, 99E1C, A33F0, 344304);
if (version_D2Common < V110) if (version_D2Common < V110)
{ {
D2S(D2Common,10581, CharStatsBIN*, D2Common10581, (DWORD charID));//ONLY in 1.09 D2S(D2Common,10581, CharStatsBIN*, D2Common10581, (DWORD charID));//ONLY in 1.09
D2S(D2Common,10598, ItemStatCostBIN*, D2Common10598, (DWORD itemStatCostID));//ONLY in 1.09 D2S(D2Common,10598, ItemStatCostBIN*, D2Common10598, (DWORD itemStatCostID));//ONLY in 1.09
D2S(D2Common,10673, ItemTypesBIN*, D2Common10673, (DWORD itemTypesID));//ONLY in 1.09 D2S(D2Common,10673, ItemTypesBIN*, D2Common10673, (DWORD itemTypesID));//ONLY in 1.09
} }
#undef F7 #undef F8
#undef A7 #undef A8
#undef C7 #undef C8
#undef D2S #undef D2S
#undef D2F #undef D2F
#undef E2S #undef E2S
#undef E2F #undef E2F
#undef E2C #undef E2C
//////////////// MISC FCT //////////////// //////////////// MISC FCT ////////////////
//setImage = version_D2Common >= V111 ? setImage_111 : setImage_1XX; //setImage = version_D2Common >= V111 ? setImage_111 : setImage_1XX;
//setFrame = version_D2Common >= V111 ? setFrame_111 : setFrame_1XX; //setFrame = version_D2Common >= V111 ? setFrame_111 : setFrame_1XX;
getDescStrPos = version_D2Common >= V110 ? getDescStrPos_10 : getDescStrPos_9; getDescStrPos = version_D2Common >= V110 ? getDescStrPos_10 : getDescStrPos_9;
compileTxtFile = version_D2Common >= V111 ? compileTxtFile_111 : version_D2Common == V110 ? compileTxtFile_10 : compileTxtFile_9; compileTxtFile114_1 = offset_D2Client + 0x002BD640;
compileTxtFile114_2 = offset_D2Client + 0x002BCDE0;
compileTxtFile114_3 = offset_D2Client + 0x002E6370;
compileTxtFile114_5 = offset_D2Client + 0x00281EF0;
compileTxtFile114_6 = offset_D2Client + 0x002BD780;
compileTxtFile114_7 = offset_D2Client + 0x002BCDA0;
compileTxtFile = version_D2Common >= V114a ? compileTxtFile_114 : version_D2Common >= V111 ? compileTxtFile_111 : version_D2Common == V110 ? compileTxtFile_10 : compileTxtFile_9;
//////////////// SELECT RIGHT ADDR FUNCTION //////////////// //////////////// SELECT RIGHT ADDR FUNCTION ////////////////
@ -836,7 +1084,7 @@ bool initD2functions()
//V3(D2LoadSuperuniques, TD2LoadSuperuniques, D2Common, 1F500, 1F510, 29FA0, 71EB0); //V3(D2LoadSuperuniques, TD2LoadSuperuniques, D2Common, 1F500, 1F510, 29FA0, 71EB0);
//V3(D2GetItemStatCostBIN,TD2GetItemStatCostBIN, D2Common, 000, 000, 642B0, 13F0); //V3(D2GetItemStatCostBIN,TD2GetItemStatCostBIN, D2Common, 000, 000, 642B0, 13F0);
//V3(D2GetItemTypesBIN, TD2GetItemTypesBIN, D2Common, 000, 000, 2B1A0, 11F0); //V3(D2GetItemTypesBIN, TD2GetItemTypesBIN, D2Common, 000, 000, 2B1A0, 11F0);
//V3(D2SpawnMonster, TD2SpawnMonster, D2Game, 000, 000, 3F220, 4ABE0); //V3(D2SpawnSuperUnique, TD2SpawnSuperUnique, D2Game, 000, 000, 3F220, 4ABE0);
//V3(D2ReloadGambleScreen,TD2ReloadGambleScreen, D2Game, 000, 000, 000, 8E480); //V3(D2ReloadGambleScreen,TD2ReloadGambleScreen, D2Game, 000, 000, 000, 8E480);
//V3(D2SaveGame, TD2SaveGame, D2Game, 000, 000, 89C0, E2390); //V3(D2SaveGame, TD2SaveGame, D2Game, 000, 000, 89C0, E2390);
//V3(D2ClickOnStashButton,TD2ClickOnStashButton, D2Client, 000, 000, 000, A6520); //V3(D2ClickOnStashButton,TD2ClickOnStashButton, D2Client, 000, 000, 000, A6520);
@ -845,12 +1093,12 @@ bool initD2functions()
//V3(D2Game235C0, TD2Game235C0, D2Game, 000, 000, 000, D6D10); //V3(D2Game235C0, TD2Game235C0, D2Game, 000, 000, 000, D6D10);
//V3(D2OpenPandPortal, TD2OpenPandPortal, D2Game, 000, 000, 000, 9B480); //V3(D2OpenPandPortal, TD2OpenPandPortal, D2Game, 000, 000, 000, 9B480);
//V3(D2OpenPandFinalPortal,TD2OpenPandFinalPortal,D2Game, 000, 000, 000, 9B470); //V3(D2OpenPandFinalPortal,TD2OpenPandFinalPortal,D2Game, 000, 000, 000, 9B470);
//V3(D2MephIA, TD2MephIA, D2Game, 000, 000, 000, 84730); //V3(D2MephAI, TD2MephAI, D2Game, 000, 000, 000, 84730);
//V3(D2DiabloIA, TD2DiabloIA, D2Game, 000, 000, 000, 75980); //V3(D2DiabloAI, TD2DiabloAI, D2Game, 000, 000, 000, 75980);
//V3(D2BaalIA, TD2BaalIA, D2Game, 000, 000, 000, EAB20); //V3(D2BaalAI, TD2BaalAI, D2Game, 000, 000, 000, EAB20);
//V3(D2UberMephIA, TD2UberMephIA, D2Game, 000, 000, 000, 70320); //V3(D2UberMephAI, TD2UberMephAI, D2Game, 000, 000, 000, 70320);
//V3(D2UberDiabloIA, TD2UberDiabloIA, D2Game, 000, 000, 000, 7F200); //V3(D2UberDiabloAI, TD2UberDiabloAI, D2Game, 000, 000, 000, 7F200);
//V3(D2UberBaalIA, TD2UberBaalIA, D2Game, 000, 000, 000, E92B0); //V3(D2UberBaalAI, TD2UberBaalAI, D2Game, 000, 000, 000, E92B0);
//#undef V3 //#undef V3
@ -872,19 +1120,41 @@ bool initD2functions()
V2SendPacket = D2SendPacket; V2SendPacket = D2SendPacket;
V2LoadInventory = D2LoadInventory; V2LoadInventory = D2LoadInventory;
V2CompileCubeInput = D2CompileCubeInput; V2CompileCubeInput = D2CompileCubeInput;
V2CompileCubeOutput = D2CompileCubeOutput; //V2CompileCubeOutput = D2CompileCubeOutput;
V2BroadcastFunction = D2BroadcastFunction; V2BroadcastFunction = D2BroadcastFunction;
V2GetGameByClientID = D2GetGameByClientID; V2GetGameByClientID = D2GetGameByClientID;
V2SpawnSuperUnique = D2SpawnSuperUnique;
V2SpawnMonster = D2SpawnMonster; V2SpawnMonster = D2SpawnMonster;
V2VerifIfNotCarry1 = D2VerifIfNotCarry1; V2VerifIfNotCarry1 = D2VerifIfNotCarry1;
V2GameGetObject = D2GameGetObject; V2GameGetObject = D2GameGetObject;
V2TestPositionInRoom = D2TestPositionInRoom; V2TestPositionInRoom = D2TestPositionInRoom;
V2GetItemTypesBIN = D2GetItemTypesBIN; V2GetItemTypesBIN = D2GetItemTypesBIN;
V2SaveGame = D2SaveGame; V2SaveGame = D2SaveGame;
V2MonsterUseSkill = D2MonsterUseSkill;
V2LinkPortal = D2LinkPortal;
V2Game235C0 = D2Game235C0;
V2ReadFile = D2ReadFile;
//V2OpenNPCMenu = D2OpenNPCMenu; //V2OpenNPCMenu = D2OpenNPCMenu;
//////////////// REDIRECT ON CUSTOM FUNCTIONS //////////////// //////////////// REDIRECT ON CUSTOM FUNCTIONS ////////////////
if ( version_D2Client >= V111 ) if (version_D2Client == V114d)
{
D2SendToServer3 = (TD2SendToServer3) D2SendToServer3_114;
D2PrintStat = (TD2PrintStat)D2PrintStat_114;
D2SendPacket = (TD2SendPacket) D2SendPacket_114;
D2CompileCubeInput = (TD2CompileCubeInput) D2CompileCubeInput_114;
D2SpawnSuperUnique = (TD2SpawnSuperUnique) D2SpawnSuperUnique_114;
D2VerifIfNotCarry1 = (TD2VerifIfNotCarry1)D2VerifIfNotCarry1_111;
D2isLODGame = D2isLODGame_111;
D2GetMouseX = D2GetMouseX_111;
D2GetMouseY = D2GetMouseY_111;
D2SpawnMonster = (TD2SpawnMonster)D2SpawnMonster_114;
D2LinkPortal = (TD2LinkPortal)D2LinkPortal_114;
D2Game235C0 = (TD2Game235C0) D2Game235C0_114;
D2GetGameByClientID = (TD2GetGameByClientID) D2GetGameByClientID_1XX;
D2SaveGame = (TD2SaveGame) D2SaveGame_1XX;
}
else if ( version_D2Client >= V111 )
{ {
D2SendMsgToAll = (TD2SendMsgToAll) D2SendMsgToAll_111; D2SendMsgToAll = (TD2SendMsgToAll) D2SendMsgToAll_111;
D2SetColorPopup = (TD2SetColorPopup) D2SetColorPopup_111; D2SetColorPopup = (TD2SetColorPopup) D2SetColorPopup_111;
@ -900,9 +1170,9 @@ bool initD2functions()
D2SendPacket = (TD2SendPacket) D2SendPacket_111; D2SendPacket = (TD2SendPacket) D2SendPacket_111;
D2LoadInventory = (TD2LoadInventory) D2LoadInventory_111; D2LoadInventory = (TD2LoadInventory) D2LoadInventory_111;
D2CompileCubeInput = (TD2CompileCubeInput) D2CompileCubeInput_111; D2CompileCubeInput = (TD2CompileCubeInput) D2CompileCubeInput_111;
D2CompileCubeOutput = (TD2CompileCubeOutput) D2CompileCubeOutput_111; //D2CompileCubeOutput = (TD2CompileCubeOutput) D2CompileCubeOutput_111;
D2BroadcastFunction = (TD2BroadcastFunction) D2BroadcastFunction_111; D2BroadcastFunction = (TD2BroadcastFunction) D2BroadcastFunction_111;
D2SpawnMonster = version_D2Game >= V111b ? (TD2SpawnMonster)D2SpawnMonster_111b : (TD2SpawnMonster)D2SpawnMonster_111; D2SpawnSuperUnique = version_D2Game >= V111b ? (TD2SpawnSuperUnique)D2SpawnSuperUnique_111b : (TD2SpawnSuperUnique)D2SpawnSuperUnique_111;
D2VerifIfNotCarry1 = (TD2VerifIfNotCarry1) D2VerifIfNotCarry1_111; D2VerifIfNotCarry1 = (TD2VerifIfNotCarry1) D2VerifIfNotCarry1_111;
D2GameGetObject = (TD2GameGetObject) D2GameGetObject_111; D2GameGetObject = (TD2GameGetObject) D2GameGetObject_111;
D2GetItemTypesBIN = (TD2GetItemTypesBIN) D2GetItemTypesBIN_111; D2GetItemTypesBIN = (TD2GetItemTypesBIN) D2GetItemTypesBIN_111;
@ -915,10 +1185,12 @@ bool initD2functions()
D2GetClientPlayer = D2GetClientPlayer_111; D2GetClientPlayer = D2GetClientPlayer_111;
D2GetRealItem = D2GetRealItem_111; D2GetRealItem = D2GetRealItem_111;
D2CleanStatMouseUp = D2CleanStatMouseUp_111; D2CleanStatMouseUp = D2CleanStatMouseUp_111;
StatMouse1 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C004, 11C2F4, 11C040, 11C3DC, 11D224); D2MonsterUseSkill = (TD2MonsterUseSkill)D2MonsterUseSkill_111;
StatMouse2 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C008, 11C2F8, 11C044, 11C3E0, 11D228); D2ReadFile = (TD2ReadFile)D2ReadFile_111;
StatMouse3 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C020, 11C310, 11C05C, 11C3F8, 11D240); StatMouse1 = (DWORD*)R8(D2Client, 0000, 0000, 0000, 11C004, 11C2F4, 11C040, 11C3DC, 11D224, 3A0650);
StatMouse4 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C024, 11C314, 11C060, 11C3FC, 11D244); StatMouse2 = (DWORD*)R8(D2Client, 0000, 0000, 0000, 11C008, 11C2F8, 11C044, 11C3E0, 11D228, 3A0654);
StatMouse3 = (DWORD*)R8(D2Client, 0000, 0000, 0000, 11C020, 11C310, 11C05C, 11C3F8, 11D240, 3A0658);
StatMouse4 = (DWORD*)R8(D2Client, 0000, 0000, 0000, 11C024, 11C314, 11C060, 11C3FC, 11D244, 3A065C);
} else { } else {
D2SendToServer = (TD2SendToServer) D2SendToServer_1XX; D2SendToServer = (TD2SendToServer) D2SendToServer_1XX;
D2GetGameByClientID = (TD2GetGameByClientID) D2GetGameByClientID_1XX; D2GetGameByClientID = (TD2GetGameByClientID) D2GetGameByClientID_1XX;
@ -948,15 +1220,14 @@ bool initD2functions()
//////////////// STRUCTURE MANAGEMENT //////////////// //////////////// STRUCTURE MANAGEMENT ////////////////
// shifting.ptPYPlayerData = V7(D2Common,118,118,F4,F4,F4,F4,F4); // 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.ptPYPlayerData = *(DWORD*)((DWORD)D2InitPlayerData + V8(D2Common,5D,5D,5D,49,49,49,49,49,48));
shifting.ptSpecificData = V7(D2Common,70,70,14,14,14,14,14,14); shifting.ptSpecificData = V8(D2Common,70,70,14,14,14,14,14,14,14);
shifting.ptGame = V7(D2Common,A4,A4,80,80,80,80,80,80); shifting.ptGame = V8(D2Common,A4,A4,80,80,80,80,80,80,80);
shifting.ptClientGame = V7(D2Common,170,194,1A8,1A8,1A8,1A8,1A8,1A8); shifting.ptClientGame = V8(D2Common,170,194,1A8,1A8,1A8,1A8,1A8,1A8,1A8);
shifting.ptInventory = V7(D2Common,84,84,60,60,60,60,60,60); shifting.ptInventory = V8(D2Common,84,84,60,60,60,60,60,60,60);
shifting.ptSkills = V7(D2Common,CC,CC,A8,A8,A8,A8,A8,A8); shifting.ptSkills = V8(D2Common,CC,CC,A8,A8,A8,A8,A8,A8,A8);
shifting.ptImage = V7(D2Common,04,04,04,08,08,3C,34,34); shifting.ptImage = V8(D2Common,04,04,04,08,08,3C,34,34,34);
shifting.ptFrame = V7(D2Common,08,08,08,44,44,40,00,00); shifting.ptFrame = V8(D2Common,08,08,08,44,44,40,00,00,00);
return true;
} }
/*================================= END OF FILE =================================*/ /*================================= END OF FILE =================================*/

772
PlugY/D2wrapper.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d and DoNotCloseNihlathakPortal by haxifix.
@file D2wrapper.cpp @file D2wrapper.cpp
@brief Main Diablo II extra DLL handler. @brief Main Diablo II extra DLL handler.
@ -9,6 +10,7 @@
=================================================================*/ =================================================================*/
#include "plugYFiles.h" // Install_PlugYFiles()
#include "globalVariable.h" // Install_VariableOnRealm() #include "globalVariable.h" // Install_VariableOnRealm()
#include "commands.h" // Install_Commands() #include "commands.h" // Install_Commands()
#include "othersFeatures.h" // Install_ChangeResolution() #include "othersFeatures.h" // Install_ChangeResolution()
@ -26,104 +28,83 @@
#include "extraOptions.h" // Install_AlwaysRegenMapInSP() #include "extraOptions.h" // Install_AlwaysRegenMapInSP()
#include "language.h" // Install_LanguageManagement() #include "language.h" // Install_LanguageManagement()
#include "windowed.h" // installed with Install_PrintPlugYVersion() #include "windowed.h" // installed with Install_PrintPlugYVersion()
#include "savePlayerData.h" // Install_SavePlayerData()
#include "customLibraries.h" #include "customLibraries.h"
#include "common.h" #include "common.h"
int version_SmackW32 = UNKNOW; int version_Game = UNKNOWN;
int version_D2Common = UNKNOW; //int version_binkw32 = UNKNOWN;
int version_ijl11 = UNKNOW; //int version_Bnclient = UNKNOWN;
int version_D2Gdi = UNKNOW; int version_D2Client = UNKNOWN;
int version_D2Win = UNKNOW; int version_D2CMP = UNKNOWN;
int version_D2sound = UNKNOW; int version_D2Common = UNKNOWN;
int version_D2MCPCLI = UNKNOW; //int version_D2DDraw = UNKNOWN;
int version_D2Launch = UNKNOW; //int version_D2Direct3D = UNKNOWN;
int version_D2gfx = UNKNOW; int version_D2Game = UNKNOWN;
int version_D2Client = UNKNOW; //int version_D2Gdi = UNKNOWN;
int version_D2Net = UNKNOW; int version_D2gfx = UNKNOWN;
int version_D2Lang = UNKNOW; //int version_D2Glide = UNKNOWN;
int version_D2Game = UNKNOW; int version_D2Lang = UNKNOWN;
int version_D2CMP = UNKNOW; int version_D2Launch = UNKNOWN;
int version_Bnclient = UNKNOW; //int version_D2MCPClient = UNKNOWN;
int version_Fog = UNKNOW; //int version_D2Multi = UNKNOWN;
int version_Storm = UNKNOW; int version_D2Net = UNKNOWN;
//int version_D2sound = UNKNOWN;
int version_D2Win = UNKNOWN;
int version_Fog = UNKNOWN;
//int version_ijl11 = UNKNOWN;
//int version_SmackW32 = UNKNOWN;
int version_Storm = UNKNOWN;
DWORD offset_Game = NULL;
DWORD offset_SmackW32 = NULL; //DWORD offset_binkw32 = NULL;
DWORD offset_D2Common = NULL; //DWORD offset_Bnclient = NULL;
DWORD offset_ijl11 = NULL;
DWORD offset_D2Gdi = NULL;
DWORD offset_D2Win = NULL;
DWORD offset_D2sound = NULL;
DWORD offset_D2Multi = NULL;
DWORD offset_D2MCPCLI = NULL;
DWORD offset_D2Launch = NULL;
DWORD offset_D2gfx = NULL;
DWORD offset_D2Game = NULL;
DWORD offset_D2Client = NULL; DWORD offset_D2Client = NULL;
DWORD offset_D2Net = NULL;
DWORD offset_D2Lang = NULL;
DWORD offset_D2CMP = NULL; DWORD offset_D2CMP = NULL;
DWORD offset_Bnclient = NULL; DWORD offset_D2Common = NULL;
//DWORD offset_D2DDraw = NULL;
//DWORD offset_D2Direct3D = NULL;
DWORD offset_D2Game = NULL;
//DWORD offset_D2Gdi = NULL;
DWORD offset_D2gfx = NULL;
//DWORD offset_D2Glide = NULL;
DWORD offset_D2Lang = NULL;
DWORD offset_D2Launch = NULL;
//DWORD offset_D2MCPClient = NULL;
//DWORD offset_D2Multi = NULL;
DWORD offset_D2Net = NULL;
//DWORD offset_D2sound = NULL;
DWORD offset_D2Win = NULL;
DWORD offset_Fog = NULL; DWORD offset_Fog = NULL;
//DWORD offset_ijl11 = NULL;
//DWORD offset_SmackW32 = NULL;
DWORD offset_Storm = NULL; DWORD offset_Storm = NULL;
// manque : Game.exe D2DDraw.dll D2Direct3D.dll D2Glide.dll
const char* S_SmackW32 = "SmackW32.dll"; const char* S_Game = "Game.exe";
const char* S_D2Common = "D2Common.dll"; //const char* S_binkw32 = "binkw32.dll";
const char* S_ijl11 = "ijl11.dll"; //const char* S_Bnclient = "Bnclient.dll";
const char* S_D2Gdi = "D2Gdi.dll";
const char* S_D2Win = "D2Win.dll";
const char* S_D2sound = "D2sound.dll";
const char* S_D2Multi = "D2Multi.dll";
const char* S_D2MCPCLI = "D2MCPClient.dll";
const char* S_D2Launch = "D2Launch.dll";
const char* S_D2gfx = "D2gfx.dll";
const char* S_D2Game = "D2Game.dll";
const char* S_D2Client = "D2Client.dll"; const char* S_D2Client = "D2Client.dll";
const char* S_D2Net = "D2Net.dll";
const char* S_D2Lang = "D2Lang.dll";
const char* S_D2CMP = "D2CMP.dll"; const char* S_D2CMP = "D2CMP.dll";
const char* S_Bnclient = "Bnclient.dll"; const char* S_D2Common = "D2Common.dll";
//const char* S_D2DDraw = "D2DDraw.dll";
//const char* S_D2Direct3D = "D2Direct3D.dll";
const char* S_D2Game = "D2Game.dll";
//const char* S_D2Gdi = "D2Gdi.dll";
const char* S_D2gfx = "D2gfx.dll";
//const char* S_D2Glide = "D2Glide.dll";
const char* S_D2Lang = "D2Lang.dll";
const char* S_D2Launch = "D2Launch.dll";
//const char* S_D2MCPClient = "D2MCPClient.dll";
//const char* S_D2Multi = "D2Multi.dll";
const char* S_D2Net = "D2Net.dll";
//const char* S_D2sound = "D2sound.dll";
const char* S_D2Win = "D2Win.dll";
const char* S_Fog = "Fog.dll"; const char* S_Fog = "Fog.dll";
//const char* S_ijl11 = "ijl11.dll";
//const char* S_SmackW32 = "SmackW32.dll";
const char* S_Storm = "Storm.dll"; const char* S_Storm = "Storm.dll";
DWORD loadLibrary( const char* libraryName)
{
DWORD offset;
/* char currentpath[MAX_PATH];
if (!strcmp(libraryName,"D2Common.dll") || !strcmp(libraryName,"D2Game.dll") || !strcmp(libraryName,"D2Client.dll"))
{
GetCurrentDirectory(MAX_PATH,currentpath);
strncat(currentpath,"\\",MAX_PATH);
strncat(currentpath,libraryName,MAX_PATH);
log_msg("Load = %s : ",currentpath);
offset = (DWORD)LoadLibrary(currentpath);
log_msg("offset = %08X\n",offset);
if (offset)
{
log_msg("%s loaded successfully at: %08X\n", libraryName, offset);
return offset;
}
}*/
offset = (DWORD)LoadLibrary(libraryName);
if (!offset)
{
log_msg("Failed to load library : %s\n", libraryName);
exit(-1);
}
log_msg("%s loaded successfully at: %08X\n", libraryName, offset);
return offset;
}
void freeLibrary( DWORD library )
{
if (library)
FreeLibrary((HINSTANCE__ *)library);
}
// Change the protection scheme of a loaded // Change the protection scheme of a loaded
// DLL called libraryName in memory space at address addr+size to allow us to customize it. // DLL called libraryName in memory space at address addr+size to allow us to customize it.
void hookLibrary(const char* libraryName, DWORD addr) void hookLibrary(const char* libraryName, DWORD addr)
@ -152,55 +133,40 @@ void unhookLibrary(const char* libraryName, DWORD addr)
log_msg("%s successfully unhooked. (%08X,%08X)\n", libraryName ,baseOfCode, sizeOfCode); log_msg("%s successfully unhooked. (%08X,%08X)\n", libraryName ,baseOfCode, sizeOfCode);
} }
void freeLibrary( DWORD library )
void loadD2Libraries ()
{ {
log_msg("***** Load D2 Libraries *****\n"); if (library && library != offset_Game)
FreeLibrary((HMODULE)library);
offset_SmackW32 = loadLibrary( S_SmackW32); //0xD000 0x03B90000 Already Loaded -
offset_D2Common = loadLibrary( S_D2Common); //0x8D000 0x037A0000 0x7C000
offset_ijl11 = loadLibrary( S_ijl11); //0x24000 0x60000000 Already Loaded -
offset_D2Gdi = loadLibrary( S_D2Gdi); //0x7000 0x6F830000 Already Loaded -
offset_D2Win = loadLibrary( S_D2Win); //0x19000 0x6F8A0000 Already Loaded 0x1C000
offset_D2sound = loadLibrary( S_D2sound); //0xC000 0x6F980000 Already Loaded 0xD000
// offset_D2Multi = loadLibrary( S_D2Multi); //0x1000 0x6F9A0000 ?
// offset_D2MCPCLI = loadLibrary( S_D2MCPCLI); //0x6000 0x6F9F0000 Already Loaded -
offset_D2Launch = loadLibrary( S_D2Launch); //0x20000 0x6FA10000 Already Loaded 0x1E000
offset_D2gfx = loadLibrary( S_D2gfx); //0xB000 0x6FA70000 Already Loaded -
offset_D2Game = loadLibrary( S_D2Game); //0xF6000 0x6FC30000 0xCF000
offset_D2Client = loadLibrary( S_D2Client); //0xCC000 0x6FAA0000 0xCA000
offset_D2Net = loadLibrary( S_D2Net); //0x6000 0x6FC00000 Already Loaded -
offset_D2Lang = loadLibrary( S_D2Lang); //0x0A000 0x6FC10000 Already Loaded -
offset_D2CMP = loadLibrary( S_D2CMP); //0x18000 0x6FDF0000 Already Loaded 0x19000
offset_Bnclient = loadLibrary( S_Bnclient); //0x15000 0x6FF00000 Already Loaded -
offset_Fog = loadLibrary( S_Fog); //0x20000 0x6FF50000 Already Loaded 0x1F000
offset_Storm = loadLibrary( S_Storm); //0x30000 0x6FFB0000 Already Loaded -
log_msg("\n\n");
} }
void freeD2Libraries() void freeD2Libraries()
{ {
if (version_Game >= V114a)
return;
log_msg("***** Free Libraries *****\n"); log_msg("***** Free Libraries *****\n");
freeLibrary( offset_SmackW32 ); // freeLibrary( offset_binkw32 );
freeLibrary( offset_D2Common ); // freeLibrary( offset_Bnclient );
freeLibrary( offset_ijl11 );
freeLibrary( offset_D2Gdi );
freeLibrary( offset_D2Win );
freeLibrary( offset_D2sound );
// freeLibrary( offset_D2Multi );
// freeLibrary( offset_D2MCPCLI );
freeLibrary( offset_D2Launch );
freeLibrary( offset_D2gfx );
freeLibrary( offset_D2Game );
freeLibrary( offset_D2Client ); freeLibrary( offset_D2Client );
freeLibrary( offset_D2Net );
freeLibrary( offset_D2Lang );
freeLibrary( offset_D2CMP ); freeLibrary( offset_D2CMP );
freeLibrary( offset_Bnclient ); freeLibrary( offset_D2Common );
// freeLibrary( offset_D2DDraw );
// freeLibrary( offset_D2Direct3D );
freeLibrary( offset_D2Game );
// freeLibrary( offset_D2Gdi );
freeLibrary( offset_D2gfx );
// freeLibrary( offset_D2Glide );
freeLibrary( offset_D2Lang );
freeLibrary( offset_D2Launch );
// freeLibrary( offset_D2MCPClient );
// freeLibrary( offset_D2Multi );
freeLibrary( offset_D2Net );
// freeLibrary( offset_D2sound );
freeLibrary( offset_D2Win );
freeLibrary( offset_Fog ); freeLibrary( offset_Fog );
// freeLibrary( offset_ijl11 );
// freeLibrary( offset_SmackW32 );
freeLibrary( offset_Storm ); freeLibrary( offset_Storm );
log_msg("\n\n"); log_msg("\n\n");
@ -210,16 +176,22 @@ void hookLibraries()
{ {
log_msg("***** Unprotect Libraries *****\n"); log_msg("***** Unprotect Libraries *****\n");
hookLibrary(S_D2Common, offset_D2Common); if (version_Game >= V114a)
hookLibrary(S_Game, offset_Game);
else
{
hookLibrary(S_D2Client, offset_D2Client); hookLibrary(S_D2Client, offset_D2Client);
hookLibrary(S_D2Lang, offset_D2Lang); // hookLibrary(S_D2CMP, offset_D2CMP);
hookLibrary(S_D2Common, offset_D2Common);
hookLibrary(S_D2Game, offset_D2Game); hookLibrary(S_D2Game, offset_D2Game);
hookLibrary(S_D2gfx, offset_D2gfx);
hookLibrary(S_D2Lang, offset_D2Lang);
hookLibrary(S_D2Launch, offset_D2Launch);
// hookLibrary(S_D2Net, offset_D2Net);
// hookLibrary(S_D2Win, offset_D2Win);
hookLibrary(S_Fog, offset_Fog); hookLibrary(S_Fog, offset_Fog);
hookLibrary(S_Storm, offset_Storm); hookLibrary(S_Storm, offset_Storm);
// hookLibrary(S_D2Win, offset_D2Win); }
hookLibrary(S_D2Launch, offset_D2Launch);
hookLibrary(S_D2gfx, offset_D2gfx);
// hookLibrary(S_D2Gdi, offset_D2Gdi);
log_msg("\n\n"); log_msg("\n\n");
} }
@ -228,22 +200,31 @@ void unhookLibraries()
{ {
log_msg("***** Reprotect Libraries *****\n"); log_msg("***** Reprotect Libraries *****\n");
unhookLibrary(S_D2Common, offset_D2Common); if (version_Game >= V114a)
unhookLibrary(S_Game, offset_Game);
else
{
unhookLibrary(S_D2Client, offset_D2Client); unhookLibrary(S_D2Client, offset_D2Client);
unhookLibrary(S_D2Lang, offset_D2Lang); // unhookLibrary(S_D2CMP, offset_D2CMP);
unhookLibrary(S_D2Common, offset_D2Common);
unhookLibrary(S_D2Game, offset_D2Game); unhookLibrary(S_D2Game, offset_D2Game);
unhookLibrary(S_D2gfx, offset_D2gfx);
unhookLibrary(S_D2Lang, offset_D2Lang);
unhookLibrary(S_D2Launch, offset_D2Launch);
// unhookLibrary(S_D2Net, offset_D2Net);
// unhookLibrary(S_D2Win, offset_D2Win);
unhookLibrary(S_Fog, offset_Fog); unhookLibrary(S_Fog, offset_Fog);
unhookLibrary(S_Storm, offset_Storm); unhookLibrary(S_Storm, offset_Storm);
// unhookLibrary(S_D2Win, offset_D2Win); }
unhookLibrary(S_D2Launch, offset_D2Launch);
unhookLibrary(S_D2gfx, offset_D2gfx);
// unhookLibrary(S_D2Gdi, offset_D2Gdi);
log_msg("\n\n"); log_msg("\n\n");
} }
void freeCustomLibraries() void freeCustomLibraries()
{ {
if (!customDlls)
return;
log_msg("***** Free custom libraries *****\n"); log_msg("***** Free custom libraries *****\n");
TCustomDll* dll=customDlls; TCustomDll* dll=customDlls;
@ -253,7 +234,7 @@ void freeCustomLibraries()
dll->release(); dll->release();
freeLibrary(dll->offset); freeLibrary(dll->offset);
nextDll = dll->nextDll; nextDll = dll->nextDll;
D2FogMemDeAlloc(dll,__FILE__,__LINE__,0); delete(dll);
dll = nextDll; dll = nextDll;
} }
} }
@ -285,20 +266,22 @@ void loadCustomLibraries()
log_msg("No custom libraries to load.\n"); log_msg("No custom libraries to load.\n");
else else
{ {
log_msg("Load custom libraries :\n");
while (curString) while (curString)
{ {
if (curString[0]) if (curString[0])
{ {
offset_currentDll = loadLibrary(curString); log_msg("Load custom library : %s\n", curString);
if (offset_currentDll) offset_currentDll = (DWORD)LoadLibrary(curString);
if (!offset_currentDll)
{ {
log_msg("Load library %s failed !\n", curString);
exit(0);
}
nextDll = customDlls; nextDll = customDlls;
customDlls = new(TCustomDll); customDlls = new(TCustomDll);
customDlls->nextDll = nextDll; customDlls->nextDll = nextDll;
customDlls->initialize(offset_currentDll); customDlls->initialize(offset_currentDll);
} }
}
curString=strtok(NULL,"|"); curString=strtok(NULL,"|");
} }
} }
@ -308,150 +291,401 @@ void loadCustomLibraries()
log_msg("\n\n"); log_msg("\n\n");
} }
/* /*
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) void loadLibrary(LPCSTR libName, int* libVersion, DWORD* libOffset, int shift, DWORD v109b, DWORD v109d, DWORD v110, DWORD v111, DWORD v111b, DWORD v112, DWORD v113c)
{ {
log_msg("version of %s\t",filename); *libOffset = (DWORD)LoadLibrary(libName);
if (*libOffset == NULL)
if (addr==v109b) { {
*ver = V109b; log_msg("Failed to load library : %s\n", libName);
log_msg("1.09b\n"); exit(-1);
} else if (addr==v109d) {
*ver = V109d;
log_msg("1.09d\n");
} else if (addr==v110) {
*ver = V110;
log_msg("1.10\n");
} else if ((addr==v111) && (addr111==v111a)) {
*ver = V111;
log_msg("1.11\n");
} else if ((addr==v111) && (addr111==v111b)) {
*ver = V111b;
log_msg("1.11b\n");
} else if (addr==v112) {
*ver = V112;
log_msg("1.12\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 = V113d;
log_msg("unknow, try with 1.13d\n");
} }
log_msg("%s loaded at:\t%08X (", libName, *libOffset);
DWORD addr = *(DWORD*)(*libOffset + shift);
if (version_Game != UNKNOWN && (version_Game <= V108 || version_Game >= V113d))
*libVersion = version_Game;
else if (addr==v109b)
*libVersion = V109b;
else if (addr==v109d)
*libVersion = V109d;
else if (addr==v110)
*libVersion = V110;
else if (addr==v111)
*libVersion = V111;
else if (addr==v111b)
*libVersion = V111b;
else if (addr==v112)
*libVersion = V112;
else if (addr==v113c)
*libVersion = V113c;
else {
*libVersion = version_Game != UNKNOWN ? version_Game : V113d;
log_msg("unknown, try with ");
}
log_msg("%s)\n", GetVersionString(*libVersion));
} }
#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)
bool initD2version() #define GET_VERSION(F,S,A,B,C,D,E,G,H) loadLibrary(S_##F, &version_##F, &offset_##F, 0x##S, 0x##A, 0x##B, 0x##C, 0x##D, 0x##E, 0x##G, 0x##H)
void initD2modules()
{ {
log_msg("***** Get dll versions *****\n"); log_msg("***** Get D2 Modules address and version *****\n");
offset_Game = (DWORD)GetModuleHandle(NULL);
version_Game = GetD2Version((HMODULE)offset_Game);
log_msg("Game.exe loaded at:\t%08X (%s)\n", offset_Game, GetVersionString(version_Game));
if (version_Game >= V114a)
//GET_VERSION(SmackW32 {
GET_VERSION(D2Common, 80, 108, B03A26A0, 9E3DE7CC, 0355C185, 8402CA7A, 42E6C2E5, 43028BA5, E58C71DA, 00000000); // offset_Bnclient = offset_Game; version_Bnclient = version_Game;
//GET_VERSION(ijl11 offset_D2Client = offset_Game; version_D2Client = version_Game;
GET_VERSION(D2Gdi, 80, 108, 90CFD95A, 86CE337B, A8CCC67B, 06059D7D, 42E6C248, 43028B2F, 5D6490A2, 00000000); offset_D2CMP = offset_Game; version_D2CMP = version_Game;
GET_VERSION(D2Win, 80, 108, B595A0CD, 1995DAD2, A8F5E2FD, B6DAB75A, 42E6C266, 43028B44, 6AA01FF5, 00000000); offset_D2Common = offset_Game; version_D2Common = version_Game;
//GET_VERSION(D2sound // offset_D2DDraw = offset_Game; version_D2DDraw = version_Game;
//GET_VERSION(D2MCPCLI // offset_D2Direct3D = offset_Game; version_D2Direct3D = version_Game;
GET_VERSION(D2Launch, 80, 100, A66532FF, 66678CC5, 686223E5, 80B0E2C6, 42E6C275, 43028B50, 205A4C0F, 00000000); offset_D2Game = offset_Game; version_D2Game = version_Game;
GET_VERSION(D2gfx, 80, 110, 00949FA8, 018866A8, 401526B2, 575C8A5E, 42E6C22A, 43028B19, ACBE1B9E, 00000000); // offset_D2Gdi = offset_Game; version_D2Gdi = version_Game;
GET_VERSION(D2Client, 80, 108, 03522F39, 6730B639, C9817825, 37EC6E13, 42E6C43F, 43028CA5, 61A3B3D5, 00000000); offset_D2gfx = offset_Game; version_D2gfx = version_Game;
GET_VERSION(D2Net, 80, 0F0, E60F4DEA, 940E178B, 890FCC0B, C293A9D5, 42E6C20D, 43028B05, 19FA9F76, 00000000); // offset_D2Glide = offset_Game; version_D2Glide = version_Game;
GET_VERSION(D2Lang, 80, 0F8, 111DCCB7, 13978953, DF917353, B91BAEA2, 42E6C213, 43028B09, B7B3978E, 00000000); offset_D2Lang = offset_Game; version_D2Lang = version_Game;
GET_VERSION(D2Game, 80, 108, B0805792, 8BB2C392, 92FA18E6, 00B6F7B7, 42E6C375, 43028C0D, BD8DD8E5, 00000000); offset_D2Launch = offset_Game; version_D2Launch = version_Game;
GET_VERSION(D2CMP, 80, 0F8, BA755486, 9A77DFEE, 38F44382, 4059B13F, 42E6C203, 43028AFE, 33A9427B, 00000000); // offset_D2MCPClient = offset_Game; version_D2MCPClient = version_Game;
//GET_VERSION(Bnclient // offset_D2Multi = offset_Game; version_D2Multi = version_Game;
GET_VERSION(Fog, 80, 100, 6F16123B, 75990846, 7E7ED3C7, D333B997, 42E6C1F0, 43028AF2, D3BD4F1B, 00000000); offset_D2Net = offset_Game; version_D2Net = version_Game;
GET_VERSION(Storm, E0, 110, 3B4B41D8, 3B8AB1CE, 00004550, 9C2BECC4, 42E6C1CA, 43028AD9, E4FA2944, 00000000); // offset_D2sound = offset_Game; version_D2sound = version_Game;
offset_D2Win = offset_Game; version_D2Win = version_Game;
offset_Fog = offset_Game; version_Fog = version_Game;
offset_Storm = offset_Game; version_Storm = version_Game;
}
else
{
// GET_VERSION(Bnclient //0x15000 0x6FF00000 Already Loaded -
GET_VERSION(D2Client, 17F, 00000000, 14500000, 12500000, 0D814800, 0D812800, 0DA01000, 0DA03000); //0xCC000 0x6FAA0000 0xCA000
GET_VERSION(D2CMP, 1359, 3C686FE0, 38686FE0, 8BF78B56, 4C880424, 07C71824, CCCCCCCC, C7000005); //0x18000 0x6FDF0000 Already Loaded 0x19000
GET_VERSION(D2Common, 10CA, A1E86FDC, B1E86FDC, 72D03B42, F883057E, 16746AC6, 00FE81C3, 74FE85DB); //0x8D000 0x037A0000 0x7C000
// GET_VERSION(D2DDraw 000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000); //
// GET_VERSION(D2Direct3D 000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000); //
// GET_VERSION(D2Game, 1010, D22A78A1, D22910A1, D43FB0A1, 03E8506F, 53E8506F, 89E8506F, 63E8506F); //0xF6000 0x6FC30000 0xCF000
GET_VERSION(D2Game, 1092, 18968BF1, 38968BF1, 28968BF1, F6335608, C690C5B9, 895FD713, 56535700); //0xF6000 0x6FC30000 0xCF000
// GET_VERSION(D2Gdi, 105, B4000000, 0B210E00, E4000000, 48000401, 2F000401, 00000000, B7000401); //0x7000 0x6F830000 Already Loaded -
GET_VERSION(D2gfx, 10D, EB000000, 006FA700, 00000010, 2A000401, 19000401, 0B210E00, 00000000); //0xB000 0x6FA70000 Already Loaded -
// GET_VERSION(D2Glide 000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000); //
GET_VERSION(D2Lang, 126D, FC45048B, F445048B, 02C18313, C4830000, 00C6E045, 8B48408B, 0C75FF0C); //0x0A000 0x6FC10000 Already Loaded -
GET_VERSION(D2Launch, 109A, 81E8526F, 01E8526F, 85E8526F, 247C8B00, 00FC6583, 15FF0424, E850E045); //0x20000 0x6FA10000 Already Loaded 0x1E000
// GET_VERSION(D2MCPClient 000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000); //0x6000 0x6F9F0000 Already Loaded -
// GET_VERSION(D2Multi 000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000); //0x1000 0x6F9A0000 ?
GET_VERSION(D2Net, 16E1, 78B8A73C, 68B8A73C, 10244C8B, 5349E808, 5EA9E808, 105D8B72, 53B9E808); //0x6000 0x6FC00000 Already Loaded -
// GET_VERSION(D2sound 000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000); //0xC000 0x6F980000 Already Loaded 0xD000
GET_VERSION(D2Win, 1699, 88686F8C, 84686F8C, D094686F, F0030000, 001435E8, 8B088F44, 0013F5E8); //0x19000 0x6F8A0000 Already Loaded 0x1C000
GET_VERSION(Fog, 102, D0000006, 10000001, 00000006, 000042E6, 00004302, 0000483C, 00004B95); //0x20000 0x6FF50000 Already Loaded 0x1F000
GET_VERSION(Storm, 1190, 19E85082, 59E85082, 13C103F6, 0474F685, 8B000321, 3B1074C9, 0D896404); //0x30000 0x6FFB0000 Already Loaded -
if (version_Game == UNKNOWN)
version_Game = version_D2gfx;
}
// GET_VERSION(binkw32 000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000); //
// GET_VERSION(ijl11 000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000); //0x24000 0x60000000 Already Loaded -
// GET_VERSION(SmackW32 000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000); //0xD000 0x03B90000 Already Loaded -
log_msg("\n\n"); log_msg("\n\n");
return true;
} }
*/ */
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) IMAGE_NT_HEADERS* GetHeader(LPBYTE pBase) {
{ if (pBase == NULL)
log_msg("version of %s\t", filename); return NULL;
if (version >= V113d) { IMAGE_DOS_HEADER* pDosHeader = (IMAGE_DOS_HEADER*)pBase;
*ver = version;
log_msg("%s\n", GetVersionString(version)); if (IsBadReadPtr(pDosHeader, sizeof(IMAGE_DOS_HEADER)))
} else if (addr==v109b) { return NULL;
*ver = V109b;
log_msg("1.09b\n"); if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
} else if (addr==v109d) { return NULL;
*ver = V109d;
log_msg("1.09d\n"); IMAGE_NT_HEADERS* pHeader = (IMAGE_NT_HEADERS*)(pBase + pDosHeader->e_lfanew);
} else if (addr==v110) { if (IsBadReadPtr(pHeader, sizeof(IMAGE_NT_HEADERS)))
*ver = V110; return NULL;
log_msg("1.10\n");
} else if (addr==v111) { if (pHeader->Signature != IMAGE_NT_SIGNATURE)
*ver = V111; return NULL;
log_msg("1.11\n");
} else if (addr==v111b) { return pHeader;
*ver = V111b; }
log_msg("1.11b\n");
} else if (addr==v112) { void initD2modules()
*ver = V112; {
log_msg("1.12\n"); log_msg("***** Get D2 Modules address and version *****\n\n");
} else if (addr==v113c) {
*ver = V113c; offset_D2Client = (DWORD)LoadLibrary("D2Client.dll");
log_msg("1.13c\n"); offset_D2CMP = (DWORD)LoadLibrary("D2CMP.dll");
} else { offset_D2Common = (DWORD)LoadLibrary("D2Common.dll");
*ver = V113d; offset_D2Game = (DWORD)LoadLibrary("D2Game.dll");
log_msg("unknow, try with 1.13d\n"); offset_D2gfx = (DWORD)LoadLibrary("D2gfx.dll");
offset_D2Lang = (DWORD)LoadLibrary("D2Lang.dll");
offset_D2Launch = (DWORD)LoadLibrary("D2Launch.dll");
offset_D2Net = (DWORD)LoadLibrary("D2Net.dll");
offset_D2Win = (DWORD)LoadLibrary("D2Win.dll");
offset_Fog = (DWORD)LoadLibrary("Fog.dll");
offset_Storm = (DWORD)LoadLibrary("Storm.dll");
int count_109b = 0;
int count_109d = 0;
int count_110f = 0;
int count_111 = 0;
int count_111b = 0;
int count_112a = 0;
int count_113c = 0;
int count_113d = 0;
int count_114a = 0;
int count_114b = 0;
int count_114c = 0;
int count_114d = 0;
IMAGE_NT_HEADERS* pHeader;
if (offset_D2Client != NULL) {
pHeader = GetHeader((LPBYTE)offset_D2Client);
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000C234D) count_109b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000C16CD) count_109d++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000C1C1D) count_110f++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000045E6) count_111++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000045EE) count_111b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000045FA) count_112a++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000045F6) count_113c++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000045DE) count_113d++;
}
if (offset_D2CMP != NULL) {
pHeader = GetHeader((LPBYTE)offset_D2CMP);
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00011361) count_109b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00011361) count_109d++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00010E61) count_110f++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C23) count_111++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C23) count_111b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C23) count_112a++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C23) count_113c++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C23) count_113d++;
}
if (offset_D2Common != NULL) {
pHeader = GetHeader((LPBYTE)offset_D2Common);
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00074D1D) count_109b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00074E2D) count_109d++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000856DD) count_110f++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C94) count_111++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C8D) count_111b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C97) count_112a++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C8F) count_113c++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000047C7) count_113d++;
}
if (offset_D2Game != NULL) {
pHeader = GetHeader((LPBYTE)offset_D2Game);
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000C66AC) count_109b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000C6D5C) count_109d++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000EDC2C) count_110f++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000036E6) count_111++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000373D) count_111b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000374B) count_112a++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000373C) count_113c++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003747) count_113d++;
}
if (offset_D2gfx != NULL) {
pHeader = GetHeader((LPBYTE)offset_D2gfx);
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000054EB) count_109b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000054EB) count_109d++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000054A5) count_110f++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001807) count_111++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001807) count_111b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001807) count_112a++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001807) count_113c++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001807) count_113d++;
}
if (offset_D2Lang != NULL) {
pHeader = GetHeader((LPBYTE)offset_D2Lang);
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00005148) count_109b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00005138) count_109d++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00005048) count_110f++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A6A) count_111++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A5B) count_111b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A75) count_112a++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A71) count_113c++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A5A) count_113d++;
}
if (offset_D2Launch != NULL) {
pHeader = GetHeader((LPBYTE)offset_D2Launch);
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000172C3) count_109b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00017243) count_109d++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00018DC7) count_110f++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A84) count_111++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A85) count_111b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A85) count_112a++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A87) count_113c++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001A84) count_113d++;
}
if (offset_D2Net != NULL) {
pHeader = GetHeader((LPBYTE)offset_D2Net);
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002BCE) count_109b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002BCE) count_109d++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00002C6E) count_110f++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001676) count_111++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001676) count_111b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000167E) count_112a++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001676) count_113c++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000167E) count_113d++;
}
if (offset_D2Win != NULL) {
pHeader = GetHeader((LPBYTE)offset_D2Win);
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00014F38) count_109b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00014F38) count_109d++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00012EC0) count_110f++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000187E) count_111++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000187E) count_111b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000188E) count_112a++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000187E) count_113c++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00001887) count_113d++;
}
if (offset_Fog != NULL) {
pHeader = GetHeader((LPBYTE)offset_Fog);
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00013658) count_109b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000142E7) count_109d++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000162B0) count_110f++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003159) count_111++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003142) count_111b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000314A) count_112a++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003162) count_113c++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003142) count_113d++;
}
if (offset_Storm != NULL) {
pHeader = GetHeader((LPBYTE)offset_Storm);
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00013658) count_109b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000142E7) count_109d++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x000162B0) count_110f++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003159) count_111++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003142) count_111b++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0000314A) count_112a++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00003162) count_113c++;
if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x0003C3E0) count_113d++;
}
int minimum_match_dll = 7;
if (count_109b >= minimum_match_dll) version_Game = V109b;
if (count_109d >= minimum_match_dll) version_Game = V109d;
if (count_110f >= minimum_match_dll) version_Game = V110;
if (count_111 >= minimum_match_dll) version_Game = V111;
if (count_111b >= minimum_match_dll) version_Game = V111b;
if (count_112a >= minimum_match_dll) version_Game = V112;
if (count_113c >= minimum_match_dll) version_Game = V113c;
if (count_113d >= minimum_match_dll) version_Game = V113d;
//version_SmackW32 = version_Game;
version_D2Common = version_Game;
//version_ijl11 = version_Game;
//version_D2Gdi = version_Game;
version_D2Win = version_Game;
//version_D2sound = version_Game;
//version_D2MCPCLI = version_Game;
version_D2Launch = version_Game;
version_D2gfx = version_Game;
version_D2Client = version_Game;
version_D2Net = version_Game;
version_D2Lang = version_Game;
version_D2Game = version_Game;
version_D2CMP = version_Game;
//version_Bnclient = version;
version_Fog = version_Game;
version_Storm = version_Game;
log_msg("DLL match for version 1.09b :\t%d\n", count_109b);
log_msg("DLL match for version 1.09d :\t%d\n", count_109d);
log_msg("DLL match for version 1.10f :\t%d\n", count_110f);
log_msg("DLL match for version 1.11 :\t%d\n", count_111);
log_msg("DLL match for version 1.11b :\t%d\n", count_111b);
log_msg("DLL match for version 1.12a :\t%d\n", count_112a);
log_msg("DLL match for version 1.13c :\t%d\n", count_113c);
log_msg("\n");
offset_Game = (DWORD)GetModuleHandle("Game.exe");
if (offset_Game != NULL) {
version_Game = GetD2Version((HMODULE)offset_Game);
log_msg("Game.exe loaded at:\t%08X (%s)\n", offset_Game, GetVersionString(version_Game));
if (version_Game >= V114a)
{
//version_SmackW32 = version_Game;
version_D2Common = version_Game;
//version_ijl11 = version_Game;
//version_D2Gdi = version_Game;
version_D2Win = version_Game;
//version_D2sound = version_Game;
//version_D2MCPCLI = version_Game;
version_D2Launch = version_Game;
version_D2gfx = version_Game;
version_D2Client = version_Game;
version_D2Net = version_Game;
version_D2Lang = version_Game;
version_D2Game = version_Game;
version_D2CMP = version_Game;
//version_Bnclient = version;
version_Fog = version_Game;
version_Storm = version_Game;
}
}
//if (offset_Game != NULL) {
// pHeader = GetHeader((LPBYTE)offset_Game);
// if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00291342) count_114a++;
// if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x002854F2) count_114b++;
// if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x002850E2) count_114c++;
// if (pHeader->OptionalHeader.AddressOfEntryPoint == 0x00282985) count_114d++;
//}
log_msg("Version game is:\t(%s)\n\n", GetVersionString(version_Game));
if (version_Game == UNKNOWN)
{
MessageBoxA(NULL, "This version of Diablo II is not supported by Plugy. Please upgrade or downgrade to a supported version.", "Plugy 14.03", MB_OK);
} }
} }
#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() //////////////////////////////////// EXPORTS FUNCTIONS ////////////////////////////////////
extern "C" __declspec(dllexport) bool __stdcall Release()
{ {
log_msg("***** Get Game.exe version *****\n"); log_msg("\n***** FREE LIBRARIES *****\n\n" );
int version = GetD2Version();
log_msg("Game.exe version : %i (%s)\n", version, GetVersionString(version));
log_msg("***** Get dll versions *****\n"); freeCustomLibraries();
freeD2Libraries();
//GET_VERSION(SmackW32 log_msg("***** END DIABLO II *****\n" );
GET_VERSION(D2Common, 10CA, A1E86FDC, B1E86FDC, 72D03B42, F883057E, 16746AC6, 00FE81C3, 74FE85DB, version); log_close();
//GET_VERSION(ijl11
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, 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, version);
GET_VERSION(Storm, 1190, 19E85082, 59E85082, 13C103F6, 0474F685, 8B000321, 3B1074C9, 0D896404, version);
log_msg("\n\n");
return true; return true;
} }
//////////////////////////////////// EXPORTS FUNCTIONS ////////////////////////////////////
extern "C" __declspec(dllexport) void* __stdcall Init(LPSTR IniName) extern "C" __declspec(dllexport) void* __stdcall Init(LPSTR IniName)
{ {
if (IniName) log_msg("* PlugY is called from D2mod.dll\n\n"); if (IniName) log_msg("* PlugY is called from D2mod.dll\n\n");
else log_msg("* PlugY is called from D2gfx.dll\n\n");
static int isInstalled = false; static int isInstalled = false;
if (isInstalled) return NULL; if (isInstalled) return NULL;
isInstalled=true; isInstalled=true;
loadD2Libraries(); initD2modules();
if (!initD2version()) return NULL; if (version_Game < V109 || version_Game > V113d && version_Game != V114d)
{
log_box("PlugY isn't compatible with this version : %s", GetVersionString(version_Game));
Release();
exit(0);
}
if (!initD2functions()) return NULL; initD2functions();
loadParameters(); loadParameters();
@ -463,6 +697,7 @@ extern "C" __declspec(dllexport) void* __stdcall Init(LPSTR IniName)
log_msg("***** INSTALL FUNCTIONS *****\n"); log_msg("***** INSTALL FUNCTIONS *****\n");
Install_PlugYFiles();
Install_VariableOnRealm(); Install_VariableOnRealm();
if (active_Commands) if (active_Commands)
@ -488,6 +723,9 @@ extern "C" __declspec(dllexport) void* __stdcall Init(LPSTR IniName)
if (active_changingSavePath) if (active_changingSavePath)
Install_ChangingSavePath(); Install_ChangingSavePath();
if (active_AutoBackup)
Install_SavePlayerData();
if (active_StatsShiftClickLimit) if (active_StatsShiftClickLimit)
Install_StatsLimitShiftClick(); Install_StatsLimitShiftClick();
@ -539,30 +777,30 @@ extern "C" __declspec(dllexport) void* __stdcall Init(LPSTR IniName)
if (active_EnabledCowPortalWhenCowKingWasKill) if (active_EnabledCowPortalWhenCowKingWasKill)
Install_EnabledCowPortalWhenCowKingWasKill(); Install_EnabledCowPortalWhenCowKingWasKill();
if (active_DoNotCloseNihlathakPortal)
Install_DoNotCloseNihlathakPortal();
if (active_MoveCainNearHarrogathWaypoint)
Install_MoveCainNearHarrogathWaypoint();
if (active_RemoveExperienceDiminushingReturn)
Install_RemoveExperienceDiminushingReturn();
log_msg("\nDLL patched sucessfully.\n\n\n"); log_msg("\nDLL patched sucessfully.\n\n\n");
unhookLibraries(); unhookLibraries();
initCustomLibraries(); initCustomLibraries();
loadLocalizedStrings(D2GetLang()); //loadLocalizedStrings(D2GetLang());
log_msg("***** ENTERING DIABLO II *****\n\n" ); log_msg("***** ENTERING DIABLO II *****\n\n" );
active_logFile = active_logFile - 1; active_logFile--;
if (active_logFile < 1)
log_close();
return NULL; return NULL;
} }
extern "C" __declspec(dllexport) bool __stdcall Release()
{
log_msg("\n***** ENDING DIABLO II *****\n\n" );
freeCustomLibraries();
freeD2Libraries();
return true;
}
/*================================= END OF FILE =================================*/ /*================================= END OF FILE =================================*/

36
PlugY/Error.cpp
View File

@ -13,11 +13,11 @@
#include <string.h> // strlen() strcat() #include <string.h> // strlen() strcat()
#include <direct.h> // _getcwd() #include <direct.h> // _getcwd()
DWORD active_logFile = 1; int active_logFile = 1;
static char log_file[MAX_PATH] = ""; static char log_file[MAX_PATH] = "";
static bool log_init = false; static bool log_init = false;
static FILE* fLogFile = NULL;
void log_initfile() void log_initfile()
{ {
@ -26,15 +26,14 @@ void log_initfile()
_getcwd( log_file, MAX_PATH ); _getcwd( log_file, MAX_PATH );
if( log_file[strlen(log_file)] != '\\') if( log_file[strlen(log_file)] != '\\')
strcat(log_file, "\\"); strcat(log_file, "\\");
strcat(log_file, LOG_FILE); strcat(log_file, "PlugY.log");
FILE* lLog = fopen( log_file, "w" ); fLogFile = fopen( log_file, "w" );
if( fLogFile == NULL )
return;
if( lLog != NULL )
{
fclose(lLog);
log_init = true; log_init = true;
}
log_msg("<----------------------------------------------->\n" log_msg("<----------------------------------------------->\n"
"\n" "\n"
@ -46,6 +45,15 @@ void log_initfile()
,PLUGY_VERSION); ,PLUGY_VERSION);
} }
void log_close()
{
if (fLogFile)
{
fclose(fLogFile);
fLogFile = NULL;
}
}
void log_box( const char* pFormat, ... ) void log_box( const char* pFormat, ... )
{ {
char buffer[300]; char buffer[300];
@ -61,7 +69,8 @@ void log_box( const char* pFormat, ... )
void log_msg( const char* pFormat, ... ) void log_msg( const char* pFormat, ... )
{ {
if (!active_logFile) return; if (!active_logFile)
return;
if( !log_init ) if( !log_init )
log_initfile(); log_initfile();
@ -71,12 +80,13 @@ void log_msg( const char* pFormat, ... )
va_list lArgs; va_list lArgs;
va_start( lArgs, pFormat ); va_start( lArgs, pFormat );
FILE *lDebug = fopen( log_file, "a" ); if ( fLogFile == NULL )
fLogFile = fopen( log_file, "a" );
if( lDebug != NULL ) if( fLogFile != NULL )
{ {
vfprintf( lDebug, pFormat, lArgs ); vfprintf( fLogFile, pFormat, lArgs );
fclose( lDebug ); fflush(fLogFile);
} }
else else
log_init = false; log_init = false;

33
PlugY/ExtendedSaveFile.cpp
View File

@ -8,6 +8,7 @@
#include "extendedSaveFile.h" #include "extendedSaveFile.h"
#include "infinityStash.h" #include "infinityStash.h"
#include "customLibraries.h" #include "customLibraries.h"
#include "extraOptions.h"
#include "common.h" #include "common.h"
#include <stdio.h> #include <stdio.h>
@ -16,7 +17,7 @@
#define FILE_EXTENDED 0x4D545343 //"CSTM" #define FILE_EXTENDED 0x4D545343 //"CSTM"
BYTE * readExtendedSaveFile(char* name, DWORD* size)//WORKS BYTE * readExtendedSaveFile(char* name, DWORD* size)
{ {
char filename[512]; char filename[512];
BYTE* data; BYTE* data;
@ -44,7 +45,7 @@ BYTE * readExtendedSaveFile(char* name, DWORD* size)//WORKS
*size = 14; *size = 14;
*((DWORD*)&data[0]) = FILE_EXTENDED; //"CSTM" *((DWORD*)&data[0]) = FILE_EXTENDED; //"CSTM"
*((WORD *)&data[4]) = FILE_VERSION; *((WORD *)&data[4]) = FILE_VERSION;
*((DWORD*)&data[6]) = 0;// not used *((DWORD*)&data[6]) = (BYTE)(nbPlayersCommandByDefault == 0 ? 0 : nbPlayersCommandByDefault - 1);
*((DWORD*)&data[10]) = 0;// number of stash *((DWORD*)&data[10]) = 0;// number of stash
TCustomDll* currentDll = customDlls; TCustomDll* currentDll = customDlls;
@ -58,9 +59,7 @@ BYTE * readExtendedSaveFile(char* name, DWORD* size)//WORKS
} }
int loadExtendedSaveFile(Unit* ptChar, BYTE data[], DWORD maxSize)
int loadExtendedSaveFile(Unit* ptChar, BYTE data[], DWORD maxSize)//WORKS
{ {
if (!ptChar || !PCPY || !data) return 0; if (!ptChar || !PCPY || !data) return 0;
@ -81,7 +80,9 @@ int loadExtendedSaveFile(Unit* ptChar, BYTE data[], DWORD maxSize)//WORKS
return 9; return 9;
} }
curSize += 2; curSize += 2;
curSize += 4; nbPlayersCommand = (*(BYTE*)&data[curSize]) + 1;
curSize += 1;
curSize += 3;
int ret = loadStashList(ptChar, data, maxSize, &curSize, false); int ret = loadStashList(ptChar, data, maxSize, &curSize, false);
@ -92,12 +93,12 @@ int loadExtendedSaveFile(Unit* ptChar, BYTE data[], DWORD maxSize)//WORKS
currentDll=currentDll->nextDll; currentDll=currentDll->nextDll;
} }
PCPY->selfStashIsOpened = true; PCPY->selfStashIsOpened = true;
return ret; return ret;
} }
void writeExtendedSaveFile(char* name, BYTE* data, DWORD size) void writeExtendedSaveFile(char* name, BYTE* data, DWORD size)
{ {
char szTempName[MAX_PATH]; char szTempName[MAX_PATH];
@ -126,22 +127,6 @@ void writeExtendedSaveFile(char* name, BYTE* data, DWORD size)
log_box("Could not create the extended save file."); log_box("Could not create the extended save file.");
} }
void backupExtendedSaveFile(char* name)
{
char szBackupName[MAX_PATH];
char szSaveName[MAX_PATH];
D2FogGetSavePath(szSaveName, MAX_PATH);
strcat(szSaveName, name);
strcat(szSaveName, ".d2x");
D2FogGetSavePath(szBackupName, MAX_PATH);
strcat(szBackupName, name);
strcat(szBackupName, ".d2x.backup");
CopyFile(szSaveName, szBackupName, true);
}
void saveExtendedSaveFile(Unit* ptChar, BYTE** data, DWORD* maxSize, DWORD* curSize) void saveExtendedSaveFile(Unit* ptChar, BYTE** data, DWORD* maxSize, DWORD* curSize)
{ {
@ -149,7 +134,7 @@ void saveExtendedSaveFile(Unit* ptChar, BYTE** data, DWORD* maxSize, DWORD* curS
*curSize += 4; *curSize += 4;
*(WORD *)(*data + *curSize) = FILE_VERSION; *(WORD *)(*data + *curSize) = FILE_VERSION;
*curSize += 2; *curSize += 2;
*(DWORD *)(*data + *curSize) = 0; *(DWORD *)(*data + *curSize) = (BYTE)(nbPlayersCommand == 0 ? 0 : nbPlayersCommand - 1);
*curSize += 4; *curSize += 4;
saveStashList(ptChar, PCPY->selfStash, data, maxSize, curSize); saveStashList(ptChar, PCPY->selfStash, data, maxSize, curSize);

422
PlugY/ExtraOptions.cpp
View File

@ -1,23 +1,29 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d and DoNotCloseNihlathakPortal by haxifix.
More little options. More little options.
=================================================================*/ =================================================================*/
#include "common.h" #include "common.h"
#include "infinityStash.h"
#include <stdio.h> #include <stdio.h>
int active_DisplayItemLevel = false; bool active_DisplayItemLevel = false;
DWORD nbPlayersCommandByDefault = 0; DWORD nbPlayersCommandByDefault = 0;
int active_alwaysRegenMapInSP = false; DWORD nbPlayersCommand = 0;
int active_RunLODs = false; bool active_alwaysRegenMapInSP = false;
int active_AlwaysDisplayLifeMana = false; bool active_RunLODs = false;
int active_EnabledTXTFilesWithMSExcel = false; int active_AlwaysDisplayLifeMana = 0;
int active_DisplayBaseStatsValue = false; bool active_EnabledTXTFilesWithMSExcel = false;
int active_LadderRunewords = false; bool active_DisplayBaseStatsValue = false;
int active_EnabledCowPortalWhenCowKingWasKill = false; bool active_LadderRunewords = false;
bool active_EnabledCowPortalWhenCowKingWasKill = false;
bool active_DoNotCloseNihlathakPortal = false;
bool active_MoveCainNearHarrogathWaypoint = false;
bool active_RemoveExperienceDiminushingReturn = false;
/****************************************************************************************************/ /****************************************************************************************************/
@ -25,11 +31,25 @@ void STDCALL displayItemlevel(LPWSTR popup, Unit* ptItem)
{ {
if (onRealm && (selectModParam==MOD_NO)) return; if (onRealm && (selectModParam==MOD_NO)) return;
WCHAR text[0x50]; WCHAR text[0x50];
_snwprintf(text, sizeof(text), L"%s: %u\n", getLocalString(STR_ITEM_LEVEL), D2GetItemLevel(ptItem)); _snwprintf(text, 50, L"%s: %u\n", getLocalString(STR_ITEM_LEVEL), D2GetItemLevel(ptItem));
D2SetColorPopup(text,WHITE); D2SetColorPopup(text,WHITE);
wcscat(popup,text); wcscat(popup,text);
} }
FCT_ASM ( caller_displayItemlevel_114 )
PUSH ECX
PUSH EAX
PUSH ECX
LEA EAX,DWORD PTR SS:[EBP-0x2434]
PUSH EAX
CALL displayItemlevel
POP EAX
POP ECX
POP EDX
PUSH 0x100
JMP EDX
}}
FCT_ASM ( caller_displayItemlevel_113 ) FCT_ASM ( caller_displayItemlevel_113 )
PUSH ECX PUSH ECX
PUSH EAX PUSH EAX
@ -58,6 +78,19 @@ FCT_ASM ( caller_displayItemlevel_111 )
JMP EAX JMP EAX
}} }}
FCT_ASM ( caller_displayItemlevelSet_114 )
PUSH ECX
PUSH EDX
PUSH ECX
LEA EAX,DWORD PTR SS:[EBP-0x2138]
PUSH EAX
CALL displayItemlevel
POP EDX
POP ECX
POP EAX
PUSH 0x100
JMP EAX
}}
FCT_ASM ( caller_displayItemlevelSet_111 ) FCT_ASM ( caller_displayItemlevelSet_111 )
PUSH ECX PUSH ECX
PUSH EDX PUSH EDX
@ -135,29 +168,31 @@ void Install_DisplayItemLevel()
static int isInstalled = false; static int isInstalled = false;
if (isInstalled) return; if (isInstalled) return;
log_msg("Patch D2Client for display item popup. (DisplayPopup)\n"); log_msg("Patch D2Client to display item popup. (DisplayPopup)\n");
// print the text in the final buffer // print the text in the final buffer
mem_seek R7(D2Client, 3D47C, 3D47C, 438A1, ADD0A, 789DA, AE0AA, 941C0, 98590); mem_seek R8(D2Client, 3D47C, 3D47C, 438A1, ADD0A, 789DA, AE0AA, 941C0, 98590, 8E983);
memt_byte( 0x68 , 0xE8); memt_byte( 0x68 , 0xE8);
MEMT_REF4( 0x100, version_D2Client >= V113c ? caller_displayItemlevel_113 : version_D2Client >= V111 ? caller_displayItemlevel_111 : version_D2Client == V110 ? caller_displayItemlevel : caller_displayItemlevel_9); MEMT_REF4( 0x100, version_D2Client >= V114d ? caller_displayItemlevel_114 : version_D2Client >= V113c ? caller_displayItemlevel_113 : version_D2Client >= V111 ? caller_displayItemlevel_111 : version_D2Client == V110 ? caller_displayItemlevel : caller_displayItemlevel_9);
//6FAE38A1 . 68 00010000 PUSH 100 //6FAE38A1 . 68 00010000 PUSH 100
//6FB5DD0A |. 68 00010000 PUSH 100 //6FB5DD0A |. 68 00010000 PUSH 100
//6FB289DA |. 68 00010000 PUSH 100 //6FB289DA |. 68 00010000 PUSH 100
//6FB5E0AA |. 68 00010000 PUSH 100 //6FB5E0AA |. 68 00010000 PUSH 100
//6FB441C0 |. 68 00010000 PUSH 100 //6FB441C0 |. 68 00010000 PUSH 100
//6FB48590 |. 68 00010000 PUSH 100 //6FB48590 |. 68 00010000 PUSH 100
//0048E983 |. 68 00010000 PUSH 100 ; /Arg1 = 00000100
// print the text in the final buffer (for set items) // print the text in the final buffer (for set items)
mem_seek R7(D2Client, 3C452, 3C452, 427BE, AC773, 77773, ACEB3, 92FE3, 973B3); mem_seek R8(D2Client, 3C452, 3C452, 427BE, AC773, 77773, ACEB3, 92FE3, 973B3, 8D774);
memt_byte( 0x68 , 0xE8); memt_byte( 0x68 , 0xE8);
MEMT_REF4( 0x100, version_D2Client >= V111 ? caller_displayItemlevelSet_111 : version_D2Client == V110 ? caller_displayItemlevelSet : caller_displayItemlevelSet_9); MEMT_REF4( 0x100, version_D2Client >= V114d ? caller_displayItemlevelSet_114 : version_D2Client >= V111 ? caller_displayItemlevelSet_111 : version_D2Client == V110 ? caller_displayItemlevelSet : caller_displayItemlevelSet_9);
//6FAE27BE . 68 00010000 PUSH 100 //6FAE27BE . 68 00010000 PUSH 100
//6FB5C773 |. 68 00010000 PUSH 100 //6FB5C773 |. 68 00010000 PUSH 100
//6FB27773 |. 68 00010000 PUSH 100 //6FB27773 |. 68 00010000 PUSH 100
//6FB5CEB3 |. 68 00010000 PUSH 100 //6FB5CEB3 |. 68 00010000 PUSH 100
//6FB42FE3 |. 68 00010000 PUSH 100 //6FB42FE3 |. 68 00010000 PUSH 100
//6FB473B3 |. 68 00010000 PUSH 100 //6FB473B3 |. 68 00010000 PUSH 100
//0048D774 |. 68 00010000 PUSH 100 ; /Arg1 = 00000100
log_msg("\n"); log_msg("\n");
@ -170,6 +205,9 @@ char* msgNBPlayersString = "players %u";
DWORD* infoEnabledSendPlayersCommand; DWORD* infoEnabledSendPlayersCommand;
void SendPlayersCommand() void SendPlayersCommand()
{ {
if (!needToInit || onRealm) return;
needToInit = false;
#pragma pack(1) #pragma pack(1)
struct { struct {
BYTE displayType;//0x15 main msg; 0x14: char popup BYTE displayType;//0x15 main msg; 0x14: char popup
@ -177,29 +215,43 @@ void SendPlayersCommand()
BYTE zero; BYTE zero;
char string[0xFF]; char string[0xFF];
char null; char null;
char targetName[0x10];
char null2;
} data; } data;
#pragma pack() #pragma pack()
if (!needToInit || onRealm) return;
needToInit=0;
DWORD info = *infoEnabledSendPlayersCommand; DWORD info = *infoEnabledSendPlayersCommand;
if ((info != 0) && (info != 1) && (info != 6) && (info != 8)) return; if ((info != 0) && (info != 1) && (info != 6) && (info != 8)) return;
D2SetNbPlayers(nbPlayersCommandByDefault); if (!active_multiPageStash)
nbPlayersCommand = nbPlayersCommandByDefault;
//if (nbPlayersCommand < 2)
// return;
log_msg("SendPlayersCommand %u\n", nbPlayersCommand);
D2SetNbPlayers(nbPlayersCommand);
memset(&data,0,sizeof(data)); memset(&data,0,sizeof(data));
data.displayType=0x15; data.displayType=0x15;
data.un=1; data.un=1;
data.zero=0;//*(BYTE*)(offset_D2Client+0x112CFC); in 1.10 data.zero=0;//*(BYTE*)(offset_D2Client+0x112CFC); in 1.10
sprintf(data.string, msgNBPlayersString, nbPlayersCommand);
data.null=NULL; data.null=NULL;
sprintf(data.string, msgNBPlayersString, nbPlayersCommandByDefault);
D2SendMsgToAll((BYTE*)&data); D2SendMsgToAll((BYTE*)&data);
} }
//FCT_ASM ( caller_SendPlayersCommand_old )
// CALL SendPlayersCommand
// JMP D2GetResolution
//}}
FCT_ASM ( caller_SendPlayersCommand ) FCT_ASM ( caller_SendPlayersCommand )
PUSH ECX
CALL SendPlayersCommand CALL SendPlayersCommand
JMP D2GetResolution POP ECX
JMP D2PrintInterface
}} }}
void Install_SendPlayersCommand() void Install_SendPlayersCommand()
@ -209,13 +261,13 @@ void Install_SendPlayersCommand()
log_msg("Patch D2Client for init default nb /players. (SendPlayersCommand)\n"); log_msg("Patch D2Client for init default nb /players. (SendPlayersCommand)\n");
infoEnabledSendPlayersCommand = (DWORD*)R7(D2Client, 111D60, 110BC0, 107960, 11BFBC, 11C2AC, 11BFF8, 11C394, 11D1DC); infoEnabledSendPlayersCommand = (DWORD*)R8(D2Client, 111D60, 110BC0, 107960, 11BFBC, 11C2AC, 11BFF8, 11C394, 11D1DC, 3A0610);
if ( version_D2Client >= V110 ) if ( version_D2Client >= V110 )
msgNBPlayersString = (char*)R7(D2Client, 0000, 0000, D8448, D06A8, D4748, D4680, D4E00, D470C); msgNBPlayersString = (char*)R8(D2Client, 0000, 0000, D8448, D06A8, D4748, D4680, D4E00, D470C, 2D7374);
// Set nb Player to default // Set nb Player to default
mem_seek R7(D2Client, 8723B, 865BB, 81B8B, A3602, 66A02, 90162, C39F2, 1D3F2);//6FB1C7B7-6FAA0000 // mem_seek R8(D2Client, 8723B, 865BB, 81B8B, A3602, 66A02, 90162, C39F2, 1D3F2, 56EF9);//6FB1C7B7-6FAA0000
MEMJ_REF4( D2GetResolution , caller_SendPlayersCommand); // MEMJ_REF4( D2GetResolution, caller_SendPlayersCommand_old);
//6FB2723A |. E8 7D8E0300 CALL <JMP.&D2gfx.#10005> //6FB2723A |. E8 7D8E0300 CALL <JMP.&D2gfx.#10005>
//6FB265BA |. E8 7D8E0300 CALL <JMP.&D2gfx.#10005> //6FB265BA |. E8 7D8E0300 CALL <JMP.&D2gfx.#10005>
//6FB21B8A . E8 4F9C0400 CALL <JMP.&D2gfx.#10005> //6FB21B8A . E8 4F9C0400 CALL <JMP.&D2gfx.#10005>
@ -224,6 +276,20 @@ void Install_SendPlayersCommand()
//6FB40161 |. E8 1ECFF7FF CALL <JMP.&D2gfx.#10043> //6FB40161 |. E8 1ECFF7FF CALL <JMP.&D2gfx.#10043>
//6FB739F1 |. E8 B896F4FF CALL <JMP.&D2gfx.#10031> //6FB739F1 |. E8 B896F4FF CALL <JMP.&D2gfx.#10031>
//6FACD3F1 |. E8 EAFBFEFF CALL <JMP.&D2gfx.#10012> //6FACD3F1 |. E8 EAFBFEFF CALL <JMP.&D2gfx.#10012>
//00456EF8 |. E8 63E20900 CALL Game.004F5160
// Set nb Player to default
mem_seek R8(D2Client, 90BA, 90AA, 97DA, 88E4C, 32C8C, 7CB5C, 4437C, 453CC, 4CB04);//6FB1C7B7-6FAA0000
MEMC_REF4( D2PrintInterface, caller_SendPlayersCommand);
//6FAA90B9 . E8 62E10700 CALL D2Client.6FB27220
//6FAA90A9 . E8 F2D40700 CALL D2Client.6FB265A0
//6FAA97D9 . E8 92830700 CALL D2Client.6FB21B70
//6FB38E4B . E8 A0A70100 CALL D2Client.6FB535F0
//6FAE2C8B . E8 603D0300 CALL D2Client.6FB169F0
//6FB2CB5B . E8 F0350100 CALL D2Client.6FB40150
//6FAF437B . E8 60F60700 CALL D2Client.6FB739E0
//6FAF53CB . E8 1080FDFF CALL D2Client.6FACD3E0
//0044CB03 |. E8 D8A30000 CALL Game.00456EE0
log_msg("\n"); log_msg("\n");
@ -241,7 +307,7 @@ void Install_AlwaysRegenMapInSP()
log_msg("Patch D2Game for always regenerate maps in Single player. (AlwaysRegenMapInSP)\n"); log_msg("Patch D2Game for always regenerate maps in Single player. (AlwaysRegenMapInSP)\n");
// Always regenerate maps in Single player // Always regenerate maps in Single player
mem_seek R7(D2Game, 517ED, 51BFA, 5DE88, 6235D, 2966D, 1E1FE, ED3BE, 26D7E); mem_seek R8(D2Game, 517ED, 51BFA, 5DE88, 6235D, 2966D, 1E1FE, ED3BE, 26D7E, 16A20F);
memt_byte( 0x74 , 0xEB); // JMP SHORT D2Game.01FE2368 memt_byte( 0x74 , 0xEB); // JMP SHORT D2Game.01FE2368
//6FC8DE88 |. 74 09 JE SHORT D2Game.6FC8DE93 //6FC8DE88 |. 74 09 JE SHORT D2Game.6FC8DE93
//01FE235D |. 74 09 JE SHORT D2Game.01FE2368 //01FE235D |. 74 09 JE SHORT D2Game.01FE2368
@ -249,6 +315,7 @@ void Install_AlwaysRegenMapInSP()
//6FC3E1FE |. 74 09 JE SHORT D2Game.6FC3E209 //6FC3E1FE |. 74 09 JE SHORT D2Game.6FC3E209
//6FD0D3BE |. 74 09 JE SHORT D2Game.6FD0D3C9 //6FD0D3BE |. 74 09 JE SHORT D2Game.6FD0D3C9
//6FC46D7E |. 74 09 JE SHORT D2Game.6FC46D89 //6FC46D7E |. 74 09 JE SHORT D2Game.6FC46D89
//0056A20F |. 74 09 JE SHORT Game.0056A21A
log_msg("\n"); log_msg("\n");
@ -265,12 +332,13 @@ void Install_RunLODs()
log_msg("Patch D2gfx for launch any number of Diablo II game in the same computer. (RunLODs)\n"); log_msg("Patch D2gfx for launch any number of Diablo II game in the same computer. (RunLODs)\n");
// execute if it's our packet else continue // execute if it's our packet else continue
mem_seek R7(D2gfx, 447C, 447C, 446A, 84CF, 84AF, 894F, 85BF, B6B0); mem_seek R8(D2gfx, 447C, 447C, 446A, 84CF, 84AF, 894F, 85BF, B6B0, F562B);
memt_byte( 0x74, 0xEB ); // JMP SHORT D2gfx.6FA884F6 memt_byte( 0x74, 0xEB ); // JMP SHORT D2gfx.6FA884F6
//6FA884AF |. 74 45 JE SHORT D2gfx.6FA884F6 //6FA884AF |. 74 45 JE SHORT D2gfx.6FA884F6
//6FA8894F |. 74 45 JE SHORT D2gfx.6FA88996 //6FA8894F |. 74 45 JE SHORT D2gfx.6FA88996
//6FA885BF |. 74 45 JE SHORT D2gfx.6FA88606 //6FA885BF |. 74 45 JE SHORT D2gfx.6FA88606
//6FA8B6B0 |. 74 45 JE SHORT D2gfx.6FA8B6F7 //6FA8B6B0 |. 74 45 JE SHORT D2gfx.6FA8B6F7
//004F562B |. 74 45 JE SHORT Game.004F5672
log_msg("\n"); log_msg("\n");
@ -279,6 +347,20 @@ void Install_RunLODs()
/****************************************************************************************************/ /****************************************************************************************************/
FCT_ASM (caller_AlwaysDisplayLife_114)
JNZ displayLife
CMP onRealm,0
JNZ normalDisplayLife
CMP active_AlwaysDisplayLifeMana,0
JE normalDisplayLife
displayLife:
POP EAX
ADD EAX,0x24
JMP EAX
normalDisplayLife:
LEA EAX,DWORD PTR DS:[ESI-0x1E]
RETN
}}
FCT_ASM (caller_AlwaysDisplayLife_113) FCT_ASM (caller_AlwaysDisplayLife_113)
POP EAX POP EAX
@ -324,7 +406,19 @@ normalDisplayLife:
RETN RETN
}} }}
FCT_ASM (caller_AlwaysDisplayMana_114)
CMP onRealm,0
JNZ normalDisplayMana
CMP active_AlwaysDisplayLifeMana,0
JE normalDisplayMana
POP EAX
ADD EAX,0x23
JMP EAX
normalDisplayMana:
LEA EDI,DWORD PTR DS:[ECX-0x6F]
CMP ESI,EDI
RETN
}}
FCT_ASM (caller_AlwaysDisplayMana_113) FCT_ASM (caller_AlwaysDisplayMana_113)
MOV EAX,DWORD PTR DS:[ptResolutionY] MOV EAX,DWORD PTR DS:[ptResolutionY]
@ -387,10 +481,10 @@ void Install_AlwaysDisplayLifeMana()
if ( version_D2Client >= V113c ) if ( version_D2Client >= V113c )
{ {
mem_seek R7(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2764A, 6D6FA); mem_seek R8(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2764A, 6D6FA, 98183);
memt_byte( 0x0F , 0x90); if (version_D2Client < V114d) memt_byte( 0x0F , 0x90);
memt_byte( 0x8C , 0xE8); memt_byte( version_D2Client >= V114d ? 0x75 : 0x8C , 0xE8);
MEMT_REF4( 0x000000BC, caller_AlwaysDisplayLife_113); MEMT_REF4( version_D2Client >= V114d ? 0xE2468D27 : 0x000000BC, version_D2Client >= V114d ? caller_AlwaysDisplayLife_114 : caller_AlwaysDisplayLife_113);
//6FAD764A |. 0F8C BC000000 JL D2Client.6FAD770C //6FAD764A |. 0F8C BC000000 JL D2Client.6FAD770C
//6FAD7650 |. 83FA 6E CMP EDX,6E //6FAD7650 |. 83FA 6E CMP EDX,6E
//6FAD7653 |. 0F8F B3000000 JG D2Client.6FAD770C //6FAD7653 |. 0F8F B3000000 JG D2Client.6FAD770C
@ -398,9 +492,12 @@ void Install_AlwaysDisplayLifeMana()
//6FAD7667 |. 0F8C A4000000 JL D2Client.6FAD7711 //6FAD7667 |. 0F8C A4000000 JL D2Client.6FAD7711
//6FB1D717 |. 0F8C A4000000 JL D2Client.6FB1D7C1 //6FB1D717 |. 0F8C A4000000 JL D2Client.6FB1D7C1
//6FB1D6FA |. 0F8C BC000000 JL D2Client.6FB1D7BC
//00498183 |. 75 27 JNZ SHORT Game.004981AC
//00498185 |. 8D46 E2 LEA EAX,DWORD PTR DS:[ESI-1E]
} else { } else {
// Always display life. // Always display life.
mem_seek R7(D2Client, 58B32, 58B32, 5F102, 2D713, B5DF3, 81733, 0000, 0000); mem_seek R8(D2Client, 58B32, 58B32, 5F102, 2D713, B5DF3, 81733, 0000, 0000, 0000);
memt_byte( 0xA1 , 0xE8); memt_byte( 0xA1 , 0xE8);
MEMT_REF4( ptResolutionY , version_D2Client >= V111 ? caller_AlwaysDisplayLife_111 : caller_AlwaysDisplayLife); MEMT_REF4( ptResolutionY , version_D2Client >= V111 ? caller_AlwaysDisplayLife_111 : caller_AlwaysDisplayLife);
//6FADD713 |. A1 605CBA6F MOV EAX,DWORD PTR DS:[6FBA5C60] //6FADD713 |. A1 605CBA6F MOV EAX,DWORD PTR DS:[6FBA5C60]
@ -416,9 +513,9 @@ void Install_AlwaysDisplayLifeMana()
//memt_byte( 0x8B , 0x90); //memt_byte( 0x8B , 0x90);
//memt_byte( 0x0D , 0xE8); //memt_byte( 0x0D , 0xE8);
//MEMT_REF4( offset_D2Client + 0x11C4B4 , caller_AlwaysDisplayMana_113); //MEMT_REF4( offset_D2Client + 0x11C4B4 , caller_AlwaysDisplayMana_113);
mem_seek R7(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2770C, 6D7BC); mem_seek R8(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2770C, 6D7BC, 9825D);
memt_byte( 0xA1 , 0xE8); memt_byte( version_D2Client >= V114d ? 0x8D : 0xA1 , 0xE8);
MEMT_REF4( ptResolutionY , caller_AlwaysDisplayMana_113); MEMT_REF4( version_D2Client >= V114d ? 0xF73B9179 : (DWORD)ptResolutionY , version_D2Client >= V114d ? caller_AlwaysDisplayMana_114 : caller_AlwaysDisplayMana_113);
//6FAD770C |> A1 4CBCB86F MOV EAX,DWORD PTR DS:[6FB8BC4C] //6FAD770C |> A1 4CBCB86F MOV EAX,DWORD PTR DS:[6FB8BC4C]
//6FAD7711 |> 8B0D B4C4BC6F MOV ECX,DWORD PTR DS:[6FBCC4B4] //6FAD7711 |> 8B0D B4C4BC6F MOV ECX,DWORD PTR DS:[6FBCC4B4]
@ -431,10 +528,12 @@ void Install_AlwaysDisplayLifeMana()
//6FAD77CB |. 81C4 28030000 ADD ESP,328 //6FAD77CB |. 81C4 28030000 ADD ESP,328
//6FAD77D1 \. C3 RETN //6FAD77D1 \. C3 RETN
//6FB1D7BC |> A1 3870BA6F MOV EAX,DWORD PTR DS:[6FB8BC4C] //6FB1D7BC |> A1 3870BA6F MOV EAX,DWORD PTR DS:[6FB8BC4C]
//0049825D |. 8D79 91 LEA EDI,DWORD PTR DS:[ECX-6F]
//00498260 |. 3BF7 CMP ESI,EDI
} }
else if ( version_D2Client >= V110 ) else if ( version_D2Client >= V110 )
{ {
mem_seek R7(D2Client, 0000, 0000, 5F1E6, 2D7FB, B5EDB, 8181B, 0000, 0000); mem_seek R8(D2Client, 0000, 0000, 5F1E6, 2D7FB, B5EDB, 8181B, 0000, 0000, 0000);
memt_byte( 0x5F , 0xE8); memt_byte( 0x5F , 0xE8);
MEMT_REF4( 0x815B5D5E , caller_AlwaysDisplayMana); MEMT_REF4( 0x815B5D5E , caller_AlwaysDisplayMana);
memt_byte( 0xC4 , 0x90); // NOP memt_byte( 0xC4 , 0x90); // NOP
@ -459,7 +558,7 @@ void Install_AlwaysDisplayLifeMana()
//6FB3181F |. 81C4 5C020000 ADD ESP,25C //6FB3181F |. 81C4 5C020000 ADD ESP,25C
//6FB31825 |. C3 RETN //6FB31825 |. C3 RETN
} else { } else {
mem_seek R7(D2Client, 58C09, 58C09, 0000, 0000, 0000, 0000, 0000, 0000); mem_seek R8(D2Client, 58C09, 58C09, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0xE9 , 0xE8); memt_byte( 0xE9 , 0xE8);
MEMT_REF4( 0x000000C2 , caller_AlwaysDisplayMana_9); MEMT_REF4( 0x000000C2 , caller_AlwaysDisplayMana_9);
//6FAF8C09 . E9 C2000000 JMP D2Client.6FAF8CD0 //6FAF8C09 . E9 C2000000 JMP D2Client.6FAF8CD0
@ -482,7 +581,7 @@ void Install_EnabledTXTFilesWithMSExcel()
log_msg("Patch D2Client for enabled the opening of files already opened by MS Excel. (EnabledTXTFilesWithMSExcel)\n"); log_msg("Patch D2Client for enabled the opening of files already opened by MS Excel. (EnabledTXTFilesWithMSExcel)\n");
mem_seek( (DWORD)D2StormMPQOpenFile + (version_Storm >= V111 ? 0x12A : 0xFF) ); mem_seek( (DWORD)D2StormMPQOpenFile + (version_Storm >= V114d ? 0xB4 : version_Storm >= V111 ? 0x12A : 0xFF) );
memt_byte( 0x01 , 0x03); //; |ShareMode = FILE_SHARE_READ|FILE_SHARE_WRITE memt_byte( 0x01 , 0x03); //; |ShareMode = FILE_SHARE_READ|FILE_SHARE_WRITE
//6FC1C969 |. 6A 01 PUSH 1 ; |ShareMode = FILE_SHARE_READ //6FC1C969 |. 6A 01 PUSH 1 ; |ShareMode = FILE_SHARE_READ
@ -517,7 +616,7 @@ void STDCALL printDisplayBaseStatsValue(WORD statID, sDrawImageInfo* data, DWORD
if (isOnRect(D2GetMouseX(),D2GetMouseY(),x+5,y+5,32,32)) if (isOnRect(D2GetMouseX(),D2GetMouseY(),x+5,y+5,32,32))
{ {
WCHAR text[100]; WCHAR text[100];
_snwprintf(text, sizeof(text), getLocalString(STR_STATS_BASE_MIN), statValue, minValue); _snwprintf(text, 100, getLocalString(STR_STATS_BASE_MIN), statValue, minValue);
D2SetFont(1); D2SetFont(1);
D2PrintPopup(text, x+18, y-32, WHITE, 1); D2PrintPopup(text, x+18, y-32, WHITE, 1);
} }
@ -544,25 +643,28 @@ void Install_DisplayBaseStatsValue()
log_msg("Patch D2Client for display base stats value. (DisplayBaseStatsValue)\n"); log_msg("Patch D2Client for display base stats value. (DisplayBaseStatsValue)\n");
// Always print stat button images. // Always print stat button images.
mem_seek R7(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5, BF955); mem_seek R8(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5, BF955, A7FFB);
memt_byte( 0x8B, 0xEB ); // JMP SHORT D2Client.6FAD0088 memt_byte( 0x8B, 0xEB ); // JMP SHORT D2Client.6FAD0088
memt_byte( 0x4C, V7(D2Client, 12, 12, 13, 13, 13, 13, 13, 13) ); memt_byte( version_D2Client == V114d ? 0x4D : 0x4C, V8(D2Client, 12, 12, 13, 13, 13, 13, 13, 13, 12) );
memt_byte( 0x24, 0x90 ); // NOP memt_byte( version_D2Client == V114d ? 0xF8 : 0x24, 0x90 ); // NOP
memt_byte( V7(D2Client, 20, 20, 14, 1C, 1C, 1C, 1C, 1C), 0x90 ); // NOP (V109d:0x20 , V110:0x14 if (version_D2Client < V114d) memt_byte( V8(D2Client, 20, 20, 14, 1C, 1C, 1C, 1C, 1C, 53), 0x90 ); // NOP (V109d:0x20 , V110:0x14
//6FAD0073 8B4C24 14 MOV ECX,DWORD PTR SS:[ESP+14] //6FAD0073 8B4C24 14 MOV ECX,DWORD PTR SS:[ESP+14]
//6FB32BBA > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C] //6FB32BBA > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB3963A > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C] //6FB3963A > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB1B59A > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C] //6FB1B59A > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB6D1B5 |> 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C] //6FB6D1B5 |> 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB6F955 |> 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C] //6FB6F955 |> 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//004A7FFB > 8B4D F8 MOV ECX,DWORD PTR SS:[EBP-8]
//004A7FFE . 53 PUSH EBX ; /Arg3
mem_seek R7(D2Client, 29B9D, 29B8D, 300FD, 82C54, 896D4, 6B637, BD23E, BF9DE); mem_seek R8(D2Client, 29B9D, 29B8D, 300FD, 82C54, 896D4, 6B637, BD23E, BF9DE, A808C);
MEMJ_REF4( D2PrintImage, caller_displayBaseStatsValue); MEMJ_REF4( D2PrintImage, caller_displayBaseStatsValue);
//6FB32C53 . E8 82A3F8FF CALL <JMP.&D2gfx.#10047> //6FB32C53 . E8 82A3F8FF CALL <JMP.&D2gfx.#10047>
//6FB396D3 . E8 D238F8FF CALL <JMP.&D2gfx.#10044> //6FB396D3 . E8 D238F8FF CALL <JMP.&D2gfx.#10044>
//6FB1B636 . E8 431AFAFF CALL <JMP.&D2gfx.#10024> //6FB1B636 . E8 431AFAFF CALL <JMP.&D2gfx.#10024>
//6FB6D23D |. E8 54FEF4FF |CALL <JMP.&D2gfx.#10041> //6FB6D23D |. E8 54FEF4FF |CALL <JMP.&D2gfx.#10041>
//6FB6F9DD |. E8 54FEF4FF |CALL <JMP.&D2gfx.#10042> //6FB6F9DD |. E8 54FEF4FF |CALL <JMP.&D2gfx.#10042>
//004A808B . E8 F0E30400 CALL Game.004F6480 ; \Game.004F6480
log_msg("\n"); log_msg("\n");
@ -590,7 +692,7 @@ void Install_LadderRunewords()
log_msg("Patch D2Common for enabled the ladder only runewords. (LadderRunewords)\n"); log_msg("Patch D2Common for enabled the ladder only runewords. (LadderRunewords)\n");
mem_seek R7(D2Common, 0000, 0000, 1E965, 61762, 43A72, 5D492, 724B2, 63782); mem_seek R8(D2Common, 0000, 0000, 1E965, 61762, 43A72, 5D492, 724B2, 63782, 239C40);
MEMC_REF4( D2CompileTxtFile, compileRunesTxt); MEMC_REF4( D2CompileTxtFile, compileRunesTxt);
//01B6E964 |. E8 0714FFFF CALL D2Common.#10578 ; \#10578 //01B6E964 |. E8 0714FFFF CALL D2Common.#10578 ; \#10578
//6FDB1761 |. E8 FAA8FCFF CALL D2Common.#10653 ; \#10653 //6FDB1761 |. E8 FAA8FCFF CALL D2Common.#10653 ; \#10653
@ -598,6 +700,7 @@ void Install_LadderRunewords()
//6FDAD491 |. E8 BA49FEFF CALL D2Common.#10244 ; \#10244 //6FDAD491 |. E8 BA49FEFF CALL D2Common.#10244 ; \#10244
//6FDC24B1 |. E8 8ACAFEFF CALL D2Common.#10849 ; \#10849 //6FDC24B1 |. E8 8ACAFEFF CALL D2Common.#10849 ; \#10849
//6FDB3781 |. E8 5A93FAFF CALL D2Common.#10037 ; \#10037 //6FDB3781 |. E8 5A93FAFF CALL D2Common.#10037 ; \#10037
//00639C3F |. E8 AC86FDFF CALL Game.006122F0 ; \Game.006122F0
log_msg("\n"); log_msg("\n");
@ -615,7 +718,7 @@ void Install_EnabledCowPortalWhenCowKingWasKill()
log_msg("Patch D2Game for enabled the opening of Cow Portal when player have already kill the cow king in that difficulty. (EnabledCowPortalWhenCowKingWasKill)\n"); log_msg("Patch D2Game for enabled the opening of Cow Portal when player have already kill the cow king in that difficulty. (EnabledCowPortalWhenCowKingWasKill)\n");
mem_seek R7(D2Game, 5DFF7, 5E457, 6C5E7 , B1278, 5DB68, 75C68, 67508, EBE8); mem_seek R8(D2Game, 5DFF7, 5E457, 6C5E7 , B1278, 5DB68, 75C68, 67508, EBE8, 194179);
memt_byte( 0x85 , 0x33); // XOR EAX,EAX memt_byte( 0x85 , 0x33); // XOR EAX,EAX
//6FC8DFF7 . 85C0 TEST EAX,EAX //6FC8DFF7 . 85C0 TEST EAX,EAX
//6FC8E457 . 85C0 TEST EAX,EAX //6FC8E457 . 85C0 TEST EAX,EAX
@ -625,6 +728,233 @@ void Install_EnabledCowPortalWhenCowKingWasKill()
//6FC95C68 |. 85C0 TEST EAX,EAX //6FC95C68 |. 85C0 TEST EAX,EAX
//6FC87508 |. 85C0 TEST EAX,EAX //6FC87508 |. 85C0 TEST EAX,EAX
//6FC2EBE8 |. 85C0 TEST EAX,EAX //6FC2EBE8 |. 85C0 TEST EAX,EAX
//00594179 |. 85C0 TEST EAX,EAX
log_msg("\n");
isInstalled = true;
}
/****************************************************************************************************/
void Install_DoNotCloseNihlathakPortal()
{
static int isInstalled = false;
if (isInstalled) return;
log_msg("Patch D2Game to not close Nihlathak's portal. (DoNotCloseNihlathakPortal)\n");
mem_seek R8(D2Game, 76B19, 77019, 86679 , 107C7, 51987, 26B67, 5AE67, 1FF27, 18B9D7);
memt_byte(0x0F, 0x90);
memt_byte(0x85, 0x90);
memt_dword( version_D2Game >= V114d ? 0x000000C5 : version_D2Game >= V111 ? 0x000000BF : 0x000000C1, 0x90909090);
//6FCA6B19 . 0F85 C1000000 JNZ D2Game.6FCA6BE0
//6FCA7019 . 0F85 C1000000 JNZ D2Game.6FCA70E0
//6FCB6679 . 0F85 C1000000 JNZ D2Game.6FCB6740
//6FC307C7 . 0F85 BF000000 JNZ D2Game.6FC3088C
//6FC71987 . 0F85 BF000000 JNZ D2Game.6FC71A4C
//6FC46B67 . 0F85 BF000000 JNZ D2Game.6FC46C2C
//6FC7AE67 . 0F85 BF000000 JNZ D2Game.6FC7AF2C
//6FC3FF27 . 0F85 BF000000 JNZ D2Game.6FC3FFEC
//0058B9D7 |. 0F85 C5000000 JNZ Game.0058BAA2
log_msg("\n");
isInstalled = true;
}
/****************************************************************************************************/
/* townWest.ds1:
129A6 : 4D->76
129AA : 56->3A
12ACA : 05->04
+4 : 4D->76
+4 : 56->3A
+4 : 4E->76
+4 : 58->3A
+4 : 01->01
+4 : 4C->7B
+4 : 57->50
+4 : 02->02
+4 : 4D->7B
+4 : 5D->41
+4 : 01->01
+4 : 49->7D
+4 : 5C->3E
+4 : 02->02
+4 : 4F->
+4 : 5B->
+4 : 02->
*/
/*char* FASTCALL usePlugYTownWest(char* filename)
{
if (onRealm)
return filename;
if (!strcmp(filename, "DATA\\GLOBAL\\TILES\\Expansion\\Town\\townWest.ds1"))
return "PlugY\\townWest.ds1";
return filename;
}
FCT_ASM ( caller_usePlugYTownWest )
LEA EAX,DWORD PTR SS:[EBP-0x40]
MOV ECX,EAX
CALL usePlugYTownWest
MOV ECX,EAX
RETN
}}
FCT_ASM ( caller_usePlugYTownWest_113d )
LEA EAX,DWORD PTR SS:[ESP+0x14]
MOV ECX,EAX
CALL usePlugYTownWest
MOV EDX,ESI
RETN
}}*/
/****************************************************************************************************/
void* FASTCALL updateHarrogath(DWORD unused, char* filename, DWORD* size, const char* __CallFile, DWORD __CallLine)
{
if (onRealm)
return D2ReadFile(unused, filename, size, __CallFile, __CallLine);
if (strcmp(filename, "DATA\\GLOBAL\\TILES\\Expansion\\Town\\townWest.ds1"))
return D2ReadFile(unused, filename, size, __CallFile, __CallLine);
DWORD fileSize = 0;
if (size == NULL)
size = &fileSize;
char* data = (char*)D2ReadFile(unused, filename, size, __FILE__, __LINE__);
if (*size > 400 &&
*(DWORD*)(data + *size - 0x16C) == 0x0000004D &&
*(DWORD*)(data + *size - 0x168) == 0x00000056 &&
*(DWORD*)(data + *size - 0x48) == 0x00000005 &&
*(DWORD*)(data + *size - 0x44) == 0x0000004D &&
*(DWORD*)(data + *size - 0x40) == 0x00000056 &&
*(DWORD*)(data + *size - 0x3C) == 0x0000004E &&
*(DWORD*)(data + *size - 0x38) == 0x00000058 &&
*(DWORD*)(data + *size - 0x34) == 0x00000001 &&
*(DWORD*)(data + *size - 0x30) == 0x0000004C &&
*(DWORD*)(data + *size - 0x2C) == 0x00000057 &&
*(DWORD*)(data + *size - 0x28) == 0x00000002 &&
*(DWORD*)(data + *size - 0x24) == 0x0000004D &&
*(DWORD*)(data + *size - 0x20) == 0x0000005D &&
*(DWORD*)(data + *size - 0x1C) == 0x00000001 &&
*(DWORD*)(data + *size - 0x18) == 0x00000049 &&
*(DWORD*)(data + *size - 0x14) == 0x0000005C &&
*(DWORD*)(data + *size - 0x10) == 0x00000002 &&
*(DWORD*)(data + *size - 0x0C) == 0x0000004F &&
*(DWORD*)(data + *size - 0x08) == 0x0000005B &&
*(DWORD*)(data + *size - 0x04) == 0x00000002)
{
log_msg("update TownWest to Move Cain near Harrogath waypoint\n");
*(DWORD*)(data + *size - 0x16C) = 0x00000076;
*(DWORD*)(data + *size - 0x168) = 0x0000003A;
*(DWORD*)(data + *size - 0x48) = 0x00000004;
*(DWORD*)(data + *size - 0x44) = 0x00000076;
*(DWORD*)(data + *size - 0x40) = 0x0000003A;
*(DWORD*)(data + *size - 0x3C) = 0x00000076;
*(DWORD*)(data + *size - 0x38) = 0x0000003A;
*(DWORD*)(data + *size - 0x34) = 0x00000001;
*(DWORD*)(data + *size - 0x30) = 0x0000007B;
*(DWORD*)(data + *size - 0x2C) = 0x00000050;
*(DWORD*)(data + *size - 0x28) = 0x00000002;
*(DWORD*)(data + *size - 0x24) = 0x0000007B;
*(DWORD*)(data + *size - 0x20) = 0x00000041;
*(DWORD*)(data + *size - 0x1C) = 0x00000001;
*(DWORD*)(data + *size - 0x18) = 0x0000007D;
*(DWORD*)(data + *size - 0x14) = 0x0000003E;
*(DWORD*)(data + *size - 0x10) = 0x00000002;
*(DWORD*)(data + *size - 0x0C) = 0x00000000;
*(DWORD*)(data + *size - 0x08) = 0x00000000;
*(DWORD*)(data + *size - 0x04) = 0x00000000;
}
else
log_msg("ERROR : Failed to update TownWest to Move Cain near Harrogath waypoint\n");
return data;
}
FCT_ASM ( caller_updateHarrogath )
MOV ECX,DWORD PTR SS:[ESP+4]
PUSH 0
PUSH 0
PUSH DWORD PTR SS:[ESP+0x10]
MOV EDX,EAX
CALL updateHarrogath
RETN 8
}}
void Install_MoveCainNearHarrogathWaypoint()
{
static int isInstalled = false;
if (isInstalled) return;
log_msg("Patch D2Common to move Deckard Cain near Waypoint in Harrogath. (MoveCainNearHarrogathWaypoint)\n");
mem_seek R8(D2Common, 3653E, 3654E, 45A2E , 82233, 39593, 222A3, B573, 54033, 265972);
MEMC_REF4( V2ReadFile, version_D2Common >= V111 && version_D2Common <= V113d? (TD2ReadFile)caller_updateHarrogath : updateHarrogath);
//6FD7653D |. E8 62D30300 CALL D2Common.6FDB38A4
//6FD7654D |. E8 62D40300 CALL D2Common.6FDB39B4
//6FD85A2D |. E8 36E80300 CALL D2Common.6FDC4268
//6FDD2232 . E8 A974F8FF CALL D2Common.6FD596E0
//6FD89592 . E8 3903FDFF CALL D2Common.6FD598D0
//6FD722A2 . E8 5976FEFF CALL D2Common.6FD59900
//6FD5B572 . E8 89E3FFFF CALL D2Common.6FD59900
//6FDA4032 . E8 A975FBFF CALL D2Common.6FD5B5E0
//00665971 |. E8 0317EBFF CALL Game.00517079
/*
mem_seek R8(D2Common, 0000, 0000, 0000 , 0000, 0000, 734AA, 6C75A, 308FA, 21E4F7);
memt_byte( 0x8D, 0xE8);
MEMT_REF4( version_D2Common >= V114d ? 0xC88BC045 : 0x8B102444, version_D2Common >= V114d ? caller_usePlugYTownWest : caller_usePlugYTownWest_113d);
if (version_D2Common < V114d) memt_byte( 0xD6, 0x90);
//6FDC34AA |. 8D4424 10 LEA EAX,DWORD PTR SS:[ESP+10]
//6FDC34AE |. 8BD6 MOV EDX,ESI
//6FDBC75A |. 8D4424 10 LEA EAX,DWORD PTR SS:[ESP+10]
//6FDBC75E |. 8BD6 MOV EDX,ESI
//6FD808FA |. 8D4424 10 LEA EAX,DWORD PTR SS:[ESP+10]
//6FD808FE |. 8BD6 MOV EDX,ESI
//0061E4F7 |. 8D45 C0 LEA EAX,DWORD PTR SS:[EBP-40]
//0061E4FA |. 8BC8 MOV ECX,EAX
*/
log_msg("\n");
isInstalled = true;
}
ExperienceBIN* STDCALL modifExperienceBin(ExperienceBIN* ptExperienceBIN)
{
for (int i=71; i<101; i++)
ptExperienceBIN[i].ExpRatio = 1024;
return ptExperienceBIN;
}
FCT_ASM ( caller_modifExperienceBin )
PUSH DWORD PTR SS:[ESP+0x14]
PUSH DWORD PTR SS:[ESP+0x14]
PUSH DWORD PTR SS:[ESP+0x14]
PUSH DWORD PTR SS:[ESP+0x14]
PUSH DWORD PTR SS:[ESP+0x14]
CALL D2CompileTxtFile
PUSH EAX
CALL modifExperienceBin
RETN 0x14
}}
void Install_RemoveExperienceDiminushingReturn()
{
static int isInstalled = false;
if (isInstalled) return;
log_msg("Patch D2Common to remove experience diminushing return. (RemoveExperienceDiminushingReturn)\n");
// modification of experienceBIN
mem_seek R8(D2Common, 00000, 00000, 00000, 00000, 00000, 00000, 00000, 00000, 213E42);
MEMC_REF4( D2CompileTxtFile, caller_modifExperienceBin);
//00613E41 |. E8 AAE4FFFF CALL Game.006122F0 ; \Game.006122F0
log_msg("\n"); log_msg("\n");

62
PlugY/GlobalVariable.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Updating server. Updating server.
@ -8,16 +9,21 @@
#include "bigStash.h" // active_bigStash_tested #include "bigStash.h" // active_bigStash_tested
#include "uberQuest.h" //active_UberQuest + resetQuestState() #include "uberQuest.h" //active_UberQuest + resetQuestState()
#include "infinityStash.h" //active_UberQuest + resetQuestState()
#include "common.h" #include "common.h"
#include <stdio.h> #include <stdio.h>
bool onRealm=false; bool onRealm = false;
bool needToInit=false; bool needToInit = false;
int previouslyOnRealm = -1; int previouslyOnRealm = -1;
void STDCALL BtnPress() // mode 0:SinglePlayer - 1:TCPIP - 2:Battlenet
void STDCALL BtnPress(int mode)
{ {
needToInit = 1; needToInit = true;
loadLocalizedStrings(D2GetLang());
// if (active_WorldEvent) // if (active_WorldEvent)
// initWorldEventVariables(); // initWorldEventVariables();
if (active_UberQuest) if (active_UberQuest)
@ -27,11 +33,28 @@ void STDCALL BtnPress()
previouslyOnRealm = onRealm; previouslyOnRealm = onRealm;
} }
FCT_ASM ( caller_BnetBtnPress114 )
CMP active_DisableBattleNet,1
JE disableBattleNet
MOV onRealm,1
PUSH EAX
PUSH 2
CALL BtnPress
POP EAX
SUB ESP,0x3FC//400
JMP DWORD PTR SS:[ESP+0x3FC]
disableBattleNet:
POP EAX
POP EAX
RETN
}}
FCT_ASM ( caller_BnetBtnPress ) FCT_ASM ( caller_BnetBtnPress )
CMP active_DisableBattleNet,1 CMP active_DisableBattleNet,1
JE disableBattleNet JE disableBattleNet
MOV onRealm,1 MOV onRealm,1
PUSH EAX PUSH EAX
PUSH 2
CALL BtnPress CALL BtnPress
POP EAX POP EAX
SUB ESP,0x3FC//400 SUB ESP,0x3FC//400
@ -49,8 +72,18 @@ FCT_ASM ( caller_MultiPlayerBtnPress )
}} }}
*/ */
FCT_ASM ( caller_TCPIPBtnPress114 )
MOV onRealm,0
PUSH 1
CALL BtnPress
MOV ECX,DWORD PTR SS:[ESP]
ADD ECX,0xB9B0
JMP ECX
}}
FCT_ASM ( caller_TCPIPBtnPress111 ) FCT_ASM ( caller_TCPIPBtnPress111 )
MOV onRealm,0 MOV onRealm,0
PUSH 1
CALL BtnPress CALL BtnPress
MOV ESI,0x40 MOV ESI,0x40
RETN RETN
@ -58,6 +91,7 @@ FCT_ASM ( caller_TCPIPBtnPress111 )
FCT_ASM ( caller_TCPIPBtnPress ) FCT_ASM ( caller_TCPIPBtnPress )
MOV onRealm,0 MOV onRealm,0
PUSH 1
CALL BtnPress CALL BtnPress
MOV EBP,1 MOV EBP,1
RETN RETN
@ -65,6 +99,7 @@ FCT_ASM ( caller_TCPIPBtnPress )
FCT_ASM ( caller_SinglePlayerBtnPress ) FCT_ASM ( caller_SinglePlayerBtnPress )
MOV onRealm,0 MOV onRealm,0
PUSH 0
CALL BtnPress CALL BtnPress
MOV EDX,0x400 MOV EDX,0x400
RETN RETN
@ -99,11 +134,12 @@ void Install_VariableOnRealm()
log_msg("Patch D2Launch for set not on realm variable. (VariableonRealm)\n"); log_msg("Patch D2Launch for set not on realm variable. (VariableonRealm)\n");
// click on Battle.net button // click on Battle.net button
mem_seek R7(D2Launch, 8195, 81A5, 9915, 129E5, 18AA5, 17D15, 19295, 11C65); mem_seek R8(D2Launch, 8195, 81A5, 9915, 129E5, 18AA5, 17D15, 19295, 11C65, 3533B);
memt_byte( 0x81, 0xE8 ); // CALL memt_byte( 0x81, 0xE8 ); // CALL
MEMT_REF4( 0x000400EC, caller_BnetBtnPress); MEMT_REF4( 0x000400EC, version_D2Launch == V114d ? caller_BnetBtnPress114 : caller_BnetBtnPress);
memt_byte( 0x00, 0x90 ); // NOP memt_byte( 0x00, 0x90 ); // NOP
//6FA529E5 . 81EC 00040000 SUB ESP,400 //6FA529E5 . 81EC 00040000 SUB ESP,400
//0043533B |. 81EC 00040000 SUB ESP,400
// click on Multiplayer button // click on Multiplayer button
// mem_seek R7(D2Launch, D5EC, D5CC, EFFC, 0000, 0000, 0000, 0000); // mem_seek R7(D2Launch, D5EC, D5CC, EFFC, 0000, 0000, 0000, 0000);
@ -112,11 +148,16 @@ void Install_VariableOnRealm()
//6FA1EFFC . B8 01000000 MOV EAX,1 //6FA1EFFC . B8 01000000 MOV EAX,1
// click on TCP/IP button // click on TCP/IP button
mem_seek R7(D2Launch, 87B9, 87C9, 9F99, 11329, 17409, 16659, 17B8E, 1053E); mem_seek R8(D2Launch, 87B9, 87C9, 9F99, 11329, 17409, 16659, 17B8E, 1053E, 2FFEC);
if (version_D2Launch == V109b || version_D2Launch == V109d || version_D2Launch == V110) if (version_D2Launch <= V110)
{ {
memt_byte( 0xBD, 0xE8 ); // CALL memt_byte( 0xBD, 0xE8 ); // CALL
MEMT_REF4( 0x00000001, caller_TCPIPBtnPress); MEMT_REF4( 0x00000001, caller_TCPIPBtnPress);
}
else if (version_D2Launch >= V114d)
{
MEMT_REF4( 0x0000B9B0, caller_TCPIPBtnPress114);
//0042FFEB . E8 B0B90000 CALL Game.0043B9A0
} else { } else {
memt_byte( 0xBE, 0xE8 ); // CALL memt_byte( 0xBE, 0xE8 ); // CALL
MEMT_REF4( 0x00000040, caller_TCPIPBtnPress111); MEMT_REF4( 0x00000040, caller_TCPIPBtnPress111);
@ -124,16 +165,17 @@ void Install_VariableOnRealm()
} }
// click on SinglePlayer button // click on SinglePlayer button
mem_seek R7(D2Launch, D1F6, D1E6, EC16, B726, 117E6, 10A56, 11F36, A906); mem_seek R8(D2Launch, D1F6, D1E6, EC16, B726, 117E6, 10A56, 11F36, A906, 30BC9);
memt_byte( 0xBA, 0xE8 ); // CALL memt_byte( 0xBA, 0xE8 ); // CALL
MEMT_REF4( 0x00000400, caller_SinglePlayerBtnPress); MEMT_REF4( 0x00000400, caller_SinglePlayerBtnPress);
//6FA4B726 . BA 00040000 MOV EDX,400 //6FA4B726 . BA 00040000 MOV EDX,400
//00430BC9 |. BA 00040000 MOV EDX,400
if (version_D2Game == V110) if (version_D2Game == V110)
{ {
log_msg("\nPatch D2Game for fixing ptClient removing bug. (VariableonRealm)\n"); log_msg("\nPatch D2Game for fixing ptClient removing bug. (VariableonRealm)\n");
//Bug crash ptClient search fix (for Megalixir Mod). //Bug crash ptClient search fix (for Megalixir Mod).
mem_seek R7(D2Game, 0000, 0000, 2B97, 0000, 0000, 0000, 0000, 0000); mem_seek R8(D2Game, 0000, 0000, 2B97, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0x39 ,0xE8); memt_byte( 0x39 ,0xE8);
MEMT_REF4( 0x8B0C7429 , caller_fixClientRemovingBug); MEMT_REF4( 0x8B0C7429 , caller_fixClientRemovingBug);
memt_byte( 0xC1 ,0x90); memt_byte( 0xC1 ,0x90);

432
PlugY/InfinityStash.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Gestion of the infinity and shared Stash. Gestion of the infinity and shared Stash.
@ -19,10 +20,13 @@ DWORD maxSharedPages = -1;
DWORD nbPagesPerIndex = 10; DWORD nbPagesPerIndex = 10;
DWORD nbPagesPerIndex2 = 100; DWORD nbPagesPerIndex2 = 100;
bool active_multiPageStash = false; bool active_multiPageStash = false;
bool autoRenameStashPage = false;
int active_SharedStashInMultiPlayer = 0;//0: disabled, 1:shared in SP, 2: shared in SP & TCP/IP
bool active_sharedStash = false; bool active_sharedStash = false;
bool separateHardSoftStash = false; bool separateHardSoftStash = false;
bool active_sharedGold=false; bool active_sharedGold=false;
char* sharedStashFilename = NULL; char* sharedStashFilename = NULL;
DWORD saveFileStackSize = 0x2000;
typedef int (*TchangeToSelectedStash)(Unit* ptChar, Stash* newStash, DWORD bOnlyItems, DWORD bIsClient); typedef int (*TchangeToSelectedStash)(Unit* ptChar, Stash* newStash, DWORD bOnlyItems, DWORD bIsClient);
@ -38,14 +42,14 @@ Unit* firstClassicStashItem(Unit* ptChar)
return NULL; return NULL;
} }
DWORD endStashList(Unit* ptChar, Stash* ptStash)//WORKS DWORD endStashList(Unit* ptChar, Stash* ptStash)
{ {
Stash* stash = ptStash; Stash* stash = ptStash;
while (stash) while (stash)
{ {
if (stash->ptListItem || ((stash == PCPY->currentStash) && firstClassicStashItem(ptChar))) return 0; if (stash->ptListItem || ((stash == PCPY->currentStash) && firstClassicStashItem(ptChar))) return 0;
if (stash->isIndex || (stash->name != NULL && stash->name[0])) return 0; if (stash->name != NULL && stash->name[0]) return 0;
stash = stash->nextStash; stash = stash->nextStash;
} }
return 1; return 1;
@ -63,15 +67,13 @@ DWORD endStashList(Unit* ptChar, Stash* ptStash)//WORKS
//} //}
Stash* getLastStash(Stash* ptStash)//WORKS Stash* getLastStash(Stash* ptStash)
{ {
Stash* stash = ptStash; if (!ptStash)
return NULL;
if (!stash) return NULL; while (ptStash->nextStash)
while (stash->nextStash) ptStash = ptStash->nextStash;
stash = stash->nextStash; return ptStash;
return stash;
} }
Stash* newStash(DWORD id) Stash* newStash(DWORD id)
@ -86,36 +88,43 @@ Stash* newStash(DWORD id)
return stash; return stash;
} }
Stash* addStash(Unit* ptChar, bool isShared) Stash* addStash(Unit* ptChar, bool isShared, bool autoSetIndex, Stash* previous)
{ {
Stash* previous; previous = getLastStash(previous ? previous : isShared ? PCPY->sharedStash : PCPY->selfStash);
Stash* stash; if (previous)
// DWORD memPool = PCGame ? PCGame->memoryPool :0; isShared = previous->isShared;
if (isShared)
{
previous = getLastStash(PCPY->sharedStash);
stash = newStash(PCPY->nbSharedPages++);
} else {
previous = getLastStash(PCPY->selfStash);
stash = newStash(PCPY->nbSelfPages++);
}
Stash* stash = newStash(isShared ? PCPY->nbSharedPages++ : PCPY->nbSelfPages++);
stash->isShared = isShared; stash->isShared = isShared;
stash->previousStash = previous; stash->previousStash = previous;
if (previous) if (previous)
{
previous->nextStash = stash; previous->nextStash = stash;
if (autoSetIndex)
{
stash->isIndex = ((stash->id + 1) % nbPagesPerIndex) == 0;
stash->isMainIndex = ((stash->id + 1) % nbPagesPerIndex2) == 0;
}
}
else if (isShared) else if (isShared)
{
PCPY->sharedStash = stash; PCPY->sharedStash = stash;
stash->isIndex = 1;
stash->isMainIndex = 1;
}
else else
{
PCPY->selfStash = stash; PCPY->selfStash = stash;
stash->isIndex = 1;
stash->isMainIndex = 1;
}
log_msg("AddStash: stash->id=%d\tstash->isShared=%d\tstash->previous=%08X\tnbSelf=%d\tnbShared=%d\n", log_msg("AddStash: stash->id=%d\tstash->isShared=%d\tnbSelf=%d\tnbShared=%d\n", stash->id, stash->isShared, PCPY->nbSelfPages, PCPY->nbSharedPages);
stash->id,stash->isShared,stash->previousStash,PCPY->nbSelfPages,PCPY->nbSharedPages);
return stash; return stash;
} }
Stash* getStash(Unit* ptChar, DWORD isShared, DWORD id)//WORKS Stash* getStash(Unit* ptChar, DWORD isShared, DWORD id)
{ {
Stash* ptStash = isShared ? PCPY->sharedStash : PCPY->selfStash; Stash* ptStash = isShared ? PCPY->sharedStash : PCPY->selfStash;
@ -133,11 +142,11 @@ int changeToSelectedStash_9(Unit* ptChar, Stash* newStash, DWORD bOnlyItems, DWO
{ {
if (!newStash) return 0; if (!newStash) return 0;
log_msg("changeToSelectedStash ID:%d\tshared:%d\tonlyItems:%d\tclient:%d\n", newStash->id, newStash->isShared, bOnlyItems, bIsClient);
Stash* currentStash = PCPY->currentStash; Stash* currentStash = PCPY->currentStash;
if (currentStash == newStash) return 0; if (currentStash == newStash) return 0;
log_msg("changeToSelectedStash ID:%d\tshared:%d\tonlyItems:%d\tclient:%d\n", newStash->id, newStash->isShared, bOnlyItems, bIsClient);
d2_assert( currentStash && currentStash->ptListItem, "ERROR : currentStash isn't empty (ptListItem != NULL)",__FILE__,__LINE__); d2_assert( currentStash && currentStash->ptListItem, "ERROR : currentStash isn't empty (ptListItem != NULL)",__FILE__,__LINE__);
// collect items to remove // collect items to remove
@ -152,7 +161,7 @@ int changeToSelectedStash_9(Unit* ptChar, Stash* newStash, DWORD bOnlyItems, DWO
{ {
D2SetAnim(D2GetRealItem(ptItem),-1); D2SetAnim(D2GetRealItem(ptItem),-1);
if (ptPrevItem) { if (ptPrevItem) {
ptPrevItem->CurrentAnim = (DWORD)ptNextItem;//is ptPrevItem->nextNode = ptNextItem; ptPrevItem->mode = (DWORD)ptNextItem;//is ptPrevItem->nextNode = ptNextItem;
} else { } else {
ptInventory->currentUsedSocket = (DWORD)ptNextItem;//is ptInventory->ptListItem = ptNextItem; ptInventory->currentUsedSocket = (DWORD)ptNextItem;//is ptInventory->ptListItem = ptNextItem;
} }
@ -166,7 +175,7 @@ int changeToSelectedStash_9(Unit* ptChar, Stash* newStash, DWORD bOnlyItems, DWO
if (currentStash) if (currentStash)
{ {
// ptItem = setNextItem(ptItem, PCPY->currentStash->ptListItem); // ptItem = setNextItem(ptItem, PCPY->currentStash->ptListItem);
ptItem->CurrentAnim = (DWORD)currentStash->ptListItem;//is ptItem->nextNode = ptListItem ptItem->mode = (DWORD)currentStash->ptListItem;//is ptItem->nextNode = ptListItem
currentStash->ptListItem = ptItem; currentStash->ptListItem = ptItem;
}; };
} else ptPrevItem = ptItem; } else ptPrevItem = ptItem;
@ -194,11 +203,11 @@ int changeToSelectedStash_10(Unit* ptChar, Stash* newStash, DWORD bOnlyItems, DW
{ {
if (!newStash) return 0; if (!newStash) return 0;
log_msg("changeToSelectedStash ID:%d\tshared:%d\tonlyItems:%d\tclient:%d\n",newStash->id,newStash->isShared, bOnlyItems,bIsClient);
Stash* currentStash = PCPY->currentStash; Stash* currentStash = PCPY->currentStash;
if (currentStash == newStash) return 0; if (currentStash == newStash) return 0;
log_msg("changeToSelectedStash ID:%d\tshared:%d\tonlyItems:%d\tclient:%d\n",newStash->id,newStash->isShared, bOnlyItems,bIsClient);
d2_assert( currentStash && currentStash->ptListItem, "ERROR : currentStash isn't empty (ptListItem != NULL)",__FILE__,__LINE__); d2_assert( currentStash && currentStash->ptListItem, "ERROR : currentStash isn't empty (ptListItem != NULL)",__FILE__,__LINE__);
// Remove items from current page // Remove items from current page
@ -267,7 +276,7 @@ DWORD loadStash(Unit* ptChar, Stash* ptStash, BYTE data[], DWORD startSize, DWOR
// if (strlen((char *)&data[curSize]) > 0xF) // if (strlen((char *)&data[curSize]) > 0xF)
// *(char *)&data[curSize+0xF] = NULL; // *(char *)&data[curSize+0xF] = NULL;
if (strlen((char *)&data[curSize])) if (strlen((char *)&data[curSize]))
ptStash->name = (char*)malloc(strlen((char *)&data[curSize]));//D2AllocMem(PCGame->memoryPool, strlen((char *)&data[curSize]),__FILE__,__LINE__,0); ptStash->name = (char*)malloc(strlen((char *)&data[curSize]) + 1);//D2AllocMem(PCGame->memoryPool, strlen((char *)&data[curSize]),__FILE__,__LINE__,0);
if (ptStash->name) if (ptStash->name)
strcpy(ptStash->name, (char *)&data[curSize]); strcpy(ptStash->name, (char *)&data[curSize]);
curSize += strlen((char *)&data[curSize]) + 1; curSize += strlen((char *)&data[curSize]) + 1;
@ -275,41 +284,79 @@ DWORD loadStash(Unit* ptChar, Stash* ptStash, BYTE data[], DWORD startSize, DWOR
// Read inventory. // Read inventory.
DWORD ret = D2LoadInventory(PCGame, ptChar, (saveBitField*)&data[curSize], 0x60, maxSize-curSize, 0, &nbBytesRead); DWORD ret = D2LoadInventory(PCGame, ptChar, (saveBitField*)&data[curSize], 0x60, maxSize-curSize, 0, &nbBytesRead);
if (ret) log_msg("loadStash -> D2LoadInventory failed\n"); if (ret) log_msg("loadStash -> D2LoadInventory failed\n");
log_msg("Stash loaded (%d : %s)\n", ptStash->id ,ptStash->name); log_msg("Stash loaded (%d : %s)\n", ptStash->id, ptStash->name);
*retSize=curSize + nbBytesRead; *retSize=curSize + nbBytesRead;
return ret; return ret;
} }
DWORD loadStashList(Unit* ptChar, BYTE* data, DWORD maxSize, DWORD* curSize, bool isShared)//WORKS void autoSetIndex(Stash* firstStash)
{
if (!firstStash)
return;
log_msg("autoSetIndex\n");
Stash* stash = firstStash;
while (stash)
{
if (stash->isIndex || stash->isMainIndex)
return;
stash = stash->nextStash;
}
stash = firstStash;
stash->isIndex = 1;
stash->isMainIndex = 1;
stash = stash->nextStash;
while (stash)
{
stash->isIndex = ((stash->id + 1) % nbPagesPerIndex) == 0;
stash->isMainIndex = ((stash->id + 1) % nbPagesPerIndex2) == 0;
stash = stash->nextStash;
}
}
DWORD loadStashList(Unit* ptChar, BYTE* data, DWORD maxSize, DWORD* curSize, bool isShared)
{ {
DWORD curStash = 0; DWORD curStash = 0;
Stash* newStash; Stash* newStash = NULL;
DWORD nbStash = *(DWORD*)&data[*curSize]; DWORD nbStash = *(DWORD*)&data[*curSize];
*curSize += 4; *curSize += 4;
log_msg("loadStashList nbStash=%d\n", nbStash);
while (curStash < nbStash) while (curStash < nbStash)
{ {
newStash = addStash(ptChar, isShared); newStash = addStash(ptChar, isShared, false, newStash);
changeToSelectedStash(ptChar, newStash, 0, false); changeToSelectedStash(ptChar, newStash, 0, false);
DWORD ret = loadStash(ptChar, newStash, data, *curSize, 10000000, curSize); DWORD ret = loadStash(ptChar, newStash, data, *curSize, 10000000, curSize);
if (ret) return ret; if (ret) return ret;
curStash++; curStash++;
} }
if (!isShared && !PCPY->selfStash) if (!isShared)
{ {
newStash = addStash(ptChar, isShared); if (PCPY->selfStash)
autoSetIndex(PCPY->selfStash);
else
{
newStash = addStash(ptChar, isShared, true, newStash);
PCPY->currentStash = newStash; PCPY->currentStash = newStash;
} }
}
if (isShared && !PCPY->sharedStash) if (isShared)
{ {
newStash = addStash(ptChar, isShared); if (PCPY->sharedStash)
autoSetIndex(PCPY->sharedStash);
else
{
newStash = addStash(ptChar, isShared, true, newStash);
if (!PCPY->currentStash) if (!PCPY->currentStash)
PCPY->currentStash = newStash; PCPY->currentStash = newStash;
} }
}
changeToSelectedStash(ptChar, isShared?PCPY->sharedStash:PCPY->selfStash, 0, false);
return 0; return 0;
} }
@ -332,7 +379,7 @@ void saveStash(Unit* ptChar, Stash* ptStash, BYTE** data, DWORD* maxSize, DWORD*
if (ptStash->name) if (ptStash->name)
{ {
int size = strlen(ptStash->name); int size = strlen(ptStash->name);
if (size > 15) size = 15; if (size > 20) size = 20;
strncpy((char*)DATA, ptStash->name, size); strncpy((char*)DATA, ptStash->name, size);
*curSize += size; *curSize += size;
} }
@ -376,7 +423,7 @@ void saveStashList(Unit* ptChar, Stash* ptStash, BYTE** data, DWORD* maxSize, DW
while(ptStash) while(ptStash)
{ {
if (*curSize + 0x2000 > *maxSize) if (*curSize + saveFileStackSize > *maxSize)
{ {
BYTE* oldData = *data; BYTE* oldData = *data;
*maxSize *= 2; *maxSize *= 2;
@ -393,21 +440,22 @@ void saveStashList(Unit* ptChar, Stash* ptStash, BYTE** data, DWORD* maxSize, DW
} }
/////// client /////// client
void updateSelectedStashClient(Unit* ptChar)//WORKS void updateSelectedStashClient(Unit* ptChar)
{ {
Stash* newStash = PCPY->currentStash; Stash* newStash = PCPY->currentStash;
if (!newStash)
return;
updateClient(ptChar, UC_SELECT_STASH, newStash->id, newStash->flags, PCPY->flags); updateClient(ptChar, UC_SELECT_STASH, newStash->id, newStash->flags, PCPY->flags);
updateClient(ptChar, UC_PAGE_NAME, newStash->name); updateClient(ptChar, UC_PAGE_NAME, newStash->name);
} }
void setSelectedStashClient(DWORD stashId, DWORD stashFlags, DWORD flags, bool bOnlyItems)//WORKS void setSelectedStashClient(DWORD stashId, DWORD stashFlags, DWORD flags, bool bOnlyItems)
{ {
log_msg("setSelectedStashClient ID:%d, stashFlags:%d, flags:%08X\n", stashId, stashFlags, flags); log_msg("setSelectedStashClient ID:%d, stashFlags:%d, flags:%08X\n", stashId, stashFlags, flags);
Unit* ptChar = D2GetClientPlayer(); Unit* ptChar = D2GetClientPlayer();
Stash* newStash = getStash(ptChar, (stashFlags & 1) == 1, stashId); Stash* newStash = getStash(ptChar, (stashFlags & 1) == 1, stashId);
if (!newStash) do if (!newStash) do
newStash = addStash(ptChar, (stashFlags & 1) == 1); newStash = addStash(ptChar, (stashFlags & 1) == 1, false, newStash);
while (newStash->id < stashId); while (newStash->id < stashId);
newStash->flags = stashFlags; newStash->flags = stashFlags;
changeToSelectedStash(ptChar, newStash, bOnlyItems, 1); changeToSelectedStash(ptChar, newStash, bOnlyItems, 1);
@ -415,8 +463,13 @@ void setSelectedStashClient(DWORD stashId, DWORD stashFlags, DWORD flags, bool b
} }
void selectStash(Unit* ptChar, Stash* newStash)//WORKS void selectStash(Unit* ptChar, Stash* newStash, bool forceUpdate)
{ {
if (!newStash)
return;
if (!forceUpdate && newStash == PCPY->currentStash)
return;
log_msg("selectStash ID:%d\tshared:%d\tforceUpdate:%d\n", newStash->id, newStash->isShared, forceUpdate);
changeToSelectedStash(ptChar, newStash, 0, 0); changeToSelectedStash(ptChar, newStash, 0, 0);
updateSelectedStashClient(ptChar); updateSelectedStashClient(ptChar);
} }
@ -446,10 +499,11 @@ void toggleToSharedStash(Unit* ptChar)
void swapStash(Unit* ptChar, Stash* curStash, Stash* swpStash) void swapStash(Unit* ptChar, Stash* curStash, Stash* swpStash)
{ {
log_msg("swapStash ID:%d\tshared:%d\tonlyItems:%d\tclient:%d\n", swpStash->id, swpStash->isShared, 1, 0);
if (!ptChar || !curStash || !swpStash || curStash == swpStash) if (!ptChar || !curStash || !swpStash || curStash == swpStash)
return; return;
changeToSelectedStash(ptChar, swpStash, 1, 0); changeToSelectedStash(ptChar, swpStash, 1, 0);
updateClient(ptChar, UC_SELECT_STASH, swpStash->id, swpStash->flags | 4, PCPY->flags); updateClient(ptChar, UC_SELECT_STASH, swpStash->id, swpStash->flags | 8, PCPY->flags);
} }
void toggleStash(Unit* ptChar, DWORD page) void toggleStash(Unit* ptChar, DWORD page)
@ -462,13 +516,16 @@ void toggleStash(Unit* ptChar, DWORD page)
void swapStash(Unit* ptChar, DWORD page, bool toggle) void swapStash(Unit* ptChar, DWORD page, bool toggle)
{ {
log_msg("swap stash page = %u\n", page); log_msg("swap stash page = %u, toggle=%u\n", page, toggle);
Stash* curStash = PCPY->currentStash; Stash* curStash = PCPY->currentStash;
Stash* swpStash = curStash->isShared == toggle ? PCPY->selfStash : PCPY->sharedStash; Stash* swpStash = curStash->isShared == toggle ? PCPY->selfStash : PCPY->sharedStash;
if (!swpStash)
swpStash = addStash(ptChar, !curStash->isShared, true, swpStash);
for (DWORD i = 0; i < page; i++) for (DWORD i = 0; i < page; i++)
{ {
if (curStash->nextStash == NULL) log_msg("swap stash : %i\n", i);
addStash(ptChar, swpStash->isShared); if (swpStash->nextStash == NULL)
addStash(ptChar, swpStash->isShared, false, swpStash);
swpStash = swpStash->nextStash; swpStash = swpStash->nextStash;
} }
swapStash(ptChar, curStash, swpStash); swapStash(ptChar, curStash, swpStash);
@ -477,21 +534,21 @@ void swapStash(Unit* ptChar, DWORD page, bool toggle)
void insertStash(Unit* ptChar) void insertStash(Unit* ptChar)
{ {
Stash* curStash = PCPY->currentStash; Stash* curStash = PCPY->currentStash;
Stash* stash = addStash(ptChar, curStash->isShared); Stash* stash = addStash(ptChar, curStash->isShared, false, curStash);
do while (stash->previousStash != curStash)
{ {
stash->flags = stash->previousStash->flags; stash->flags = stash->previousStash->flags;
stash->name = stash->previousStash->name; stash->name = stash->previousStash->name;
stash->ptListItem = stash->previousStash->ptListItem; stash->ptListItem = stash->previousStash->ptListItem;
stash = stash->previousStash; stash = stash->previousStash;
} while (stash != curStash); }
stash->isIndex = 0; stash->isIndex = 0;
stash->isMainIndex = 0;
stash->name = NULL; stash->name = NULL;
stash->ptListItem = NULL; stash->ptListItem = NULL;
selectNextStash(ptChar);
} }
bool deleteStash(Unit* ptChar) bool deleteStash(Unit* ptChar, bool isClient)
{ {
if (firstClassicStashItem(ptChar) != NULL) if (firstClassicStashItem(ptChar) != NULL)
return false; return false;
@ -500,21 +557,27 @@ bool deleteStash(Unit* ptChar)
if (stash->nextStash == NULL) if (stash->nextStash == NULL)
{ {
stash->isIndex = 0; stash->isIndex = 0;
stash->isMainIndex = 0;
stash->name = NULL; stash->name = NULL;
return true; return true;
} }
stash->flags = stash->nextStash->flags; stash->flags = stash->nextStash->flags;
stash->name = stash->nextStash->name; stash->name = stash->nextStash->name;
if (stash->nextStash->ptListItem != NULL) if (stash->nextStash->ptListItem != NULL)
swapStash(ptChar, stash, stash->nextStash); {
log_msg("deleteStash ID:%d\tshared:%d\tonlyItems:%d\tclient:%d\n", stash->id, stash->isShared, 1, isClient);
changeToSelectedStash(ptChar, stash->nextStash, 1, isClient);
}
stash = stash->nextStash; stash = stash->nextStash;
do { while (stash->nextStash)
{
stash->flags = stash->nextStash->flags; stash->flags = stash->nextStash->flags;
stash->name = stash->nextStash->name; stash->name = stash->nextStash->name;
stash->ptListItem = stash->nextStash->ptListItem; stash->ptListItem = stash->nextStash->ptListItem;
stash = stash->nextStash; stash = stash->nextStash;
} while (stash->nextStash); }
stash->isIndex = 0; stash->isIndex = 0;
stash->isMainIndex = 0;
stash->name = NULL; stash->name = NULL;
stash->ptListItem = NULL; stash->ptListItem = NULL;
return true; return true;
@ -523,30 +586,29 @@ bool deleteStash(Unit* ptChar)
void renameCurrentStash(Unit* ptChar, char* name) void renameCurrentStash(Unit* ptChar, char* name)
{ {
log_msg("renameCurrentStash : %08X, %s\n", ptChar, name); log_msg("renameCurrentStash : '%s'\n", name);
Stash* stash = PCPY->currentStash; Stash* stash = PCPY->currentStash;
int len = 0; int len = 0;
if (name != NULL) if (name != NULL)
len = strlen(name); len = strlen(name);
log_msg("renameCurrentStash : %d\n", len);
if (stash->name) if (stash->name)
D2FogMemDeAlloc(stash->name, __FILE__, __LINE__, 0); D2FogMemDeAlloc(stash->name, __FILE__, __LINE__, 0);
log_msg("renameCurrentStash 3\n");
if (len > 0) if (len > 0)
{ {
stash->name = (char *)malloc(len);//D2FogMemAlloc(len,__FILE__,__LINE__,0); stash->name = (char *)malloc(len + 1);//D2FogMemAlloc(len,__FILE__,__LINE__,0);
strcpy(stash->name, name); strcpy(stash->name, name);
} }
else else
stash->name = NULL; stash->name = NULL;
log_msg("renameCurrentStash 4\n");
} }
void setCurrentStashIndex(Unit* ptChar, bool isIndex) void setCurrentStashIndex(Unit* ptChar, int index)
{ {
if (PCPY->currentStash) if (!PCPY->currentStash)
PCPY->currentStash->isIndex = isIndex; return;
PCPY->currentStash->isIndex = index >= 1;
PCPY->currentStash->isMainIndex = index == 2;
updateSelectedStashClient(ptChar); updateSelectedStashClient(ptChar);
} }
@ -572,7 +634,7 @@ void selectNextStash(Unit* ptChar)
if (!selStash->isShared && (selStash->id >= maxSelfPages)) return; if (!selStash->isShared && (selStash->id >= maxSelfPages)) return;
if (selStash->isShared && (selStash->id >= maxSharedPages)) return; if (selStash->isShared && (selStash->id >= maxSharedPages)) return;
selStash = selStash->nextStash ? selStash->nextStash : addStash(ptChar, PCPY->showSharedStash); selStash = selStash->nextStash ? selStash->nextStash : addStash(ptChar, PCPY->showSharedStash, true, selStash);
if (selStash && (selStash != PCPY->currentStash)) if (selStash && (selStash != PCPY->currentStash))
selectStash(ptChar, selStash); selectStash(ptChar, selStash);
@ -617,8 +679,15 @@ void selectPreviousIndex2Stash(Unit* ptChar)
{ {
selectPreviousStash(ptChar); selectPreviousStash(ptChar);
Stash* selStash = PCPY->currentStash; Stash* selStash = PCPY->currentStash;
while (selStash && !selStash->isMainIndex)
selStash = selStash->previousStash;
if (selStash == NULL)
{
selStash = PCPY->currentStash;
while (selStash->previousStash && ((selStash->id+1) % nbPagesPerIndex2 != 0)) while (selStash->previousStash && ((selStash->id+1) % nbPagesPerIndex2 != 0))
selStash = selStash->previousStash; selStash = selStash->previousStash;
}
if (selStash && (selStash != PCPY->currentStash)) if (selStash && (selStash != PCPY->currentStash))
selectStash(ptChar, selStash); selectStash(ptChar, selStash);
@ -638,7 +707,7 @@ void selectNextIndexStash(Unit* ptChar)
{ {
if (!selStash->isShared && (selStash->id >= maxSelfPages)) break; if (!selStash->isShared && (selStash->id >= maxSelfPages)) break;
if (selStash->isShared && (selStash->id >= maxSharedPages)) break; if (selStash->isShared && (selStash->id >= maxSharedPages)) break;
selStash = selStash->nextStash ? selStash->nextStash : addStash(ptChar, PCPY->showSharedStash);; selStash = selStash->nextStash ? selStash->nextStash : addStash(ptChar, PCPY->showSharedStash, true, selStash);
} }
} }
if (selStash && (selStash != PCPY->currentStash)) if (selStash && (selStash != PCPY->currentStash))
@ -649,16 +718,142 @@ void selectNextIndex2Stash(Unit* ptChar)
{ {
selectNextStash(ptChar); selectNextStash(ptChar);
Stash* selStash = PCPY->currentStash; Stash* selStash = PCPY->currentStash;
while (selStash && !selStash->isMainIndex)
selStash = selStash->nextStash;
if (selStash == NULL)
{
selStash = PCPY->currentStash;
while ((selStash->id+1) % nbPagesPerIndex2 != 0) while ((selStash->id+1) % nbPagesPerIndex2 != 0)
{ {
if (!selStash->isShared && (selStash->id >= maxSelfPages)) break; if (!selStash->isShared && (selStash->id >= maxSelfPages)) break;
if (selStash->isShared && (selStash->id >= maxSharedPages)) break; if (selStash->isShared && (selStash->id >= maxSharedPages)) break;
selStash = selStash->nextStash ? selStash->nextStash : addStash(ptChar, PCPY->showSharedStash);; selStash = selStash->nextStash ? selStash->nextStash : addStash(ptChar, PCPY->showSharedStash, true, selStash);
}
} }
if (selStash && (selStash != PCPY->currentStash)) if (selStash && (selStash != PCPY->currentStash))
selectStash(ptChar, selStash); selectStash(ptChar, selStash);
} }
WCHAR* getDefaultStashName(Unit* ptChar)
{
if (!autoRenameStashPage)
return getLocalString( PCPY->currentStash->isShared ? STR_SHARED_PAGE_NUMBER : STR_PERSONAL_PAGE_NUMBER);
int onlyOneUnique = -1;
int uniqueNameIndex = -1;
int onlyOneSet = -1;
int setNameIndex = -1;
int onlyOneMisc = -1;
int miscNameIndex = -1;
Unit* ptItem = D2InventoryGetFirstItem(PCInventory);
int nb = 0;
while (ptItem)
{
if (D2ItemGetPage(ptItem) == 4)
{
if (onlyOneUnique != 0)
{
if (ptItem->ptItemData->quality != ITEMQUALITY_UNIQUE)
{
onlyOneUnique = 0;
uniqueNameIndex = -1;
}
else
{
int uniqueId = D2GetUniqueID(ptItem);
UniqueItemsBIN* uniqueBIN = SgptDataTables->uniqueItems + uniqueId;
if (onlyOneUnique < 0)
{
onlyOneUnique = 1;
uniqueNameIndex = uniqueBIN->uniqueNameId;
}
else if (setNameIndex != uniqueBIN->uniqueNameId)
{
onlyOneUnique = 0;
uniqueNameIndex = -1;
}
}
}
if (onlyOneSet != 0)
{
if (ptItem->ptItemData->quality != ITEMQUALITY_SET)
{
onlyOneSet = 0;
setNameIndex = -1;
}
else
{
int uniqueID = ptItem->ptItemData->uniqueID;
SetItemsBIN* itemBIN = &SgptDataTables->setItems[uniqueID];
SetsBIN* setBIN = &SgptDataTables->sets[itemBIN->setId];
if (onlyOneSet < 0)
{
onlyOneSet = 1;
setNameIndex = setBIN->setNameIndex;
}
else if (setNameIndex != setBIN->setNameIndex)
{
onlyOneSet = 0;
setNameIndex = -1;
}
}
}
if (onlyOneMisc != 0)
{
if (ptItem->ptItemData->quality != ITEMQUALITY_NORMAL)
{
onlyOneMisc = 0;
miscNameIndex = -1;
}
else
{
ItemsBIN* ptItemsBin = D2GetItemsBIN(ptItem->nTxtFileNo);
if (onlyOneMisc < 0)
{
onlyOneMisc = 1;
miscNameIndex = ptItemsBin->NameStr;
}
else if (miscNameIndex != ptItemsBin->NameStr)
{
onlyOneMisc = 0;
miscNameIndex = -1;
}
}
}
}
ptItem = D2UnitGetNextItem(ptItem);
}
if (onlyOneUnique == 1 && uniqueNameIndex >= 0)
return StripGender(D2GetStringFromIndex(uniqueNameIndex));
if (onlyOneSet == 1 && setNameIndex >= 0)
return StripGender(D2GetStringFromIndex(setNameIndex));
if (onlyOneMisc == 1 && miscNameIndex >= 0)
return StripGender(D2GetStringFromIndex(miscNameIndex));
return getLocalString( PCPY->currentStash->isShared ? STR_SHARED_PAGE_NUMBER : STR_PERSONAL_PAGE_NUMBER);
}
void getCurrentStashName(WCHAR* buffer, DWORD maxSize, Unit* ptChar)
{
if (PCPY->currentStash->name && PCPY->currentStash->name[0])
{
mbstowcs(buffer, PCPY->currentStash->name, maxSize - 1);
}
else
{
wcsncpy(buffer, getDefaultStashName(ptChar), maxSize - 1);;
}
buffer[20] = NULL;
}
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
Stash* curStash2; Stash* curStash2;
DWORD currentSawStash2; DWORD currentSawStash2;
@ -724,7 +919,7 @@ DWORD STDCALL carry1Limit(Unit* ptChar, Unit* ptItemParam, DWORD itemNum, BYTE p
{ {
if (!ptChar) return 0; if (!ptChar) return 0;
Unit* ptItem = ptItemParam ? ptItemParam : D2GameGetObject(PCGame, UNIT_ITEM, itemNum); Unit* ptItem = ptItemParam ? ptItemParam : D2GameGetObject(PCGame, UNIT_ITEM, itemNum);
if ((page != 4) && (D2GetItemQuality(ptItem) == 7) && ptChar) if ((page != 4) && (D2GetItemQuality(ptItem) == ITEMQUALITY_UNIQUE) && ptChar)
{ {
int uniqueID = D2GetUniqueID(ptItem); int uniqueID = D2GetUniqueID(ptItem);
if ((uniqueID>=0) && (uniqueID < (int)SgptDataTables->nbUniqueItems)) if ((uniqueID>=0) && (uniqueID < (int)SgptDataTables->nbUniqueItems))
@ -742,6 +937,26 @@ DWORD STDCALL carry1Limit(Unit* ptChar, Unit* ptItemParam, DWORD itemNum, BYTE p
return 0; return 0;
} }
FCT_ASM ( caller_carry1Limit_114 )
PUSH DWORD PTR SS:[ESP+0x08]//page
PUSH 0//EDI
PUSH DWORD PTR SS:[ESP+0x0C]
PUSH ESI//ptChar
CALL carry1Limit
TEST EAX,EAX
JNZ end_carry1Limit
JMP D2ItemSetPage
end_carry1Limit:
ADD ESP,0xC
XOR EAX,EAX
POP EDI
POP EBX
POP ESI
MOV ESP,EBP
POP EBP
RETN 8
}}
FCT_ASM ( caller_carry1Limit_111 ) FCT_ASM ( caller_carry1Limit_111 )
PUSH DWORD PTR SS:[ESP+0x08]//page PUSH DWORD PTR SS:[ESP+0x08]//page
PUSH 0//EDI PUSH 0//EDI
@ -781,6 +996,26 @@ end_carry1Limit:
RETN 8 RETN 8
}} }}
FCT_ASM ( caller_carry1LimitSwap_114 )
PUSH EAX
PUSH DWORD PTR SS:[ESP+0x20]
PUSH 0
PUSH EDI//ptChar
CALL carry1Limit
TEST EAX,EAX
JNZ end_carry1Limit
JMP D2ItemGetPage
end_carry1Limit:
ADD ESP,8
XOR EAX,EAX
POP EBX
POP EDI
POP ESI
MOV ESP, EBP
POP EBP
RETN 8
}}
FCT_ASM ( caller_carry1LimitSwap_112 ) FCT_ASM ( caller_carry1LimitSwap_112 )
PUSH EAX PUSH EAX
PUSH DWORD PTR SS:[ESP+0x1C] PUSH DWORD PTR SS:[ESP+0x1C]
@ -858,6 +1093,20 @@ END_carry1LimitWhenDrop:
RETN RETN
}}*/ }}*/
FCT_ASM ( caller_carry1LimitWhenDrop_114 )
PUSH 0
PUSH 0
PUSH DWORD PTR SS:[ESP+0x10] //ptItem
PUSH EBX //ptChar
CALL carry1Limit
TEST EAX,EAX
JNZ end_carry1Limit
JMP D2CanPutItemInInv
end_carry1Limit:
XOR EAX,EAX
RETN 0x1C
}}
FCT_ASM ( caller_carry1LimitWhenDrop_111 ) FCT_ASM ( caller_carry1LimitWhenDrop_111 )
PUSH 0 PUSH 0
PUSH 0 PUSH 0
@ -903,6 +1152,20 @@ END_carry1LimitWhenDrop:
RETN RETN
}} }}
FCT_ASM ( caller_carry1OutOfStash_114 )
PUSH ESI
CALL D2ItemGetPage
CMP AL,4
JNZ continue_carry1OutOfStash
//SUB DWORD PTR SS:[ESP],0xC
ADD DWORD PTR SS:[ESP],0x17D
RETN
continue_carry1OutOfStash:
MOV EDI,DWORD PTR SS:[EBP-4]
TEST EDI,EDI
RETN
}}
FCT_ASM ( caller_carry1OutOfStash_111 ) FCT_ASM ( caller_carry1OutOfStash_111 )
PUSH EDI PUSH EDI
CALL D2ItemGetPage CALL D2ItemGetPage
@ -945,48 +1208,51 @@ void Install_MultiPageStash()
log_msg("Patch D2Game for carry1 unique item. (MultiPageStash)\n"); log_msg("Patch D2Game for carry1 unique item. (MultiPageStash)\n");
// Cannot put 2 items carry1 in inventory // Cannot put 2 items carry1 in inventory
mem_seek R7(D2Game, 0000, 0000, 55050, 57CA3, 2FE63, 99B03, CF1E3, 6B013); mem_seek R8(D2Game, 0000, 0000, 55050, 57CA3, 2FE63, 99B03, CF1E3, 6B013, 14AC7F);
MEMJ_REF4( D2ItemSetPage , version_D2Game >= V111 ? caller_carry1Limit_111 : caller_carry1Limit); MEMJ_REF4( D2ItemSetPage , version_D2Game >= V114d ? caller_carry1Limit_114 : version_D2Game >= V111 ? caller_carry1Limit_111 : caller_carry1Limit);
//6FC8504F . E8 94670900 CALL <JMP.&D2Common.#10720> //6FC8504F . E8 94670900 CALL <JMP.&D2Common.#10720>
//01FD7CA2 . E8 6329FBFF CALL <JMP.&D2Common.#10485> //01FD7CA2 . E8 6329FBFF CALL <JMP.&D2Common.#10485>
//01F9FE62 . E8 47A8FDFF CALL <JMP.&D2Common.#10608> //01F9FE62 . E8 47A8FDFF CALL <JMP.&D2Common.#10608>
//6FCB9B02 . E8 9709F7FF CALL <JMP.&D2Common.#10223> //6FCB9B02 . E8 9709F7FF CALL <JMP.&D2Common.#10223>
//6FCEF1E2 . E8 47B7F3FF CALL <JMP.&D2Common.#10012> //6FCEF1E2 . E8 47B7F3FF CALL <JMP.&D2Common.#10012>
//6FC8B012 . E8 13F7F9FF CALL <JMP.&D2Common.#11026> //6FC8B012 . E8 13F7F9FF CALL <JMP.&D2Common.#11026>
//0054AC7E |. E8 FDD50D00 CALL Game.00628280 ; \Game.00628280
// Cannot put 2 items carry1 in inventory by swapping // Cannot put 2 items carry1 in inventory by swapping
mem_seek R7(D2Game, 0000, 0000, 558D9, 58968, 310E8, 9B6E8, D10C8, 6BC78); mem_seek R8(D2Game, 0000, 0000, 558D9, 58968, 310E8, 9B6E8, D10C8, 6BC78, 14B179);
MEMJ_REF4( D2ItemGetPage , version_D2Game >= V112 ? caller_carry1LimitSwap_112 : version_D2Game >= V111 ? caller_carry1LimitSwap_111 : caller_carry1LimitSwap); MEMJ_REF4( D2ItemGetPage , version_D2Game >= V114d ? caller_carry1LimitSwap_114 : version_D2Game >= V112 ? caller_carry1LimitSwap_112 : version_D2Game >= V111 ? caller_carry1LimitSwap_111 : caller_carry1LimitSwap);
//6FC858D8 . E8 175F0900 CALL <JMP.&D2Common.#10719> //6FC858D8 . E8 175F0900 CALL <JMP.&D2Common.#10719>
//01FD8967 . E8 8E1DFBFF CALL <JMP.&D2Common.#10820> //01FD8967 . E8 8E1DFBFF CALL <JMP.&D2Common.#10820>
//01FA10E7 . E8 9A96FDFF CALL <JMP.&D2Common.#10505> //01FA10E7 . E8 9A96FDFF CALL <JMP.&D2Common.#10505>
//6FCBB6E7 . E8 CAEDF6FF CALL <JMP.&D2Common.#10370> //6FCBB6E7 . E8 CAEDF6FF CALL <JMP.&D2Common.#10370>
//6FCF10C7 . E8 F895F3FF CALL <JMP.&D2Common.#10020> //6FCF10C7 . E8 F895F3FF CALL <JMP.&D2Common.#10020>
//6FC8BC77 . E8 22E9F9FF CALL <JMP.&D2Common.#10810> //6FC8BC77 . E8 22E9F9FF CALL <JMP.&D2Common.#10810>
//0054B178 |. E8 D3D00D00 CALL Game.00628250 ; \Game.00628250
if ( version_D2Game >= V111 ) if ( version_D2Game >= V111 )
{ {
// Cannot put 2 items carry1 in inventory when drop cube // Cannot put 2 items carry1 in inventory when drop cube
mem_seek R7(D2Game, 0000, 0000, 0000, 3D935, 49FD5, 17AD5, D7B75, B7B15); mem_seek R8(D2Game, 0000, 0000, 0000, 3D935, 49FD5, 17AD5, D7B75, B7B15, 163A89);
MEMJ_REF4( D2CanPutItemInInv , caller_carry1LimitWhenDrop_111); MEMJ_REF4( D2CanPutItemInInv , version_D2Game >= V114d ? caller_carry1LimitWhenDrop_114 : caller_carry1LimitWhenDrop_111);
//01FBD934 |. E8 5BD3FCFF |CALL <JMP.&D2Common.#10855> //01FBD934 |. E8 5BD3FCFF |CALL <JMP.&D2Common.#10855>
//01FB9FD4 |. E8 3912FCFF |CALL <JMP.&D2Common.#10813> //01FB9FD4 |. E8 3912FCFF |CALL <JMP.&D2Common.#10813>
//6FC37AD4 |. E8 0535FFFF |CALL <JMP.&D2Common.#10289> //6FC37AD4 |. E8 0535FFFF |CALL <JMP.&D2Common.#10289>
//6FCF7B74 |. E8 232FF3FF |CALL <JMP.&D2Common.#10133> //6FCF7B74 |. E8 232FF3FF |CALL <JMP.&D2Common.#10133>
//6FCD7B14 |. E8 7D32F5FF |CALL <JMP.&D2Common.#10402> //6FCD7B14 |. E8 7D32F5FF |CALL <JMP.&D2Common.#10402>
//00563A88 . E8 C37E0D00 CALL Game.0063B950 ; \Game.0063B950
} else { } else {
// Cannot put 2 items carry1 in inventory when drop cube // Cannot put 2 items carry1 in inventory when drop cube
mem_seek R7(D2Game, 0000, 0000, 14341, 0000, 0000, 0000, 0000, 0000); mem_seek R8(D2Game, 0000, 0000, 14341, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0xBA ,0xE8); memt_byte( 0xBA ,0xE8);
MEMT_REF4( 0x00000806 , caller_carry1LimitWhenDrop); MEMT_REF4( 0x00000806 , caller_carry1LimitWhenDrop);
//6FC44341 |. BA 06080000 |MOV EDX,806 //6FC44341 |. BA 06080000 |MOV EDX,806
} }
// Verif only carry1 out of stash page when pick up an item // Verif only carry1 out of stash page when pick up an item
mem_seek R7(D2Game, 0000, 0000, 1299E, 38E3B, 43F0B, 1209B, D211B, B301B); mem_seek R8(D2Game, 0000, 0000, 1299E, 38E3B, 43F0B, 1209B, D211B, B301B, 15CADD);
memt_byte( 0x8B ,0xE8); memt_byte( 0x8B ,0xE8);
MEMT_REF4( version_D2Game >= V111 ? 0x850C2474 : 0x85102444 , version_D2Game >= V111 ? caller_carry1OutOfStash_111 : caller_carry1OutOfStash); MEMT_REF4( version_D2Game >= V114d ? 0xFF85FC7D : version_D2Game >= V111 ? 0x850C2474 : 0x85102444 , version_D2Game >= V114d ? caller_carry1OutOfStash_114 : version_D2Game >= V111 ? caller_carry1OutOfStash_111 : caller_carry1OutOfStash);
memt_byte( version_D2Game >= V111 ? 0xF6 : 0xC0 ,0x90); if (version_D2Game < V114d) memt_byte( version_D2Game >= V111 ? 0xF6 : 0xC0 ,0x90);
//6FC4299E |. 8B4424 10 |MOV EAX,DWORD PTR SS:[ESP+10] //6FC4299E |. 8B4424 10 |MOV EAX,DWORD PTR SS:[ESP+10]
//6FC429A2 |. 85C0 |TEST EAX,EAX //6FC429A2 |. 85C0 |TEST EAX,EAX
//01FB8E3B |. 8B7424 0C |MOV ESI,DWORD PTR SS:[ESP+C] //01FB8E3B |. 8B7424 0C |MOV ESI,DWORD PTR SS:[ESP+C]
@ -999,6 +1265,8 @@ void Install_MultiPageStash()
//6FCF211F |. 85F6 |TEST ESI,ESI //6FCF211F |. 85F6 |TEST ESI,ESI
//6FCD301B |. 8B7424 0C |MOV ESI,DWORD PTR SS:[ESP+C] //6FCD301B |. 8B7424 0C |MOV ESI,DWORD PTR SS:[ESP+C]
//6FCD301F |. 85F6 |TEST ESI,ESI //6FCD301F |. 85F6 |TEST ESI,ESI
//0055CADD |> 8B7D FC |MOV EDI,DWORD PTR SS:[EBP-4]
//0055CAE0 |. 85FF |TEST EDI,EDI
log_msg("\n"); log_msg("\n");
} }

49
PlugY/Interface_Skills.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Interface functions Interface functions
@ -15,7 +16,7 @@
int posXUnassignSkillBtn=-1; int posXUnassignSkillBtn=-1;
int posYUnassignSkillBtn=-1; int posYUnassignSkillBtn=-1;
DWORD btnSkillIsDown; DWORD btnSkillIsDown=0;
DWORD getXSkillBtn() {return RX(posXUnassignSkillBtn<0? 0x243 : posXUnassignSkillBtn);} DWORD getXSkillBtn() {return RX(posXUnassignSkillBtn<0? 0x243 : posXUnassignSkillBtn);}
#define getLSkillBtn() 32 #define getLSkillBtn() 32
DWORD getYSkillBtn() {return RY(posYUnassignSkillBtn<0 ? 0x1B1 : posYUnassignSkillBtn);} DWORD getYSkillBtn() {return RY(posYUnassignSkillBtn<0 ? 0x1B1 : posYUnassignSkillBtn);}
@ -45,12 +46,13 @@ Unit* STDCALL skillsPageMouseDown(sWinMessage* msg)
{ {
Unit* ptChar = D2GetClientPlayer(); Unit* ptChar = D2GetClientPlayer();
if ( active_SkillsPoints && !onRealm && D2isLODGame() && isOnButtonUnassignSkill(D2GetMouseX(),D2GetMouseY())) if (active_SkillsPoints && !onRealm && D2isLODGame() && isOnButtonUnassignSkill(D2GetMouseX(),D2GetMouseY()))
{ {
log_msg("push down left button unassign skill\n"); log_msg("push down left button unassign skill\n");
btnSkillIsDown = 1; //btnSkillIsDown = 1;
D2PlaySound(4,0,0,0,0); D2PlaySound(4,0,0,0,0);
freeMessage(msg); freeMessage(msg);
updateServer(US_UNASSIGN_SKILLS);
return NULL; return NULL;
} }
return ptChar; return ptChar;
@ -59,7 +61,7 @@ Unit* STDCALL skillsPageMouseDown(sWinMessage* msg)
void STDCALL skillsPageMouseUp() void STDCALL skillsPageMouseUp()
{ {
if ( active_SkillsPoints && !onRealm && D2isLODGame() && isOnButtonUnassignSkill(D2GetMouseX(),D2GetMouseY())) if (active_SkillsPoints && !onRealm && D2isLODGame() && isOnButtonUnassignSkill(D2GetMouseX(),D2GetMouseY()))
{ {
log_msg("push up left button unassign skill\n"); log_msg("push up left button unassign skill\n");
if (btnSkillIsDown) if (btnSkillIsDown)
@ -88,6 +90,17 @@ FCT_ASM ( caller_printSkillsPageBtns )
RETN RETN
}} }}
FCT_ASM ( caller_DontPrintSkillPointsRemaining_114 )
MOV AL,BYTE PTR DS:[onRealm]
TEST AL,AL
JNZ dontPrint
ADD DWORD PTR SS:[ESP],0x97
RETN
dontPrint:
MOV ECX,0x1083
RETN
}}
FCT_ASM ( caller_DontPrintSkillPointsRemaining_111 ) FCT_ASM ( caller_DontPrintSkillPointsRemaining_111 )
MOV AL,BYTE PTR DS:[onRealm] MOV AL,BYTE PTR DS:[onRealm]
TEST AL,AL TEST AL,AL
@ -110,6 +123,12 @@ dontPrint:
RETN RETN
}} }}
FCT_ASM ( caller_skillsPageMouseDown_114 )
PUSH ESI
CALL skillsPageMouseDown
RETN
}}
FCT_ASM ( caller_skillsPageMouseDown_111 ) FCT_ASM ( caller_skillsPageMouseDown_111 )
PUSH EBP PUSH EBP
CALL skillsPageMouseDown CALL skillsPageMouseDown
@ -139,7 +158,7 @@ void Install_InterfaceSkills()
log_msg("Patch D2Client for skills interface. (InterfaceSkills)\n"); log_msg("Patch D2Client for skills interface. (InterfaceSkills)\n");
// Print new buttons images // Print new buttons images
mem_seek R7(D2Client, 7AC20, 7AC20, 77073, 16190, 8A9C0, 7F320, 77F20, 2F380); mem_seek R8(D2Client, 7AC20, 7AC20, 77073, 16190, 8A9C0, 7F320, 77F20, 2F380, AB7A5);
memt_byte( 0x5F, 0xE9 ); // JMP caller_printBtns memt_byte( 0x5F, 0xE9 ); // JMP caller_printBtns
if ( version_D2Client >= V111 ) { if ( version_D2Client >= V111 ) {
MEMT_REF4( 0xCCC35B5E, caller_printSkillsPageBtns_111); MEMT_REF4( 0xCCC35B5E, caller_printSkillsPageBtns_111);
@ -168,6 +187,11 @@ void Install_InterfaceSkills()
//6FADF382 |. 5B POP EBX //6FADF382 |. 5B POP EBX
//6FADF383 \. C3 RETN //6FADF383 \. C3 RETN
//6FADF384 CC INT3 //6FADF384 CC INT3
//004AB7A5 |> 5F POP EDI
//004AB7A6 |. 5E POP ESI
//004AB7A7 |. 5B POP EBX
//004AB7A8 \. C3 RETN
//004AB7A9 CC INT3
} else { } else {
MEMT_REF4( 0x835B5D5E, caller_printSkillsPageBtns); MEMT_REF4( 0x835B5D5E, caller_printSkillsPageBtns);
memt_byte( 0xC4, 0x90 ); // NOP memt_byte( 0xC4, 0x90 ); // NOP
@ -184,21 +208,22 @@ void Install_InterfaceSkills()
if (posXUnassignSkillBtn==-1 && posYUnassignSkillBtn==-1) if (posXUnassignSkillBtn==-1 && posYUnassignSkillBtn==-1)
{ {
// Don't print "Skill Points Remaining" // Don't print "Skill Points Remaining"
mem_seek R7(D2Client, 7AC30, 7AC30, 77080, 16294, 8AC74, 7ECF4, 78334, 2F7E4); mem_seek R8(D2Client, 7AC30, 7AC30, 77080, 16294, 8AC74, 7ECF4, 78334, 2F7E4, AACE0);
memt_byte( 0xB9, 0xE8 ); memt_byte( 0xB9, 0xE8 );
MEMT_REF4( 0x00001083, version_D2Client >= V111 ? caller_DontPrintSkillPointsRemaining_111 : caller_DontPrintSkillPointsRemaining); MEMT_REF4( 0x00001083, version_D2Client >= V114d ? caller_DontPrintSkillPointsRemaining_114 : version_D2Client >= V111 ? caller_DontPrintSkillPointsRemaining_111 : caller_DontPrintSkillPointsRemaining);
//6FB17080 /$ B9 83100000 MOV ECX,1083 //6FB17080 /$ B9 83100000 MOV ECX,1083
//6FAC6294 |. B9 83100000 MOV ECX,1083 //6FAC6294 |. B9 83100000 MOV ECX,1083
//6FB3AC74 |. B9 83100000 MOV ECX,1083 //6FB3AC74 |. B9 83100000 MOV ECX,1083
//6FB2ECF4 |. B9 83100000 MOV ECX,1083 //6FB2ECF4 |. B9 83100000 MOV ECX,1083
//6FB28334 |. B9 83100000 MOV ECX,1083 //6FB28334 |. B9 83100000 MOV ECX,1083
//6FADF7E4 |. B9 83100000 MOV ECX,1083 //6FADF7E4 |. B9 83100000 MOV ECX,1083
//004AACE0 /$ B9 83100000 MOV ECX,1083
} }
// Manage mouse down (Play sound) // Manage mouse down (Play sound)
mem_seek R7(D2Client, 7BBD1, 7BBD1, 780E4, 17BC2, 8C6E2, 808B2, 79C62, 31112); mem_seek R8(D2Client, 7BBD1, 7BBD1, 780E4, 17BC2, 8C6E2, 808B2, 79C62, 31112, ABC1A);
memt_byte( 0xC7, 0xE8 ); // CALL caller_skillsPageMouseDown memt_byte( 0xC7, 0xE8 ); // CALL caller_skillsPageMouseDown
MEMT_REF4( version_D2Client >= V111 ? 0x00001845 : 0x00001843, version_D2Client >= V111 ? caller_skillsPageMouseDown_111 : caller_skillsPageMouseDown); MEMT_REF4( version_D2Client >= V114d ? 0x00001846 : version_D2Client >= V111 ? 0x00001845 : 0x00001843, version_D2Client == V114d ? caller_skillsPageMouseDown_114 : version_D2Client >= V111 ? caller_skillsPageMouseDown_111 : caller_skillsPageMouseDown);
memt_byte( 0x00, 0x90 ); // NOP memt_byte( 0x00, 0x90 ); // NOP
memt_byte( 0x00, 0x90 ); // NOP memt_byte( 0x00, 0x90 ); // NOP
//6FB180E4 > C743 18 00000000 MOV DWORD PTR DS:[EBX+18],0 //6FB180E4 > C743 18 00000000 MOV DWORD PTR DS:[EBX+18],0
@ -207,9 +232,11 @@ void Install_InterfaceSkills()
//6FB308B2 > C745 18 00000000 MOV DWORD PTR SS:[EBP+18],0 //6FB308B2 > C745 18 00000000 MOV DWORD PTR SS:[EBP+18],0
//6FB29C62 > C745 18 00000000 MOV DWORD PTR SS:[EBP+18],0 //6FB29C62 > C745 18 00000000 MOV DWORD PTR SS:[EBP+18],0
//6FAE1112 > C745 18 00000000 MOV DWORD PTR SS:[EBP+18],0 //6FAE1112 > C745 18 00000000 MOV DWORD PTR SS:[EBP+18],0
//004ABC1A |> C746 18 00000000 MOV DWORD PTR DS:[ESI+18],0
/* Conflicts with D2ExpRes
// Manage mouse up // Manage mouse up
mem_seek R7(D2Client, 7BC40, 7BC40, 78466, 17558, 8C078, 80248, 795F8, 30AA8); mem_seek R8(D2Client, 7BC40, 7BC40, 78466, 17558, 8C078, 80248, 795F8, 30AA8, ABC96);
MEMJ_REF4( D2FreeWinMessage, caller_skillsPageMouseUp);//0xFFF93B0A MEMJ_REF4( D2FreeWinMessage, caller_skillsPageMouseUp);//0xFFF93B0A
//6FB18465 . E8 C07D0400 CALL <JMP.&Storm.#511> //6FB18465 . E8 C07D0400 CALL <JMP.&Storm.#511>
//6FAC7557 .^E9 4248FFFF JMP <JMP.&Storm.#511> //6FAC7557 .^E9 4248FFFF JMP <JMP.&Storm.#511>
@ -217,6 +244,8 @@ void Install_InterfaceSkills()
//6FB30247 .^E9 2CBCF8FF JMP <JMP.&Storm.#511> //6FB30247 .^E9 2CBCF8FF JMP <JMP.&Storm.#511>
//6FB295F7 .^E9 8828F9FF JMP <JMP.&Storm.#511> //6FB295F7 .^E9 8828F9FF JMP <JMP.&Storm.#511>
//6FAE0AA7 .^E9 E0B2FDFF JMP <JMP.&Storm.#511> //6FAE0AA7 .^E9 E0B2FDFF JMP <JMP.&Storm.#511>
//004ABC95 |. E8 F645F7FF CALL Game.00420290
*/
log_msg("\n"); log_msg("\n");

1044
PlugY/Interface_Stash.cpp
View File

File diff suppressed because it is too large Load Diff

98
PlugY/Interface_Stats.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Interface functions Interface functions
@ -12,6 +13,7 @@
#include "common.h" #include "common.h"
#include <stdio.h> #include <stdio.h>
/*
static struct static struct
{ {
union{ union{
@ -34,6 +36,7 @@ static struct
#define getYNextPageBtn() RY(D2GetResolution()?0x40:0x70) #define getYNextPageBtn() RY(D2GetResolution()?0x40:0x70)
#define getHNextPageBtn() 32 #define getHNextPageBtn() 32
#define isOnNextPageBtn(x,y) isOnRect(x, y, getXNextPageBtn(), getYNextPageBtn(), getLNextPageBtn(), getHNextPageBtn()) #define isOnNextPageBtn(x,y) isOnRect(x, y, getXNextPageBtn(), getYNextPageBtn(), getLNextPageBtn(), getHNextPageBtn())
*/
@ -48,7 +51,7 @@ void STDCALL printStatsPageBtns()
sDrawImageInfo data; sDrawImageInfo data;
ZeroMemory(&data,sizeof(data)); ZeroMemory(&data,sizeof(data));
if (printBackgroundOnMainPage && D2GetResolution()) if (printBackgroundOnMainPage)
{ {
setImage(&data, statsBackgroundImages); setImage(&data, statsBackgroundImages);
setFrame(&data, 1); setFrame(&data, 1);
@ -56,16 +59,14 @@ void STDCALL printStatsPageBtns()
} }
setImage(&data, D2LoadBuySelBtn()); setImage(&data, D2LoadBuySelBtn());
if (D2GetResolution())
{
setFrame(&data, 12 + isDownBtn.previousPage); setFrame(&data, 12 + isDownBtn.previousPage);
D2PrintImage(&data, getXPreviousPageBtn(), getYPreviousPageBtn(), -1, 5, 0); D2PrintImage(&data, getXPreviousPageBtn(), getYPreviousPageBtn(), -1, 5, 0);
}
setFrame(&data, 14 + isDownBtn.nextPage); setFrame(&data, 14 + isDownBtn.nextPage);
D2PrintImage(&data, getXNextPageBtn(), getYNextPageBtn(), -1, 5, 0); D2PrintImage(&data, getXNextPageBtn(), getYNextPageBtn(), -1, 5, 0);
D2SetFont(1); D2SetFont(1);
if (D2GetResolution() && isOnPreviousPageBtn(mx,my)) //print popup "previous page" if (isOnPreviousPageBtn(mx,my)) //print popup "previous page"
{ {
lpText = getLocalString(STR_PREVIOUS_PAGE); lpText = getLocalString(STR_PREVIOUS_PAGE);
D2PrintPopup(lpText, getXPreviousPageBtn()+getLPreviousPageBtn()/2, getYPreviousPageBtn()-getHPreviousPageBtn(), WHITE, 1); D2PrintPopup(lpText, getXPreviousPageBtn()+getLPreviousPageBtn()/2, getYPreviousPageBtn()-getHPreviousPageBtn(), WHITE, 1);
@ -83,6 +84,12 @@ Unit* STDCALL statsPageMouseDown(sWinMessage* msg)
if (!active_newInterfaces || !D2isLODGame() ) return ptChar; if (!active_newInterfaces || !D2isLODGame() ) return ptChar;
if (statsLeftDown(msg)) {
freeMessage(msg);
return NULL;
}
/*
if (D2GetResolution() && isOnPreviousPageBtn(msg->x,msg->y)) if (D2GetResolution() && isOnPreviousPageBtn(msg->x,msg->y))
{ {
log_msg("push down left button previous page\n"); log_msg("push down left button previous page\n");
@ -99,6 +106,7 @@ Unit* STDCALL statsPageMouseDown(sWinMessage* msg)
freeMessage(msg); freeMessage(msg);
return NULL; return NULL;
} }
*/
return ptChar; return ptChar;
} }
@ -109,6 +117,13 @@ Unit* STDCALL statsPageMouseUp(sWinMessage* msg)
if (!active_newInterfaces || !D2isLODGame() ) return ptChar; if (!active_newInterfaces || !D2isLODGame() ) return ptChar;
if (statsLeftUp(msg)) {
isDownBtn.all=0;
freeMessage(msg);
return NULL;
}
/*
if (D2GetResolution() && isOnPreviousPageBtn(msg->x,msg->y)) if (D2GetResolution() && isOnPreviousPageBtn(msg->x,msg->y))
{ {
log_msg("push up left button previous page\n"); log_msg("push up left button previous page\n");
@ -133,11 +148,22 @@ Unit* STDCALL statsPageMouseUp(sWinMessage* msg)
return NULL; return NULL;
} }
} }
*/
isDownBtn.all=0; isDownBtn.all=0;
return ptChar; return ptChar;
} }
FCT_ASM ( caller_printStatsPageBtns_114 )
CALL printStatsPageBtns
POP EDI
POP ESI
POP EBX
MOV ESP,EBP
POP EBP
RETN
}}
FCT_ASM ( caller_printStatsPageBtns_111 ) FCT_ASM ( caller_printStatsPageBtns_111 )
CALL printStatsPageBtns CALL printStatsPageBtns
POP EDI POP EDI
@ -170,6 +196,20 @@ FCT_ASM ( caller_printStatsPageBtns_9 )
}} }}
FCT_ASM ( caller_statsPageMouseDown_114 )
PUSH DWORD PTR SS:[ESP+0x18]
CALL statsPageMouseDown
TEST EAX,EAX
JE fin_statsPageMouseDown
JMP D2GetClientPlayer
fin_statsPageMouseDown:
ADD ESP,4
POP EDI
POP ESI
POP EBX
POP EBP
RETN 4
}}
FCT_ASM ( caller_statsPageMouseDown_111 ) FCT_ASM ( caller_statsPageMouseDown_111 )
PUSH DWORD PTR SS:[ESP+0x20] PUSH DWORD PTR SS:[ESP+0x20]
@ -201,6 +241,22 @@ fin_statsPageMouseDown:
RETN 4 RETN 4
}} }}
FCT_ASM ( caller_statsPageMouseUp_114 )
PUSH DWORD PTR SS:[EBP+0x8]
CALL statsPageMouseUp
TEST EAX,EAX
JE fin_statsPageMouseUp
JMP D2GetClientPlayer
fin_statsPageMouseUp:
ADD ESP,4
POP EDI
POP ESI
POP EBX
MOV ESP, EBP
POP EBP
RETN 4
}}
FCT_ASM ( caller_statsPageMouseUp ) FCT_ASM ( caller_statsPageMouseUp )
PUSH EBP PUSH EBP
CALL statsPageMouseUp CALL statsPageMouseUp
@ -244,9 +300,9 @@ void Install_InterfaceStats()
log_msg("Patch D2Client for stats interface. (InterfaceStats)\n"); log_msg("Patch D2Client for stats interface. (InterfaceStats)\n");
// Print new buttons images // Print new buttons images
mem_seek R7(D2Client, 2A7BE, 2A7AE, 30F86, 83636, 8A0B6, 6C016, BDC16, C03B6); mem_seek R8(D2Client, 2A7BE, 2A7AE, 30F86, 83636, 8A0B6, 6C016, BDC16, C03B6, A8949);
memt_byte( 0x5F, 0xE9 ); // JMP memt_byte( 0x5F, 0xE9 ); // JMP
MEMT_REF4( 0x815B5D5E, version_D2Client >= V111 ? caller_printStatsPageBtns_111: version_D2Client == V110 ? caller_printStatsPageBtns : caller_printStatsPageBtns_9); MEMT_REF4( version_D2Client >= V114d ? 0xE58B5B5E : 0x815B5D5E, version_D2Client >= V114d ? caller_printStatsPageBtns_114 : version_D2Client >= V111 ? caller_printStatsPageBtns_111: version_D2Client == V110 ? caller_printStatsPageBtns : caller_printStatsPageBtns_9);
//6FAD0F86 . 5F POP EDI //6FAD0F86 . 5F POP EDI
//6FAD0F87 . 5E POP ESI //6FAD0F87 . 5E POP ESI
//6FAD0F88 . 5D POP EBP //6FAD0F88 . 5D POP EBP
@ -282,12 +338,28 @@ void Install_InterfaceStats()
//6FB703B8 |. 5D POP EBP //6FB703B8 |. 5D POP EBP
//6FB703B9 |. 5B POP EBX //6FB703B9 |. 5B POP EBX
//6FB703BA |. 81C4 70030000 ADD ESP,370 //6FB703BA |. 81C4 70030000 ADD ESP,370
//6FB703Ñ0 \. C3 RETN //6FB703C0 \. C3 RETN
//004A8949 . 5F POP EDI
//004A894A . 5E POP ESI
//004A894B . 5B POP EBX
//004A894C . 8BE5 MOV ESP,EBP
if ( version_D2Client >= V111 ) if ( version_D2Client >= V114d )
{ {
// Manage mouse down (Play sound) // Manage mouse down (Play sound)
mem_seek R7(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, BCDC8, BF568); mem_seek R8(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, BCDC8, BF568, A77D4);
MEMC_REF4( D2GetClientPlayer, caller_statsPageMouseDown_114);
//004A77D3 . E8 F8C5FBFF CALL Game.00463DD0
// Manage mouse up
mem_seek R8(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, BDE33, C05D3, A7963);
MEMC_REF4( D2GetClientPlayer, caller_statsPageMouseUp_114);
//004A7962 |. E8 69C4FBFF CALL Game.00463DD0
}
else if ( version_D2Client >= V111 )
{
// Manage mouse down (Play sound)
mem_seek R8(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, BCDC8, BF568, A77D4);
memt_byte( 0xA1, 0xE8 ); memt_byte( 0xA1, 0xE8 );
MEMT_REF4( ptptClientChar, caller_statsPageMouseDown); MEMT_REF4( ptptClientChar, caller_statsPageMouseDown);
//6FB327C8 . A1 F0C4BC6F MOV EAX,DWORD PTR DS:[6FBCC4F0] //6FB327C8 . A1 F0C4BC6F MOV EAX,DWORD PTR DS:[6FBCC4F0]
@ -297,7 +369,7 @@ void Install_InterfaceStats()
//6FB6F568 . A1 50D0BC6F MOV EAX,DWORD PTR DS:[6FBCD050] //6FB6F568 . A1 50D0BC6F MOV EAX,DWORD PTR DS:[6FBCD050]
// Manage mouse up // Manage mouse up
mem_seek R7(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, BDE33, C05D3); mem_seek R8(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, BDE33, C05D3, A7963);
memt_byte( 0xA1, 0xE8 ); memt_byte( 0xA1, 0xE8 );
MEMT_REF4( ptptClientChar, caller_statsPageMouseUp); MEMT_REF4( ptptClientChar, caller_statsPageMouseUp);
//6FB33853 . A1 F0C4BC6F MOV EAX,DWORD PTR DS:[6FBCC4F0] //6FB33853 . A1 F0C4BC6F MOV EAX,DWORD PTR DS:[6FBCC4F0]
@ -307,12 +379,12 @@ void Install_InterfaceStats()
//6FB705D3 . A1 50D0BC6F MOV EAX,DWORD PTR DS:[6FBCD050] //6FB705D3 . A1 50D0BC6F MOV EAX,DWORD PTR DS:[6FBCD050]
} else { } else {
// Manage mouse down (Play sound) // Manage mouse down (Play sound)
mem_seek R7(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, 0000, 0000); mem_seek R8(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, BCDC8, BF568, A77D4);
MEMC_REF4( D2GetClientPlayer, caller_statsPageMouseDown); MEMC_REF4( D2GetClientPlayer, caller_statsPageMouseDown);
//6FAD133C . E8 8F700500 CALL D2Client.6FB283D0 //6FAD133C . E8 8F700500 CALL D2Client.6FB283D0
// Manage mouse up // Manage mouse up
mem_seek R7(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, 0000, 0000); mem_seek R8(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, BDE33, C05D3, A7963);
MEMC_REF4( D2GetClientPlayer, version_D2Client == V110 ? caller_statsPageMouseUp : caller_statsPageMouseUp_9);//0x00056EB2 MEMC_REF4( D2GetClientPlayer, version_D2Client == V110 ? caller_statsPageMouseUp : caller_statsPageMouseUp_9);//0x00056EB2
//6FAD1519 . E8 B26E0500 CALL D2Client.6FB283D0 //6FAD1519 . E8 B26E0500 CALL D2Client.6FB283D0
} }

21
PlugY/Language.cpp
View File

@ -1,5 +1,6 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.14d by haxifix.
Language management. Language management.
@ -10,7 +11,7 @@
#include <stdio.h> #include <stdio.h>
bool active_ChangeLanguage = true; bool active_ChangeLanguage = false;
DWORD selectedLanguage = LNG_ENG; DWORD selectedLanguage = LNG_ENG;
bool active_LanguageManagement = false; bool active_LanguageManagement = false;
@ -19,12 +20,17 @@ t_availableLanguages availableLanguages;
DWORD* ptCurrentLanguage; DWORD* ptCurrentLanguage;
DWORD STDCALL languageManagement () DWORD STDCALL languageManagement()
{ {
if (active_ChangeLanguage) *ptCurrentLanguage = selectedLanguage; if (active_ChangeLanguage)
*ptCurrentLanguage = selectedLanguage;
if (active_LanguageManagement) if (active_LanguageManagement)
if ((*ptCurrentLanguage > LNG_RUS) || !((1 << *ptCurrentLanguage) & availableLanguages.all)) {
if ((*ptCurrentLanguage >= LNG_DEF) || !((1 << *ptCurrentLanguage) & availableLanguages.all))
*ptCurrentLanguage = defaultLanguage; *ptCurrentLanguage = defaultLanguage;
}
return *ptCurrentLanguage; return *ptCurrentLanguage;
} }
@ -36,20 +42,21 @@ void Install_LanguageManagement()
log_msg("Patch D2Lang for language management. (LanguageManagement)\n"); log_msg("Patch D2Lang for language management. (LanguageManagement)\n");
ptCurrentLanguage = *(DWORD**)((DWORD)D2GetLang + (version_D2Lang >= V111 ? 0x51: 0x5C)); ptCurrentLanguage = *(DWORD**)((DWORD)D2GetLang + (version_D2Lang == V114d ? 0x4D : version_D2Lang >= V111 ? 0x51: 0x5C));
languageManagement();
// Language management // Language management
mem_seek( (DWORD)D2GetLang + (version_D2Lang >= V111 ? 0x3E : 0x49));//6FC13E39-6FC10000 mem_seek( (DWORD)D2GetLang + (version_D2Lang == V114d ? 0x4C : version_D2Lang >= V111 ? 0x3E : 0x49));//6FC13E39-6FC10000
memt_byte( 0xA1 , 0xE8); memt_byte( 0xA1 , 0xE8);
MEMT_REF4( ptCurrentLanguage, languageManagement); MEMT_REF4( ptCurrentLanguage, languageManagement);
//6FC13E39 |. A1 EC0CC26F MOV EAX,DWORD PTR DS:[6FC20CEC] //6FC13E39 |. A1 EC0CC26F MOV EAX,DWORD PTR DS:[6FC20CEC]
//003D91FE |. A1 1C0A3E00 MOV EAX,DWORD PTR DS:[3E0A1C] //003D91FE |. A1 1C0A3E00 MOV EAX,DWORD PTR DS:[3E0A1C]
//003DA0AE |. A1 1C0A3E00 MOV EAX,DWORD PTR DS:[3E0A1C] //003DA0AE |. A1 1C0A3E00 MOV EAX,DWORD PTR DS:[3E0A1C]
//0052519C |> A1 EC298800 MOV EAX,DWORD PTR DS:[8829EC]
log_msg("\n"); log_msg("\n");
isInstalled = true; isInstalled = true;
} }
/*================================= END OF FILE =================================*/ /*================================= END OF FILE =================================*/

103
PlugY/LoadPlayerData.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Load Player Custom Data. Load Player Custom Data.
@ -20,6 +21,8 @@ DWORD STDCALL LoadSPCustomData(Unit* ptChar)
BYTE* data; BYTE* data;
log_msg("--- Start LoadSPCustomData ---\n"); log_msg("--- Start LoadSPCustomData ---\n");
active_sharedStash = active_SharedStashInMultiPlayer > 0;
log_msg("active_sharedStash = %d : %d\n\n", active_sharedStash);
if (!ptChar) if (!ptChar)
{log_msg("LoadSPCustomData : ptChar == NULL\n");return 0x1B;}//Unknow failure {log_msg("LoadSPCustomData : ptChar == NULL\n");return 0x1B;}//Unknow failure
@ -37,7 +40,7 @@ DWORD STDCALL LoadSPCustomData(Unit* ptChar)
data = readExtendedSaveFile(PCPlayerData->name, &size); data = readExtendedSaveFile(PCPlayerData->name, &size);
ret = loadExtendedSaveFile(ptChar, data, size); ret = loadExtendedSaveFile(ptChar, data, size);
D2FogMemDeAlloc(data,__FILE__,__LINE__,0); D2FogMemDeAlloc(data,__FILE__,__LINE__,0);
if (!ret) if (!ret && active_sharedStash)
{ {
data = readSharedSaveFile(PCPlayerData->name, &size); data = readSharedSaveFile(PCPlayerData->name, &size);
ret = loadSharedSaveFile(ptChar, data, size); ret = loadSharedSaveFile(ptChar, data, size);
@ -51,6 +54,20 @@ DWORD STDCALL LoadSPCustomData(Unit* ptChar)
return ret; return ret;
} }
FCT_ASM (caller_LoadSPPlayerCustomData_114 )
MOV EDI,EAX
TEST EDI,EDI
JNZ JMP_LoadSPPlayerCustomData
PUSH DWORD PTR SS:[ESP+0x1C]
CALL LoadSPCustomData
MOV EDI,EAX
TEST EDI,EDI
JNZ JMP_LoadSPPlayerCustomData
RETN
JMP_LoadSPPlayerCustomData:
ADD DWORD PTR SS:[ESP],0x14
RETN
}}
FCT_ASM (caller_LoadSPPlayerCustomData ) FCT_ASM (caller_LoadSPPlayerCustomData )
MOV ESI,EAX MOV ESI,EAX
@ -92,12 +109,12 @@ return value :
13:Unable to enter game, a normal character cannot join a game create an harcore character. 13:Unable to enter game, a normal character cannot join a game create an harcore character.
14:Unable to enter game, an harcore character cannot join a game create by a normal character. 14:Unable to enter game, an harcore character cannot join a game create by a normal character.
15:A dead character cannot join or create any game 15:A dead character cannot join or create any game
16:unknow failure 16:unknown failure
17:Unable to enter game. A D2 Character cannot join an expansion character 17:Unable to enter game. A D2 Character cannot join an expansion character
18:Expansion cannot join D2 18:Expansion cannot join D2
19:Failures to join game 19:Failures to join game
1A:Unable to enter game 1A:Unable to enter game
1B:unknow failure 1B:unknown failure
*/ */
enum { enum {
TS_SAVE_PERSONAL=0, TS_SAVE_PERSONAL=0,
@ -172,31 +189,31 @@ void sendData(BYTE* data, DWORD size, bool isShared)
log_msg("\n"); log_msg("\n");
} }
static DWORD sizeExtended;
static BYTE* dataExtended;
static DWORD sizeShared;
static BYTE* dataShared;
void FASTCALL SendSaveFiles (char* ptPath, DWORD maxsize, char* name) void FASTCALL SendSaveFiles (char* ptPath, DWORD maxsize, char* name)
{ {
// DWORD size;
// BYTE* data;
D2FogGetSavePath(ptPath,maxsize); D2FogGetSavePath(ptPath,maxsize);
log_msg("\n--- Start SendSaveFiles ---\n"); log_msg("\n--- Start SendSaveFiles ---\n");
active_sharedStash = active_SharedStashInMultiPlayer == 2;
log_msg("active_sharedStash = %d : %d\n\n", active_sharedStash);
// Send Extended Save File // Send Extended Save File
log_msg("Send Extended Save File\n"); log_msg("Send Extended Save File\n");
dataExtended = readExtendedSaveFile(name, &sizeExtended); DWORD sizeExtended = 0;
BYTE* dataExtended = readExtendedSaveFile(name, &sizeExtended);
sendData(dataExtended, sizeExtended, false); sendData(dataExtended, sizeExtended, false);
D2FogMemDeAlloc(dataExtended,__FILE__,__LINE__,0); D2FogMemDeAlloc(dataExtended,__FILE__,__LINE__,0);
// Send Shared Save File // Send Shared Save File
//if (active_sharedStash)
{
log_msg("Send Shared Save File\n"); log_msg("Send Shared Save File\n");
dataShared = readSharedSaveFile(name, &sizeShared); DWORD sizeShared = 0;
BYTE* dataShared = readSharedSaveFile(name, &sizeShared);
sendData(dataShared, sizeShared, true); sendData(dataShared, sizeShared, true);
D2FogMemDeAlloc(dataShared,__FILE__,__LINE__,0); D2FogMemDeAlloc(dataShared,__FILE__,__LINE__,0);
}
// Ending load // Ending load
log_msg("End SendSaveFiles.\n\n"); log_msg("End SendSaveFiles.\n\n");
@ -209,6 +226,8 @@ DWORD STDCALL ReceiveSaveFiles (DWORD clientID, t_rcvMsg* msg)
if( (msg->packID != customPackID) || !msg->isCustom) return msg->packID; if( (msg->packID != customPackID) || !msg->isCustom) return msg->packID;
log_msg("Loading Receive Packet: clientID=%d\t type=%X\t finalSize=%X\t packSize=%02X\t data=%08X\n", clientID, msg->type, msg->finalSize, msg->packSize, msg->data); log_msg("Loading Receive Packet: clientID=%d\t type=%X\t finalSize=%X\t packSize=%02X\t data=%08X\n", clientID, msg->type, msg->finalSize, msg->packSize, msg->data);
active_sharedStash = active_SharedStashInMultiPlayer == 2;
log_msg("active_sharedStash = %d : %d\n\n", active_sharedStash);
bool isShared; bool isShared;
@ -297,6 +316,8 @@ int STDCALL ReceiveSaveFiles_9(DWORD clientID, SOCKET s, char *buf, int len, int
DWORD STDCALL LoadMPCustomData(Unit* ptChar) DWORD STDCALL LoadMPCustomData(Unit* ptChar)
{ {
log_msg("Start LoadMPCustomData\n"); log_msg("Start LoadMPCustomData\n");
active_sharedStash = active_SharedStashInMultiPlayer == 2;
log_msg("active_sharedStash = %d : %d\n\n", active_sharedStash);
if (!ptChar) return NULL; if (!ptChar) return NULL;
if (!ptChar) if (!ptChar)
@ -337,7 +358,7 @@ DWORD STDCALL LoadMPCustomData(Unit* ptChar)
log_msg("is LOD Game\n"); log_msg("is LOD Game\n");
if (!ret) if (!ret)
ret = loadExtendedSaveFile(ptChar, curSF->dataExtended, curSF->sizeExtended); ret = loadExtendedSaveFile(ptChar, curSF->dataExtended, curSF->sizeExtended);
if (!ret) if (!ret && active_sharedStash)
ret = loadSharedSaveFile(ptChar, curSF->dataShared, curSF->sizeShared); ret = loadSharedSaveFile(ptChar, curSF->dataShared, curSF->sizeShared);
} else { } else {
log_msg("is not LOD Game\n"); log_msg("is not LOD Game\n");
@ -350,6 +371,20 @@ DWORD STDCALL LoadMPCustomData(Unit* ptChar)
return ret; return ret;
} }
FCT_ASM ( caller_LoadMPPlayerCustomData_114 )
PUSH DWORD PTR SS:[EDI]
CALL LoadMPCustomData
TEST EAX,EAX
JNZ JMP_LoadMPlayerCustomData
CMP DWORD PTR DS:[EDI],0
JNZ Continue_LoadMP
ADD DWORD PTR SS:[ESP],0x1D
Continue_LoadMP:
RETN
JMP_LoadMPlayerCustomData:
SUB DWORD PTR SS:[ESP],0x10
RETN
}}
FCT_ASM ( caller_LoadMPPlayerCustomData_111 ) FCT_ASM ( caller_LoadMPPlayerCustomData_111 )
@ -413,6 +448,18 @@ FCT_ASM ( caller_SendSaveFiles )
JMP SendSaveFiles JMP SendSaveFiles
}} }}
FCT_ASM ( caller_ReceiveSaveFiles_114 )
PUSH ECX
PUSH EDX
LEA EBX,DWORD PTR DS:[ESI+4]
PUSH EBX //Message
MOV EBX,DWORD PTR SS:[ESI]
PUSH EBX //ID client
CALL ReceiveSaveFiles
POP EDX
POP ECX
RETN
}}
FCT_ASM ( caller_ReceiveSaveFiles_111 ) FCT_ASM ( caller_ReceiveSaveFiles_111 )
@ -470,15 +517,15 @@ go_to_default:
void Install_LoadPlayerData() void Install_LoadPlayerData()
{ {
static int isInstalled = false; static int isInstalled = false;
if (isInstalled || !active_PlayerCustomData) return; if (isInstalled) return;
log_msg("Patch D2Game & D2Client for load Player's custom data. (LoadPlayerData)\n"); log_msg("Patch D2Game & D2Client for load Player's custom data. (LoadPlayerData)\n");
// Load SP player custom data. // Load SP player custom data.
mem_seek R7(D2Game, 5046F, 5086F, 5CB0F, BB8ED, 278CD, 465BD, 5638D, 3BCCD); mem_seek R8(D2Game, 5046F, 5086F, 5CB0F, BB8ED, 278CD, 465BD, 5638D, 3BCCD, 13447A);
memt_byte( 0x8B, 0xE8); // CALL caller_LoadSPPlayerCustomData memt_byte( 0x8B, 0xE8); // CALL caller_LoadSPPlayerCustomData
MEMT_REF4( 0x75F685F0 , caller_LoadSPPlayerCustomData); MEMT_REF4( version_D2Game >= V114d ? 0x75FF85F8 : 0x75F685F0 , version_D2Game >= V114d ? caller_LoadSPPlayerCustomData_114 : caller_LoadSPPlayerCustomData);
memt_byte( 0x16, 0x90); // NOP memt_byte( version_D2Game >= V114d ? 0x13 : 0x16, 0x90); // NOP
//6FC8CB0F 8BF0 MOV ESI,EAX //6FC8CB0F 8BF0 MOV ESI,EAX
//6FC8CB11 85F6 TEST ESI,ESI //6FC8CB11 85F6 TEST ESI,ESI
//6FC8CB13 75 16 JNZ SHORT D2Game.6FC8CB2B //6FC8CB13 75 16 JNZ SHORT D2Game.6FC8CB2B
@ -497,11 +544,14 @@ void Install_LoadPlayerData()
//6FC5BCCD |> 8BF0 MOV ESI,EAX //6FC5BCCD |> 8BF0 MOV ESI,EAX
//6FC5BCCF |. 85F6 TEST ESI,ESI //6FC5BCCF |. 85F6 TEST ESI,ESI
//6FC5BCD1 |. 75 16 JNZ SHORT D2Game.6FC5BCE9 //6FC5BCD1 |. 75 16 JNZ SHORT D2Game.6FC5BCE9
//0053447A |. 8BF8 MOV EDI,EAX
//0053447C |. 85FF TEST EDI,EDI
//0053447E |. 75 13 JNZ SHORT Game.00534493
// Load MP player custom data. // Load MP player custom data.
mem_seek R7(D2Game, 50790, 50B90, 5CC66, BB777, 27757, 46447, 56217, 3BB57); mem_seek R8(D2Game, 50790, 50B90, 5CC66, BB777, 27757, 46447, 56217, 3BB57, 134572);
memt_byte( 0x83, 0xE8); memt_byte( 0x83, 0xE8);
MEMT_REF4( version_D2Game >= V111 ? 0x2174003B : version_D2Game == V110 ? 0x4674003F : 0x1D74003F, version_D2Game >= V111 ? caller_LoadMPPlayerCustomData_111 : version_D2Game == V110 ? caller_LoadMPPlayerCustomData: caller_LoadMPPlayerCustomData_9); MEMT_REF4( version_D2Game >= V114d ? 0x1D74003F : version_D2Game >= V111 ? 0x2174003B : version_D2Game == V110 ? 0x4674003F : 0x1D74003F, version_D2Game >= V114d ? caller_LoadMPPlayerCustomData_114 : version_D2Game >= V111 ? caller_LoadMPPlayerCustomData_111 : version_D2Game == V110 ? caller_LoadMPPlayerCustomData: caller_LoadMPPlayerCustomData_9);
//6FC8CC66 . 833F 00 CMP DWORD PTR DS:[EDI],0 //6FC8CC66 . 833F 00 CMP DWORD PTR DS:[EDI],0
//6FC8CC69 . 74 46 JE SHORT D2Game.6FC8CCB1 //6FC8CC69 . 74 46 JE SHORT D2Game.6FC8CCB1
//0203B777 |> 833B 00 CMP DWORD PTR DS:[EBX],0 //0203B777 |> 833B 00 CMP DWORD PTR DS:[EBX],0
@ -514,9 +564,11 @@ void Install_LoadPlayerData()
//6FC7621A |. 74 21 JE SHORT D2Game.6FC7623D //6FC7621A |. 74 21 JE SHORT D2Game.6FC7623D
//6FC5BB57 |> 833B 00 CMP DWORD PTR DS:[EBX],0 //6FC5BB57 |> 833B 00 CMP DWORD PTR DS:[EBX],0
//6FC5BB5A |. 74 21 JE SHORT D2Game.6FC5BB7D //6FC5BB5A |. 74 21 JE SHORT D2Game.6FC5BB7D
//00534572 |> 833F 00 CMP DWORD PTR DS:[EDI],0
//00534575 |. 74 1D JE SHORT Game.00534594
// Send save files to Server. // Send save files to Server.
mem_seek R7(D2Client, CF42, CF32, D5A2, 733FC, 5DFDC, 7933C, 1457C, B638C); mem_seek R8(D2Client, CF42, CF32, D5A2, 733FC, 5DFDC, 7933C, 1457C, B638C, 7807E);
MEMJ_REF4( D2FogGetSavePath, version_D2Game >= V111 ? caller_SendSaveFiles_111 : caller_SendSaveFiles); MEMJ_REF4( D2FogGetSavePath, version_D2Game >= V111 ? caller_SendSaveFiles_111 : caller_SendSaveFiles);
//6FAAD5A1 |. E8 88D10B00 CALL <JMP.&Fog.#10115> //6FAAD5A1 |. E8 88D10B00 CALL <JMP.&Fog.#10115>
//6FB233FB |. E8 CA8AF9FF CALL <JMP.&Fog.#10115> //6FB233FB |. E8 CA8AF9FF CALL <JMP.&Fog.#10115>
@ -524,13 +576,14 @@ void Install_LoadPlayerData()
//6FB2933B |. E8 6A2CF9FF CALL <JMP.&Fog.#10115> //6FB2933B |. E8 6A2CF9FF CALL <JMP.&Fog.#10115>
//6FAC457B |. E8 187AFFFF CALL <JMP.&Fog.#10115> //6FAC457B |. E8 187AFFFF CALL <JMP.&Fog.#10115>
//6FB6638B |. E8 2E5BF5FF CALL <JMP.&Fog.#10115> //6FB6638B |. E8 2E5BF5FF CALL <JMP.&Fog.#10115>
//0047807D |. E8 CEEFF8FF CALL Game.00407050
// Receive save files from client. // Receive save files from client.
mem_seek R7(D2Game, 183A, 183A, 191A, 376E9, 703D9, 624D9, CAF39, D53E9); mem_seek R8(D2Game, 183A, 183A, 191A, 376E9, 703D9, 624D9, CAF39, D53E9, 13F114);
memt_byte( 0x8B ,0xE8); memt_byte( 0x8B ,0xE8);
if ( version_D2Game >= V111 ) { if ( version_D2Game >= V111 ) {
MEMT_REF4( 0xB60F005D, caller_ReceiveSaveFiles_111); MEMT_REF4( version_D2Game >= V114d ? 0x46B60F1E : 0xB60F005D, version_D2Game >= V114d ? caller_ReceiveSaveFiles_114 : caller_ReceiveSaveFiles_111);
memt_byte( 0x45 ,0x90); if (version_D2Game < V114a) memt_byte( 0x45 ,0x90);
memt_byte( 0x04 ,0x90); memt_byte( 0x04 ,0x90);
//01FB76E9 |. 8B5D 00 MOV EBX,DWORD PTR SS:[EBP] //01FB76E9 |. 8B5D 00 MOV EBX,DWORD PTR SS:[EBP]
//01FB76EC |. 0FB645 04 MOVZX EAX,BYTE PTR SS:[EBP+4] //01FB76EC |. 0FB645 04 MOVZX EAX,BYTE PTR SS:[EBP+4]
@ -542,6 +595,8 @@ void Install_LoadPlayerData()
//6FCEAF3C |. 0FB645 04 MOVZX EAX,BYTE PTR SS:[EBP+4] //6FCEAF3C |. 0FB645 04 MOVZX EAX,BYTE PTR SS:[EBP+4]
//6FCF53E9 |. 8B5D 00 MOV EBX,DWORD PTR SS:[EBP] //6FCF53E9 |. 8B5D 00 MOV EBX,DWORD PTR SS:[EBP]
//6FCF53EC |. 0FB645 04 MOVZX EAX,BYTE PTR SS:[EBP+4] //6FCF53EC |. 0FB645 04 MOVZX EAX,BYTE PTR SS:[EBP+4]
//0053F114 |. 8B1E MOV EBX,DWORD PTR DS:[ESI]
//0053F116 |. 0FB646 04 MOVZX EAX,BYTE PTR DS:[ESI+4]
} else { } else {
MEMT_REF4( 0x04468A3E, caller_ReceiveSaveFiles); MEMT_REF4( 0x04468A3E, caller_ReceiveSaveFiles);
//6FC3191A |. 8B3E MOV EDI,DWORD PTR DS:[ESI] //6FC3191A |. 8B3E MOV EDI,DWORD PTR DS:[ESI]
@ -550,7 +605,7 @@ void Install_LoadPlayerData()
if ( version_Fog <= V109d ) if ( version_Fog <= V109d )
{ {
mem_seek R7(Fog, 47DE, 45AE, 0000, 0000, 0000, 0000, 0000, 0000); mem_seek R8(Fog, 47DE, 45AE, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0x8B ,0xE8); memt_byte( 0x8B ,0xE8);
MEMT_REF4( 0x891C2444, version_Fog == V109b? caller_BugFix109b : caller_BugFix109d); MEMT_REF4( 0x891C2444, version_Fog == V109b? caller_BugFix109b : caller_BugFix109d);
memt_byte( 0x44 ,0x90); memt_byte( 0x44 ,0x90);

72
PlugY/LocalizedStrings.cpp
View File

@ -10,6 +10,8 @@
#include "common.h" #include "common.h"
#include <stdio.h> #include <stdio.h>
const char* LOCALIZED_STRINGS_FILENAME = "PlugY\\LocalizedStrings.ini";
LPWSTR StripGender(LPWSTR text) LPWSTR StripGender(LPWSTR text)
{ {
if (text[0] == L' ') if (text[0] == L' ')
@ -32,11 +34,14 @@ struct LocalizedTypeString
LPSTR itemStr; LPSTR itemStr;
LPWSTR typeLocalizedString; LPWSTR typeLocalizedString;
} *sLocalizedTypeStrings; } *sLocalizedTypeStrings;
LPWSTR sLocalizedStrings[60];
LPWSTR sLocalizedStrings[100];
int nbLocalizedTypeString = 0; int nbLocalizedTypeString = 0;
LPWSTR getLocalString(int stringId) LPWSTR getLocalString(int stringId)
{ {
if (stringId < 0 || stringId >= 100)
return L"";
return sLocalizedStrings[stringId]; return sLocalizedStrings[stringId];
} }
@ -46,7 +51,7 @@ LPCWSTR getLocalTypeString(DWORD code)
{ {
if (sLocalizedTypeStrings[i].code == code) if (sLocalizedTypeStrings[i].code == code)
{ {
log_msg("Code=%08X\n", code); //log_msg("Code=%08X\n", code);
if (sLocalizedTypeStrings[i].itemStr) if (sLocalizedTypeStrings[i].itemStr)
return StripGender(D2GetStringFromString(sLocalizedTypeStrings[i].itemStr)); return StripGender(D2GetStringFromString(sLocalizedTypeStrings[i].itemStr));
LPWSTR text = StripGender(sLocalizedTypeStrings[i].typeLocalizedString); LPWSTR text = StripGender(sLocalizedTypeStrings[i].typeLocalizedString);
@ -93,19 +98,29 @@ void loadLocalString(INIFileW *iniFile, int id, LPCWSTR section, LPCWSTR key)
sLocalizedStrings[id] = new WCHAR[len + 1]; sLocalizedStrings[id] = new WCHAR[len + 1];
wcsncpy(sLocalizedStrings[id], section, len); wcsncpy(sLocalizedStrings[id], section, len);
sLocalizedStrings[id][len] = NULL; sLocalizedStrings[id][len] = NULL;
return;
} }
int j = 0;
int i = 0;
if (buffer[0] == L'"' && buffer[len-1] == L'"') if (buffer[0] == L'"' && buffer[len-1] == L'"')
{ {
sLocalizedStrings[id] = new WCHAR[len - 1]; buffer[len-1] = NULL;
wcsncpy(sLocalizedStrings[id], buffer + 1, len - 2); i++;
sLocalizedStrings[id][len - 2] = NULL; len -= 2;
}
sLocalizedStrings[id] = new WCHAR[len + 1];
for (; i<len; i++)
{
if (buffer[i] == L'\\' && buffer[i+1] == L'n')
{
sLocalizedStrings[id][j++] = L'\n';
i++;
} }
else else
{ sLocalizedStrings[id][j++] = buffer[i];
sLocalizedStrings[id] = new WCHAR[len + 1];
wcsncpy(sLocalizedStrings[id], buffer, len);
sLocalizedStrings[id][len] = NULL;
} }
sLocalizedStrings[id][j] = NULL;
} }
int GetPrivateProfileStringList(LPCWCHAR m_cache, LPCWSTR section, LPCWSTR key) int GetPrivateProfileStringList(LPCWCHAR m_cache, LPCWSTR section, LPCWSTR key)
@ -143,7 +158,7 @@ int GetPrivateProfileStringList(LPCWCHAR m_cache, LPCWSTR section, LPCWSTR key)
// Treat next section // Treat next section
int i = 0; int i = 0;
while (nextHeader) while (nextHeader && i < nb)
{ {
cur = nextHeader + wcslen(sectionString); cur = nextHeader + wcslen(sectionString);
end = wcsstr(cur, L"]"); end = wcsstr(cur, L"]");
@ -227,12 +242,20 @@ int GetPrivateProfileStringList(LPCWCHAR m_cache, LPCWSTR section, LPCWSTR key)
void loadLocalizedStrings(int language) void loadLocalizedStrings(int language)
{ {
if (sLocalizedTypeStrings)
return;
INIFileW *iniFile = new INIFileW; INIFileW *iniFile = new INIFileW;
log_msg("***** Load localized Strings *****\n"); log_msg("***** Load localized Strings *****\n");
if (!iniFile->InitReadWrite("PlugY\\LocalizedStrings.ini", INIFILE_MPQREAD, 0))//C:\\Jeux\\Blizzard\\D2\\- if (iniFile->InitReadWrite(LOCALIZED_STRINGS_FILENAME, INIFILE_MPQREAD, 0))//C:\\Jeux\\Blizzard\\D2\\-
log_msg("File %s loaded from MPQ.\n\n", LOCALIZED_STRINGS_FILENAME);
else if (iniFile->InitReadWrite(LOCALIZED_STRINGS_FILENAME, INIFILE_READ, 0))//C:\\Jeux\\Blizzard\\D2\\-
log_msg("File %s loaded from PlugY folder.\n\n", LOCALIZED_STRINGS_FILENAME);
else
{ {
log_msg("Failed to load LocalizedStrings, default values used.\n\n"); log_msg("Failed to load %s.\n\n", LOCALIZED_STRINGS_FILENAME);
return;
} }
LPCWSTR key; LPCWSTR key;
@ -266,6 +289,7 @@ void loadLocalizedStrings(int language)
LOAD(STR_STASH_NEXT_PAGE); LOAD(STR_STASH_NEXT_PAGE);
LOAD(STR_TOGGLE_TO_PERSONAL); LOAD(STR_TOGGLE_TO_PERSONAL);
LOAD(STR_TOGGLE_TO_SHARED); LOAD(STR_TOGGLE_TO_SHARED);
LOAD(STR_TOGGLE_MULTI_DISABLED);
LOAD(STR_STASH_PREVIOUS_INDEX); LOAD(STR_STASH_PREVIOUS_INDEX);
LOAD(STR_STASH_NEXT_INDEX); LOAD(STR_STASH_NEXT_INDEX);
LOAD(STR_PUT_GOLD); LOAD(STR_PUT_GOLD);
@ -276,7 +300,10 @@ void loadLocalizedStrings(int language)
LOAD(STR_SHARED_GOLD_QUANTITY); LOAD(STR_SHARED_GOLD_QUANTITY);
LOAD(STR_PREVIOUS_PAGE); LOAD(STR_PREVIOUS_PAGE);
LOAD(STR_NEXT_PAGE); LOAD(STR_NEXT_PAGE);
LOAD(STR_PREVIOUS_RUNE);
LOAD(STR_NEXT_RUNE);
LOAD(STR_ITEM_LEVEL); LOAD(STR_ITEM_LEVEL);
LOAD(STR_PAGE_TYPE_CHANGE);
// Cube receipt : // Cube receipt :
LOAD(STR_COW_PORTAL); LOAD(STR_COW_PORTAL);
@ -316,6 +343,27 @@ void loadLocalizedStrings(int language)
LOAD(STR_ONLY_HELL); LOAD(STR_ONLY_HELL);
LOAD(STR_ONLY_CLASS); LOAD(STR_ONLY_CLASS);
// Breakpoints :
LOAD(STR_MERCENARIES);
LOAD(STR_MERC_ACT_1);
LOAD(STR_MERC_ACT_2);
LOAD(STR_MERC_ACT_3);
LOAD(STR_MERC_ACT_5);
LOAD(STR_BREAKPOINT);
LOAD(STR_BREAKPOINTS);
LOAD(STR_BLOCK_FRAMES);
LOAD(STR_CASTING_FRAMES);
LOAD(STR_HIT_RECOVERY_FRAMES);
LOAD(STR_1H_SWINGING_WEAPON);
LOAD(STR_OTHER_WEAPONS);
LOAD(STR_HUMAN_FORM);
LOAD(STR_BEAR_FORM);
LOAD(STR_WOLF_FORM);
LOAD(STR_VAMPIRE_FORM);
LOAD(STR_SPEARS_AND_STAVES);
LOAD(STR_LIGHTNING_CHAIN_LIGHTNING);
LOAD(STR_OTHER_SPELLS);
iniFile->close(); iniFile->close();
delete iniFile; delete iniFile;
} }

32
PlugY/LocalizedStrings.h
View File

@ -1,9 +1,9 @@
/*============================================== /*==============================================
File created by Yohann NICOLAS. 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 this file implements some common and useful
function related to some Diablo II mechanisms. function related to some Diablo II mechanisms.
/*============================================*/ /*============================================*/
#pragma once #pragma once
@ -26,6 +26,7 @@ enum eStringList
STR_STASH_NEXT_PAGE, STR_STASH_NEXT_PAGE,
STR_TOGGLE_TO_PERSONAL, STR_TOGGLE_TO_PERSONAL,
STR_TOGGLE_TO_SHARED, STR_TOGGLE_TO_SHARED,
STR_TOGGLE_MULTI_DISABLED,
STR_STASH_PREVIOUS_INDEX, STR_STASH_PREVIOUS_INDEX,
STR_STASH_NEXT_INDEX, STR_STASH_NEXT_INDEX,
STR_PUT_GOLD, STR_PUT_GOLD,
@ -36,7 +37,10 @@ enum eStringList
STR_SHARED_GOLD_QUANTITY, STR_SHARED_GOLD_QUANTITY,
STR_PREVIOUS_PAGE, STR_PREVIOUS_PAGE,
STR_NEXT_PAGE, STR_NEXT_PAGE,
STR_PREVIOUS_RUNE,
STR_NEXT_RUNE,
STR_ITEM_LEVEL, STR_ITEM_LEVEL,
STR_PAGE_TYPE_CHANGE,
// //
STR_COW_PORTAL, STR_COW_PORTAL,
STR_PANDEMONIUM_PORTAL, STR_PANDEMONIUM_PORTAL,
@ -74,6 +78,26 @@ enum eStringList
STR_ONLY_N_H, STR_ONLY_N_H,
STR_ONLY_HELL, STR_ONLY_HELL,
STR_ONLY_CLASS, STR_ONLY_CLASS,
STR_MERCENARIES,
STR_MERC_ACT_1,
STR_MERC_ACT_2,
STR_MERC_ACT_3,
STR_MERC_ACT_5,
STR_BREAKPOINT,
STR_BREAKPOINTS,
STR_BLOCK_FRAMES,
STR_CASTING_FRAMES,
STR_HIT_RECOVERY_FRAMES,
STR_1H_SWINGING_WEAPON,
STR_OTHER_WEAPONS,
STR_HUMAN_FORM,
STR_BEAR_FORM,
STR_WOLF_FORM,
STR_VAMPIRE_FORM,
STR_SPEARS_AND_STAVES,
STR_LIGHTNING_CHAIN_LIGHTNING,
STR_OTHER_SPELLS
}; };
/*================================= END OF FILE =================================*/ /*================================= END OF FILE =================================*/

47
PlugY/MainScreen.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Print PlugY version on screen. Print PlugY version on screen.
@ -34,6 +35,16 @@ void STDCALL printPlugYVersion(void** childrens, DWORD* sgnNumChildren)
} }
} }
void** childrens;
DWORD* sgnNumChildren;
FCT_ASM ( caller_printPlugYVersion114 )
PUSH sgnNumChildren
PUSH childrens
CALL printPlugYVersion
MOV ECX,0x115
RETN
}}
FCT_ASM ( caller_printPlugYVersion ) FCT_ASM ( caller_printPlugYVersion )
POP ESI POP ESI
PUSH DWORD PTR [ESI+2] PUSH DWORD PTR [ESI+2]
@ -52,7 +63,17 @@ void Install_PrintPlugYVersion()
log_msg("Patch D2Launch to print PlugY version. (PrintPlugYVersion)\n"); log_msg("Patch D2Launch to print PlugY version. (PrintPlugYVersion)\n");
// Print PlugY version. // Print PlugY version.
mem_seek R7(D2Launch, 7F5D, 7F7D, 9639, 117C7, 178A7, 16AF7, 18061, 10A11); mem_seek R8(D2Launch, 7F5D, 7F7D, 9639, 117C7, 178A7, 16AF7, 18061, 10A11, 33798);
if (version_D2Launch == V114d)
{
memt_byte(0xB9, 0xE8);
MEMT_REF4(0x00000115, caller_printPlugYVersion114);
childrens = (void**)(offset_Game + 0x379350);
sgnNumChildren = (DWORD*)(offset_Game + 0x379944);
//00433798 |. B9 15010000 MOV ECX,115
}
else
{
MEMJ_REF4( D2CreateTextBox, caller_printPlugYVersion); MEMJ_REF4( D2CreateTextBox, caller_printPlugYVersion);
//6FA19638 |. E8 1BED0000 CALL <JMP.&D2Win.#10017> //6FA19638 |. E8 1BED0000 CALL <JMP.&D2Win.#10017>
//6FA517C6 |. E8 6F81FFFF CALL <JMP.&D2Win.#10147> //6FA517C6 |. E8 6F81FFFF CALL <JMP.&D2Win.#10147>
@ -61,7 +82,7 @@ void Install_PrintPlugYVersion()
//6FA56AF6 |. E8 432EFFFF CALL <JMP.&D2Win.#10098> //6FA56AF6 |. E8 432EFFFF CALL <JMP.&D2Win.#10098>
//6FA58060 |. E8 ED18FFFF CALL <JMP.&D2Win.#10098> //6FA58060 |. E8 ED18FFFF CALL <JMP.&D2Win.#10098>
//6FA50A10 |. E8 218FFFFF CALL <JMP.&D2Win.#10164> //6FA50A10 |. E8 218FFFFF CALL <JMP.&D2Win.#10164>
}
log_msg("\n"); log_msg("\n");
@ -75,6 +96,14 @@ void FASTCALL versionChange(void* screen, char* text, DWORD color)
D2PrintLineOnTextBox(screen,versionText,modVersionColor); D2PrintLineOnTextBox(screen,versionText,modVersionColor);
} }
FCT_ASM ( caller_VersionChange_114 )
MOV CL, BYTE PTR DS:[modVersionColor]
MOV BYTE PTR SS:[ESP+4], CL
MOV EDX,versionText
MOV ECX,ESI
RETN
}}
FCT_ASM ( caller_VersionChange_10 ) FCT_ASM ( caller_VersionChange_10 )
MOV CL, BYTE PTR DS:[modVersionColor] MOV CL, BYTE PTR DS:[modVersionColor]
MOV BYTE PTR SS:[ESP+4], CL MOV BYTE PTR SS:[ESP+4], CL
@ -96,9 +125,17 @@ void Install_VersionChange()// BUG WITH 2MOD if D2Mod started before PlugY ????
// Print LoD/Mod version. // Print LoD/Mod version.
if (version_D2Launch >= V110) if (version_D2Launch >= V114d)
{ {
mem_seek R7(D2Launch, 00000, 00000, 9723, 1189B, 1797B, 16BCB, 18134, 10AE4);//6FA19721-6FA10000 mem_seek R8(D2Launch, 00000, 00000, 9723, 1189B, 1797B, 16BCB, 18134, 10AE4, 337EA);//6FA19721-6FA10000
memt_byte(0x8D, 0xE8); // CALL
MEMT_REF4(0xCE8BC055, caller_VersionChange_114);
//004337EA |. 8D55 C0 LEA EDX,DWORD PTR SS:[EBP-40] ; |
//004337ED |. 8BCE MOV ECX,ESI ; |
}
else if (version_D2Launch >= V110)
{
mem_seek R8(D2Launch, 00000, 00000, 9723, 1189B, 1797B, 16BCB, 18134, 10AE4, 337EA);//6FA19721-6FA10000
memt_byte( 0x8D, 0xE8 ); // CALL memt_byte( 0x8D, 0xE8 ); // CALL
MEMT_REF4( 0x8B102454 , caller_VersionChange_10); MEMT_REF4( 0x8B102454 , caller_VersionChange_10);
memt_byte( 0xCF, 0x90 ); // NOP memt_byte( 0xCF, 0x90 ); // NOP
@ -115,7 +152,7 @@ void Install_VersionChange()// BUG WITH 2MOD if D2Mod started before PlugY ????
//6FA50AE4 |. 8D5424 10 LEA EDX,DWORD PTR SS:[ESP+10] //6FA50AE4 |. 8D5424 10 LEA EDX,DWORD PTR SS:[ESP+10]
//6FA50AE8 |. 8BCF MOV ECX,EDI //6FA50AE8 |. 8BCF MOV ECX,EDI
} else { } else {
mem_seek R7(D2Launch, 801B, 803B, 972A, 118A2, 17982, 16BD2, 1813B, 10AEB); mem_seek R8(D2Launch, 801B, 803B, 972A, 118A2, 17982, 16BD2, 1813B, 10AEB, 00000);
MEMJ_REF4( D2PrintLineOnTextBox, versionChange); MEMJ_REF4( D2PrintLineOnTextBox, versionChange);
//6FA19729 |. E8 88EB0000 CALL <JMP.&D2Win.#10046> //6FA19729 |. E8 88EB0000 CALL <JMP.&D2Win.#10046>
//6FA518A1 |. E8 267FFFFF CALL <JMP.&D2Win.#10061> //6FA518A1 |. E8 267FFFFF CALL <JMP.&D2Win.#10061>

11
PlugY/ModifMemory.cpp
View File

@ -9,11 +9,10 @@
#include "parameters.h" #include "parameters.h"
#include "modifMemory.h" #include "modifMemory.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" const char* MSG_ERROR_READ_MEMORY = "Error : Read access missing to patch memory at %08X.\n\nAn option in PlugY.ini is incompatible with another mod.";
"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)"; const char* MSG_CRITICAL_WRITE_MEMORY = "Error.\nWrite access missing to patch memory at %08X.\n\nAn option in PlugY.ini is incompatible with another mod.";
const char* MSG_CRITICAL_WRITE_MEMORY = "Error.\nWrite access missing to patch memory at %08X.\n\nPlease install a clean version of Lord of Destruction\n"; const char* ERROR_TESTING1 = "Error : BYTE %02X wanted but %02X found to change memory at %08X.\n\nAn option in PlugY.ini is incompatible with another mod.";
const char* ERROR_TESTING1 = "Error : BYTE %02X wanted but %02X found to change memory at %08X\n\n"; const char* ERROR_TESTING4 = "Error : DWORD %08X wanted but %08X found to change memory at %08X.\n\nAn option in PlugY.ini is incompatible with another mod.";
const char* ERROR_TESTING4 = "Error : DWORD %08X wanted but %08X found to change memory at %08X\n\n";
void* currentMemoryPos = 0; void* currentMemoryPos = 0;
@ -102,11 +101,13 @@ bool testIfAlreadySet(DWORD current, DWORD wanted)
void testMemory4(DWORD old, DWORD found) void testMemory4(DWORD old, DWORD found)
{ {
if (old != found) if (old != found)
{
if (active_CheckMemory) if (active_CheckMemory)
{ {
log_box(ERROR_TESTING4, old, found, currentMemoryPos); log_box(ERROR_TESTING4, old, found, currentMemoryPos);
exit(1); exit(1);
} else log_msg(ERROR_TESTING4, old, found, currentMemoryPos); } else log_msg(ERROR_TESTING4, old, found, currentMemoryPos);
}
} }
void memt_dword(DWORD old, DWORD val) void memt_dword(DWORD old, DWORD val)

14
PlugY/NewInterface_CubeListing.cpp
View File

@ -42,7 +42,7 @@ void printOutputItem(CubeOutput* output, LPWSTR buf, LPINT len, LPINT nbOutputs)
if ((output->quantityOrNbSockets>1) && !output->haveSockets) if ((output->quantityOrNbSockets>1) && !output->haveSockets)
{ {
if (output->quantityOrNbSockets = 255) if (output->quantityOrNbSockets == 255)
PRINT(BUF, L"%s ", getLocalString(STR_FULL)); PRINT(BUF, L"%s ", getLocalString(STR_FULL));
else else
PRINT(BUF, L"%u ", output->quantityOrNbSockets); PRINT(BUF, L"%u ", output->quantityOrNbSockets);
@ -233,12 +233,6 @@ DWORD print(CubeMainBIN* curForm, LPWSTR buf, LPINT len, DWORD)//maxsize)
printInputItem(&curForm->input6, buf, len, &realNbInputs); printInputItem(&curForm->input6, buf, len, &realNbInputs);
printInputItem(&curForm->input7, buf, len, &realNbInputs); printInputItem(&curForm->input7, buf, len, &realNbInputs);
if (realNbInputs != curForm->numinputs)
{
PRINT(BUF, L" *** ERROR : numInputs(%d) != realNbInputs(%d) ***", curForm->numinputs, realNbInputs);
return 1;
}
PRINT(BUF,L" => "); PRINT(BUF,L" => ");
int realNbOutputs=0; int realNbOutputs=0;
@ -269,6 +263,9 @@ DWORD print(CubeMainBIN* curForm, LPWSTR buf, LPINT len, DWORD)//maxsize)
// if (curForm->version == 100) // if (curForm->version == 100)
// sprintf(BUF, " [expansion only]"); // sprintf(BUF, " [expansion only]");
if (realNbInputs != curForm->numinputs)
PRINT(BUF, L" *** ERROR : numInputs(%d) != realNbInputs(%d) ***", curForm->numinputs, realNbInputs);
return 1; return 1;
} }
#undef BUF #undef BUF
@ -305,6 +302,7 @@ void listAllCubeFormula()
int len = 0; int len = 0;
int nbCubeReceipt = 0; int nbCubeReceipt = 0;
int line = 0;
for (int i=0; i<nbLines; i++) for (int i=0; i<nbLines; i++)
{ {
DWORD res = 1; DWORD res = 1;
@ -315,7 +313,7 @@ void listAllCubeFormula()
if (res) if (res)
{ {
nbCubeReceipt++; nbCubeReceipt++;
fwprintf(file, L"%3u: %s\n", i, buf); fwprintf(file, L"%3u: %s\n", ++line, buf);
} }
} }

98
PlugY/NewInterface_Runewords.cpp
View File

@ -12,6 +12,7 @@
#include "common.h" #include "common.h"
#include <stdio.h> #include <stdio.h>
/*
#define NB_RUNES_PER_PAGE 25 #define NB_RUNES_PER_PAGE 25
#define getXCloseBtn() 360 #define getXCloseBtn() 360
@ -53,6 +54,7 @@ static struct
}; };
}; };
} isDownBtn; } isDownBtn;
*/
void printRuneword(RunesBIN* runesData, DWORD pos) void printRuneword(RunesBIN* runesData, DWORD pos)
@ -64,7 +66,7 @@ void printRuneword(RunesBIN* runesData, DWORD pos)
D2SetFont(6); D2SetFont(6);
DWORD nbPixel = D2GetPixelLen(lpText); DWORD nbPixel = D2GetPixelLen(lpText);
DWORD x1 = (nbPixel >= 195) ? 0 : 195-nbPixel; DWORD x1 = (nbPixel >= 195) ? 0 : 195-nbPixel;
D2PrintString(lpText, x1, 10 + pos*20, GOLD, 0);//MILIEU(0x00,0x70,nbPixel) D2PrintString(lpText, posXRunesList + RX(x1), posYRunesList + 10 + pos*20, GOLD, 0);//MILIEU(0x00,0x70,nbPixel)
typesList[0]=L'\0'; typesList[0]=L'\0';
DWORD numItype=0; DWORD numItype=0;
@ -80,7 +82,7 @@ void printRuneword(RunesBIN* runesData, DWORD pos)
} }
nbPixel = D2GetPixelLen(typesList); nbPixel = D2GetPixelLen(typesList);
x1 = (nbPixel >= 195) ? 0 : 195-nbPixel; x1 = (nbPixel >= 195) ? 0 : 195-nbPixel;
D2PrintString(typesList, x1, 20 + pos*20, WHITE, 0);//MILIEU(0x70,0xA0,nbPixel) D2PrintString(typesList, posXRunesList + RX(x1), posYRunesList + 20 + pos*20, WHITE, 0);//MILIEU(0x70,0xA0,nbPixel)
runesList[0]=L'\0'; runesList[0]=L'\0';
DWORD numRune=0; DWORD numRune=0;
@ -115,7 +117,7 @@ void printRuneword(RunesBIN* runesData, DWORD pos)
} }
// x1 = (nbPixel < 145) ? 155 : 300-nbPixel; // x1 = (nbPixel < 145) ? 155 : 300-nbPixel;
D2PrintString(runesList, x1, y1 + pos*20, WHITE, 0);//MILIEU(0xD0,0xA0,nbPixel) D2PrintString(runesList, posXRunesList + RX(x1), posYRunesList + y1 + pos*20, WHITE, 0);//MILIEU(0xD0,0xA0,nbPixel)
} }
@ -123,48 +125,58 @@ void printRuneword(RunesBIN* runesData, DWORD pos)
//6FB21FAA //6FB21FAA
void STDCALL printRunewordsPage() void STDCALL printRunewordsPage()
{ {
if (!D2isLODGame() || !D2GetResolution()) return D2PrintStatsPage(); if (!D2isLODGame()) return D2PrintStatsPage();
LPWSTR lpText; LPWSTR lpText;
bDontPrintBorder = true; bDontPrintBorder = D2GetResolution()? true : false;
//Init data for print image //Init data for print image
sDrawImageInfo data; sDrawImageInfo data;
ZeroMemory(&data,sizeof(data)); ZeroMemory(&data,sizeof(data));
//print background //print background
/* setImage(&data, newStatsInterfaceImages); fillRect(RX(0), RY(ResolutionY), 512, 768, 0, 5);
setImage(&data, newStatsInterfaceImages);
setFrame(&data, 0); setFrame(&data, 0);
D2PrintImage(&data, 0, 256, -1, 5, 0); D2PrintImage(&data, RX(0), RY(ResolutionY-256), -1, 5, 0);
setFrame(&data, 1); setFrame(&data, 1);
D2PrintImage(&data, 256,256, -1, 5, 0); D2PrintImage(&data, RX(256),RY(ResolutionY-256), -1, 5, 0);
setFrame(&data, 2); setFrame(&data, 2);
D2PrintImage(&data, 0, 512, -1, 5, 0); D2PrintImage(&data, RX(0), RY(ResolutionY-256*2), -1, 5, 0);
setFrame(&data, 3); setFrame(&data, 3);
D2PrintImage(&data, 256,512, -1, 5, 0); D2PrintImage(&data, RX(256),RY(ResolutionY-256*2), -1, 5, 0);
setFrame(&data, 4); setFrame(&data, 4);
D2PrintImage(&data, 0, 552, -1, 5, 0); D2PrintImage(&data, RX(0), RY(ResolutionY-256*3), -1, 5, 0);
setFrame(&data, 5); setFrame(&data, 5);
D2PrintImage(&data, 256,552, -1, 5, 0); D2PrintImage(&data, RX(256),RY(ResolutionY-256*3), -1, 5, 0);
*/
fillRect(0,0,400,552,0,5); if (printBackgroundOnMainPage)
{
setImage(&data, statsBackgroundImages);
setFrame(&data, 1);
D2PrintImage(&data, getXPreviousPageBtn()-7, getYPreviousPageBtn()+8, -1, 5, 0);
D2PrintImage(&data, getXPrevRunesBtn()-7, getYPrevRunesBtn()+8, -1, 5, 0);
}
//print button close //print button close
setImage(&data, D2LoadBuySelBtn()); setImage(&data, D2LoadBuySelBtn());
setFrame(&data, 10 + isDownBtn.close); setFrame(&data, 10 + isDownBtn.close);
D2PrintImage(&data, getXCloseBtn(), getYCloseBtn(), -1, 5, 0); D2PrintImage(&data, getXCloseBtn(), getYCloseBtn(), -1, 5, 0);
//print previous page button
setFrame(&data, 12 + isDownBtn.previousPage);
D2PrintImage(&data, getXPreviousPageBtn(), getYPreviousPageBtn(), -1, 5, 0);
//print next page button //print next page button
setFrame(&data, isDownBtn.nextPage); setFrame(&data, 14 + isDownBtn.nextPage);
D2PrintImage(&data, getXNextPageBtn(), getYNextPageBtn(), -1, 5, 0); D2PrintImage(&data, getXNextPageBtn(), getYNextPageBtn(), -1, 5, 0);
//print previous runes button //print previous runes button
setImage(&data, stashBtnsImages); setFrame(&data, 12 + isDownBtn.prevRunes);
setFrame(&data, isDownBtn.prevRunes);
D2PrintImage(&data, getXPrevRunesBtn(), getYPrevRunesBtn(), -1, 5, 0); D2PrintImage(&data, getXPrevRunesBtn(), getYPrevRunesBtn(), -1, 5, 0);
//print previous runes button //print previous runes button
setFrame(&data, 2 + isDownBtn.nextRunes); setFrame(&data, 14 + isDownBtn.nextRunes);
D2PrintImage(&data, getXNextRunesBtn(), getYNextRunesBtn(), -1, 5, 0); D2PrintImage(&data, getXNextRunesBtn(), getYNextRunesBtn(), -1, 5, 0);
D2SetFont(6); D2SetFont(6);
@ -181,11 +193,11 @@ void STDCALL printRunewordsPage()
{ {
if (!runesData->Complete || runesData->Server) continue; if (!runesData->Complete || runesData->Server) continue;
nbRunesCompleted++; nbRunesCompleted++;
if ( (curRunesPage * NB_RUNES_PER_PAGE < nbRunesCompleted) && if ( (curRunesPage * runesPerPage < nbRunesCompleted) &&
(nbRunesCompleted <= (curRunesPage+1) * NB_RUNES_PER_PAGE) ) (nbRunesCompleted <= (curRunesPage+1) * runesPerPage) )
printRuneword(runesData, curNbRunes++); printRuneword(runesData, curNbRunes++);
} }
maxRunesPage = nbRunesCompleted ? (nbRunesCompleted-1) / NB_RUNES_PER_PAGE : 0; maxRunesPage = nbRunesCompleted ? (nbRunesCompleted-1) / runesPerPage : 0;
//////////////////// POPUP PRINTING //////////////////// //////////////////// POPUP PRINTING ////////////////////
@ -197,11 +209,26 @@ void STDCALL printRunewordsPage()
{ {
D2PrintPopup(D2GetStringFromIndex(0x1030), getXCloseBtn()+getLCloseBtn()/2, getYCloseBtn()-getHCloseBtn(), WHITE, 1); D2PrintPopup(D2GetStringFromIndex(0x1030), getXCloseBtn()+getLCloseBtn()/2, getYCloseBtn()-getHCloseBtn(), WHITE, 1);
} }
else if (isOnPreviousPageBtn(x,y)) //print popup "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" else if (isOnNextPageBtn(x,y)) // print popup "next page"
{ {
lpText = getLocalString(STR_NEXT_PAGE); lpText = getLocalString(STR_NEXT_PAGE);
D2PrintPopup(lpText, getXNextPageBtn()+getLNextPageBtn()/2, getYNextPageBtn()-getHNextPageBtn(), WHITE, 1); D2PrintPopup(lpText, getXNextPageBtn()+getLNextPageBtn()/2, getYNextPageBtn()-getHNextPageBtn(), WHITE, 1);
} }
else if (isOnPrevRunesBtn(x,y)) // print popup "previous rune"
{
lpText = getLocalString(STR_PREVIOUS_RUNE);
D2PrintPopup(lpText, getXPrevRunesBtn()+getLPrevRunesBtn()/2, getYPrevRunesBtn()-getHPrevRunesBtn(), WHITE, 1);
}
else if (isOnNextRunesBtn(x,y)) // print popup "next rune"
{
lpText = getLocalString(STR_NEXT_RUNE);
D2PrintPopup(lpText, getXNextRunesBtn()+getLNextRunesBtn()/2, getYNextRunesBtn()-getHNextRunesBtn(), WHITE, 1);
}
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
@ -210,27 +237,30 @@ DWORD STDCALL mouseRunewordsPageLeftDown(sWinMessage* msg)
{ {
if (!D2isLODGame() || !D2GetResolution()) return -1; if (!D2isLODGame() || !D2GetResolution()) return -1;
if (!isOnStatsPage(msg->x,msg->y)) return 1; DWORD x = D2GetMouseX();
DWORD y = D2GetMouseY();
if (!isOnStatsPage(x,y))
return 1;
if (isOnCloseBtn(msg->x,msg->y)) if (isOnCloseBtn(x,y))
{ {
log_msg("push down left button close\n"); log_msg("push down left button close\n");
isDownBtn.close = 1; isDownBtn.close = 1;
D2PlaySound(4,0,0,0,0); D2PlaySound(4,0,0,0,0);
} }
else if (isOnNextPageBtn(msg->x,msg->y)) else if (isOnNextPageBtn(x,y))
{ {
log_msg("push down left button next page\n"); log_msg("push down left button next page\n");
isDownBtn.nextPage = 1; isDownBtn.nextPage = 1;
D2PlaySound(4,0,0,0,0); D2PlaySound(4,0,0,0,0);
} }
else if (isOnPrevRunesBtn(msg->x,msg->y)) else if (isOnPrevRunesBtn(x,y))
{ {
log_msg("push down left button prev page\n"); log_msg("push down left button prev page\n");
isDownBtn.prevRunes = 1; isDownBtn.prevRunes = 1;
D2PlaySound(4,0,0,0,0); D2PlaySound(4,0,0,0,0);
} }
else if (isOnNextRunesBtn(msg->x,msg->y)) else if (isOnNextRunesBtn(x,y))
{ {
log_msg("push down left button next runes\n"); log_msg("push down left button next runes\n");
isDownBtn.nextRunes = 1; isDownBtn.nextRunes = 1;
@ -246,24 +276,30 @@ DWORD STDCALL mouseRunewordsPageLeftUp(sWinMessage* msg)
{ {
if (!D2isLODGame() || !D2GetResolution()) return -1; if (!D2isLODGame() || !D2GetResolution()) return -1;
if (!isOnStatsPage(msg->x,msg->y)) return 1; DWORD x = D2GetMouseX();
DWORD y = D2GetMouseY();
if (!isOnStatsPage(x,y))
return 1;
if (isOnCloseBtn(msg->x,msg->y)) if (isOnCloseBtn(x,y))
{ {
log_msg("push up left button close\n"); log_msg("push up left button close\n");
if (isDownBtn.close) if (isDownBtn.close)
D2TogglePage(2,1,0); D2TogglePage(2,1,0);
} }
else if (isOnNextPageBtn(msg->x,msg->y)) else if (isOnNextPageBtn(x,y))
{ {
log_msg("push up left button next page\n"); log_msg("push up left button next page\n");
if (isDownBtn.nextPage) if (isDownBtn.nextPage)
{ {
if (extraHiddenPage>1)
GoStatPage(GetCurrentPage()+1); GoStatPage(GetCurrentPage()+1);
else
GoStatPage(0);
log_msg("next page press\n"); log_msg("next page press\n");
} }
} }
else if (isOnPrevRunesBtn(msg->x,msg->y)) else if (isOnPrevRunesBtn(x,y))
{ {
log_msg("push up left button prev runes\n"); log_msg("push up left button prev runes\n");
if (isDownBtn.prevRunes) if (isDownBtn.prevRunes)
@ -271,7 +307,7 @@ DWORD STDCALL mouseRunewordsPageLeftUp(sWinMessage* msg)
if (curRunesPage) curRunesPage--; if (curRunesPage) curRunesPage--;
} }
} }
else if (isOnNextRunesBtn(msg->x,msg->y)) else if (isOnNextRunesBtn(x,y))
{ {
log_msg("push up left button next runes\n"); log_msg("push up left button next runes\n");
if (isDownBtn.nextRunes) if (isDownBtn.nextRunes)

5
PlugY/NewInterface_Stats.cpp
View File

@ -13,6 +13,7 @@
#include <stdio.h> #include <stdio.h>
/*
#define getXCloseBtn() 360 #define getXCloseBtn() 360
#define getLCloseBtn() 32 #define getLCloseBtn() 32
#define getYCloseBtn() (ResolutionY - 60) #define getYCloseBtn() (ResolutionY - 60)
@ -92,6 +93,7 @@ void** ptD2AssignStatsPointsBtnImages = (void**)0x6FBB5BB4;
/*
static struct static struct
{ {
union{ union{
@ -111,6 +113,7 @@ static struct
}; };
}; };
} isDownBtn; } isDownBtn;
*/
void print2Lines(WORD id, LPWSTR lpText, DWORD x, DWORD l, DWORD y) void print2Lines(WORD id, LPWSTR lpText, DWORD x, DWORD l, DWORD y)
@ -347,7 +350,7 @@ if (version_D2Client <= V110)
//print Hit Point //print Hit Point
curValue = D2GetPlayerStat(ptChar, STATS_HP, 0) / 256; curValue = D2GetPlayerStat(ptChar, STATS_HP, 0) / 256;
if ((ptChar->CurrentAnim != 0x11) && !curValue) curValue=1; if ((ptChar->mode != UNIT_MODE_DEAD) && !curValue) curValue=UNIT_MODE_NEUTRAL;
swprintf(text,L"%ld",curValue); swprintf(text,L"%ld",curValue);

239
PlugY/NewInterface_StatsPageTwo.cpp
View File

@ -12,6 +12,7 @@
#include "common.h" #include "common.h"
#include <stdio.h> #include <stdio.h>
/*
#define getXCloseBtn() RX(0x110) #define getXCloseBtn() RX(0x110)
#define getLCloseBtn() 32 #define getLCloseBtn() 32
#define getYCloseBtn() RY(0x40) #define getYCloseBtn() RY(0x40)
@ -29,10 +30,13 @@
#define getYNextPageBtn() RY(0x40) #define getYNextPageBtn() RY(0x40)
#define getHNextPageBtn() 32 #define getHNextPageBtn() 32
#define isOnNextPageBtn(x,y) isOnRect(x, y, getXNextPageBtn(), getYNextPageBtn(), getLNextPageBtn(), getHNextPageBtn()) #define isOnNextPageBtn(x,y) isOnRect(x, y, getXNextPageBtn(), getYNextPageBtn(), getLNextPageBtn(), getHNextPageBtn())
*/
const char * STATS_INTERFACE_FILENAME = "PlugY\\statsinterface.txt";
#define BUFSIZE 0x80 #define BUFSIZE 0x400
/*
static struct static struct
{ {
union{ union{
@ -44,6 +48,7 @@ static struct
}; };
}; };
} isDownBtn; } isDownBtn;
*/
struct statsInterfaceBIN struct statsInterfaceBIN
@ -58,12 +63,12 @@ struct statsInterfaceBIN
}; };
extern int lastPage; extern int lastPage;
int nbStatsInterface; int nbStatsInterface = 0;
statsInterfaceBIN* statsInterface; statsInterfaceBIN* statsInterface = NULL;
void loadStatsInterfaceDesc(DWORD mempool) void loadStatsInterfaceDesc(DWORD mempool)
{ {
log_msg("loadStatsInterfaceDesc(%d)\n",mempool); log_msg("loadStatsInterfaceDesc(%d)\n", mempool);
CREATE_TABLE_DESCRIPTION(8); CREATE_TABLE_DESCRIPTION(8);
ADD_WORD_FIELD(0, "enabled"); ADD_WORD_FIELD(0, "enabled");
@ -75,12 +80,50 @@ void loadStatsInterfaceDesc(DWORD mempool)
// ADD_LOOKUP_WORD(10, "stat", lookupItemStatCost); // ADD_LOOKUP_WORD(10, "stat", lookupItemStatCost);
ADD_WORD_FIELD(12, "statID"); ADD_WORD_FIELD(12, "statID");
ADD_TERM_FIELD(); ADD_TERM_FIELD();
BUILD_BIN(statsInterfaceBIN, statsInterface, nbStatsInterface, "PlugY\\statsinterface.txt"); BUILD_BIN(statsInterfaceBIN, statsInterface, nbStatsInterface, STATS_INTERFACE_FILENAME);
//statsInterface = (statsInterfaceBIN*)compileTxtFile(mempool, STATS_INTERFACE_FILENAME, TableDesc, (DWORD*)&nbStatsInterface, sizeof(statsInterfaceBIN));
/*
int nbSize=0;
char* data = (char*)D2ReadFile(mempool, STATS_INTERFACE_FILENAME, (DWORD*)&nbSize, __FILE__, __LINE__);
if (!data || nbSize <= 0)
{
D2FogAssert("statsinterface.txt missing", D2GetInstructionPointer(), __LINE__);
exit(1);
}
//statsInterface = (statsInterfaceBIN*)compileTxtFile(mempool, STATS_INTERFACE_FILENAME, TableDesc, (DWORD*)&nbStatsInterface, sizeof(statsInterfaceBIN));
//statsInterface = (statsInterfaceBIN*)compileTxtFile((DWORD)nbSize, data, TableDesc, (DWORD*)&nbStatsInterface, sizeof(statsInterfaceBIN));
*/
/*
nbStatsInterface = 0;
for (int i = 0; i<nbSize;i++)
if (data[i] == '\n') nbStatsInterface++;
if (data[nbSize - 1] != '\n') nbStatsInterface++;
nbStatsInterface--;
statsInterface = (statsInterfaceBIN*)D2FogMemAlloc(nbStatsInterface * sizeof(statsInterfaceBIN),__FILE__,__LINE__,0);
strtok(data,"\n");
for (i=0; i<nbStatsInterface; i++)
{
strtok(NULL,"\t");
statsInterface[i].enabled = atoi(strtok(NULL,"\t"));
statsInterface[i].page = atoi(strtok(NULL,"\t"));
statsInterface[i].x = atoi(strtok(NULL,"\t"));
statsInterface[i].y = atoi(strtok(NULL,"\t"));
statsInterface[i].color = atoi(strtok(NULL,"\t"));
statsInterface[i].font = atoi(strtok(NULL,"\t"));
statsInterface[i].statsID = atoi(strtok(NULL,"\t"));
strtok(NULL,"\n");
log_msg("stats : %d, %d, %d, %d, %d, %d, %d\n", statsInterface[i].enabled, statsInterface[i].page, statsInterface[i].x, statsInterface[i].y, statsInterface[i].color, statsInterface[i].font, statsInterface[i].statsID);
}
*/
lastPage = 0; lastPage = 0;
for (i=0; i<nbStatsInterface; i++) for (i=0; i<nbStatsInterface; i++)
if (statsInterface[i].page > lastPage) if (statsInterface[i].page > lastPage)
lastPage = statsInterface[i].page; lastPage = statsInterface[i].page;
log_msg("loadStatsInterfaceDesc - fin\n");
} }
void freeStatsInterfaceDesc() void freeStatsInterfaceDesc()
@ -95,10 +138,164 @@ void freeStatsInterfaceDesc()
} }
} }
void printCharacterBreakpoints(Unit* ptChar, DWORD x, DWORD y, DWORD color, LPWSTR lpText)
{
CharStatsBIN* charStatsBIN = D2GetCharStatsBIN(ptChar->nPlayerClass);
swprintf(lpText, L"%s : %s", getLocalString(STR_BREAKPOINTS), charStatsBIN->nameU);
D2PrintString(lpText, x, y, color, 0); y+=33;
D2SetFont(6);
LPWSTR sBreakpoint = getLocalString(STR_BREAKPOINT);
LPWSTR sBlockFrames = getLocalString(STR_BLOCK_FRAMES);
LPWSTR sCastingFrames = getLocalString(STR_CASTING_FRAMES);
LPWSTR sHitRecoveryFrames = getLocalString(STR_HIT_RECOVERY_FRAMES);
LPWSTR s1HSwingingWeapon = getLocalString(STR_1H_SWINGING_WEAPON);
LPWSTR sOtherWeapon = getLocalString(STR_OTHER_WEAPONS);
LPWSTR sHumanForm = getLocalString(STR_HUMAN_FORM);
LPWSTR sBearForm = getLocalString(STR_BEAR_FORM);
LPWSTR sWolfForm = getLocalString(STR_WOLF_FORM);
LPWSTR sVampireForm = getLocalString(STR_VAMPIRE_FORM);
LPWSTR sHolyShield = D2GetStringFromIndex(0x12EC);
LPWSTR sSpearsAndStaves= getLocalString(STR_SPEARS_AND_STAVES);
LPWSTR sLightningAndChainLightnings = getLocalString(STR_LIGHTNING_CHAIN_LIGHTNING);
switch (ptChar->nPlayerClass)
{
case D2PC_AMAZON:
swprintf(lpText, L"%s:%s\n%s - %s: %d", sBreakpoint, L"4 6 11 15 23 29 40 56 80 120 200 480", sBlockFrames, s1HSwingingWeapon, 17);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"13 32 86 600", sBlockFrames, sOtherWeapon, 5);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"7 14 22 32 48 68 99 152", sCastingFrames, 19);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"6 13 20 32 52 86 174 600", sHitRecoveryFrames, 11);
D2PrintString(lpText, x, y, color, 0); y+=29;
break;
case D2PC_ASSASSIN:
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"13 32 86 600", sBlockFrames, 5);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"8 16 27 42 65 102 174", sCastingFrames, 16);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"7 15 27 48 86 200", sHitRecoveryFrames, 9);
D2PrintString(lpText, x, y, color, 0); y+=29;
break;
case D2PC_BARBARIAN:
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"9 20 42 86 280", sBlockFrames, 7);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"9 20 37 63 105 200", sCastingFrames, 13);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"7 15 27 48 86 200", sHitRecoveryFrames, 9);
D2PrintString(lpText, x, y, color, 0); y+=29;
break;
case D2PC_DRUID:
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"6 13 20 32 52 86 174 600", sBlockFrames, sHumanForm, 11);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"5 10 16 27 40 65 109 223", sBlockFrames, sBearForm, 12);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"7 15 27 48 86 200", sBlockFrames, sWolfForm, 9);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"4 10 19 30 46 68 99 163", sCastingFrames, sHumanForm, 18);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"7 15 26 40 63 99 163", sCastingFrames, sBearForm, 16);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"6 14 26 40 60 95 157", sCastingFrames, sWolfForm, 16);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"3 7 13 19 29 42 63 99 174 456", sHitRecoveryFrames, s1HSwingingWeapon, 14);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"5 10 16 26 39 56 86 152 377", sHitRecoveryFrames, sOtherWeapon, 13);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"5 10 16 24 37 54 86 152 360", sHitRecoveryFrames, sBearForm, 13);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"9 20 42 86 280", sHitRecoveryFrames, sWolfForm, 7);
D2PrintString(lpText, x, y, color, 0); y+=29;
break;
case D2PC_NECROMANCER:
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"6 13 20 32 52 86 174 600", sBlockFrames, 11);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"9 18 30 48 75 125", sCastingFrames, sHumanForm, 15);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"6 11 18 24 35 48 65 86 120 180", sCastingFrames, sVampireForm, 23);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"5 10 16 26 39 56 86 152 377", sHitRecoveryFrames, sHumanForm, 13);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"2 6 10 16 24 34 48 72 117", sHitRecoveryFrames, sVampireForm, 15);
D2PrintString(lpText, x, y, color, 0); y+=29;
break;
case D2PC_PALADIN:
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"13 32 86 600", sBlockFrames, 5);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"86", sBlockFrames, sHolyShield, 2);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"9 18 30 48 75 125", sCastingFrames, 15);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"3 7 13 20 32 48 75 129 280", sHitRecoveryFrames, sSpearsAndStaves, 13);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"7 15 27 48 86 200", sHitRecoveryFrames, sOtherWeapon, 9);
D2PrintString(lpText, x, y, color, 0); y+=29;
break;
case D2PC_SORCERESS:
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"7 15 27 48 86 200", sBlockFrames, 9);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"9 20 37 63 105 200", sCastingFrames, 13);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"7 15 23 35 52 78 117 194", sCastingFrames, sLightningAndChainLightnings, 19);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s: %d", sBreakpoint, L"5 9 14 20 30 42 60 86 142 280", sHitRecoveryFrames, 15);
D2PrintString(lpText, x, y, color, 0); y+=29;
break;
}
}
void printMercBreakpoints(Unit* ptChar, DWORD x, DWORD y, DWORD color, LPWSTR lpText)
{
LPWSTR sBreakpoint = getLocalString(STR_BREAKPOINT);
LPWSTR sCastingFrames = getLocalString(STR_CASTING_FRAMES);
LPWSTR sHitRecoveryFrames = getLocalString(STR_HIT_RECOVERY_FRAMES);
swprintf(lpText, L"%s : %s", getLocalString(STR_BREAKPOINTS), getLocalString(STR_MERCENARIES));
D2PrintString(lpText, x, y, color, 0); y+=33;
D2SetFont(6);
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"8 15 26 39 58 86 138", sCastingFrames, getLocalString(STR_MERC_ACT_3), 17);
D2PrintString(lpText, x, y, color, 0); y+=29;
y+=13;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"6 13 20 32 52 86 174 600", sHitRecoveryFrames, getLocalString(STR_MERC_ACT_1), 11);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"5 9 14 20 30 42 60 86 142 280", sHitRecoveryFrames, getLocalString(STR_MERC_ACT_2), 15);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"5 8 13 18 24 32 46 63 86 133 232 600", sHitRecoveryFrames, getLocalString(STR_MERC_ACT_3), 17);
D2PrintString(lpText, x, y, color, 0); y+=29;
swprintf(lpText, L"%s : %s\n%s - %s: %d", sBreakpoint, L"7 15 27 48 86 200", sHitRecoveryFrames, getLocalString(STR_MERC_ACT_5), 9);
D2PrintString(lpText, x, y, color, 0); y+=29;
}
void printStat(Unit* ptChar, DWORD statID, DWORD x, DWORD y, DWORD color, LPWSTR lpText) void printStat(Unit* ptChar, DWORD statID, DWORD x, DWORD y, DWORD color, LPWSTR lpText)
{ {
LPWSTR text; LPWSTR text;
log_msg("printStat : %d\n", statID);
switch (statID) switch (statID)
{ {
case STATS_FIRERESIST: case STATS_FIRERESIST:
@ -106,9 +303,15 @@ void printStat(Unit* ptChar, DWORD statID, DWORD x, DWORD y, DWORD color, LPWSTR
case STATS_LIGHTRESIST: case STATS_LIGHTRESIST:
case STATS_POISONRESIST: case STATS_POISONRESIST:
text = D2GetStringFromIndex(getDescStrPos(statID)); text = D2GetStringFromIndex(getDescStrPos(statID));
if (wcslen(text) > 50) return; if (wcslen(text) > BUFSIZE) return;
swprintf(lpText, L"%s +%i%%", text, D2GetPlayerStat(ptChar,statID,0)); swprintf(lpText, L"%s +%i%%", text, D2GetPlayerStat(ptChar,statID,0));
break; break;
case 10000:
printCharacterBreakpoints(ptChar, x, y, color, lpText);
return;
case 10001:
printMercBreakpoints(ptChar, x, y, color, lpText);
return;
default: default:
D2PrintStat(ptChar, NULL, statID, 0, D2GetPlayerStat(ptChar,statID,0), lpText);//param2=ptChar->ptStats->ptItemStats D2PrintStat(ptChar, NULL, statID, 0, D2GetPlayerStat(ptChar,statID,0), lpText);//param2=ptChar->ptStats->ptItemStats
} }
@ -138,8 +341,7 @@ void STDCALL printNewStatsPageTwo(int currentPage)
WCHAR text[BUFSIZE]; WCHAR text[BUFSIZE];
LPWSTR lpText; LPWSTR lpText;
bDontPrintBorder = false; bDontPrintBorder = D2GetResolution()? true : false;
Unit* ptChar = D2GetClientPlayer(); Unit* ptChar = D2GetClientPlayer();
d2_assert(!ptChar, "Printing stats page : no character selected",__FILE__,__LINE__); d2_assert(!ptChar, "Printing stats page : no character selected",__FILE__,__LINE__);
@ -150,16 +352,20 @@ void STDCALL printNewStatsPageTwo(int currentPage)
ZeroMemory(&data,sizeof(data)); ZeroMemory(&data,sizeof(data));
//print background //print background
fillRect(RX(0),RY(480),320,432,0,5);//552 fillRect(RX(0), RY(ResolutionY), 512, 768, 0, 5);
setImage(&data, newStatsInterfaceImages); setImage(&data, newStatsInterfaceImages);
setFrame(&data, 0); setFrame(&data, 0);
D2PrintImage(&data, RX(0), RY(224), -1, 5, 0); D2PrintImage(&data, RX(0), RY(ResolutionY-256), -1, 5, 0);
setFrame(&data, 1); setFrame(&data, 1);
D2PrintImage(&data, RX(256),RY(224), -1, 5, 0);//256 D2PrintImage(&data, RX(256),RY(ResolutionY-256), -1, 5, 0);
setFrame(&data, 2); setFrame(&data, 2);
D2PrintImage(&data, RX(0), RY(48), -1, 5, 0);//432 D2PrintImage(&data, RX(0), RY(ResolutionY-256*2), -1, 5, 0);
setFrame(&data, 3); setFrame(&data, 3);
D2PrintImage(&data, RX(256),RY(48), -1, 5, 0); D2PrintImage(&data, RX(256),RY(ResolutionY-256*2), -1, 5, 0);
setFrame(&data, 4);
D2PrintImage(&data, RX(0), RY(ResolutionY-256*3), -1, 5, 0);
setFrame(&data, 5);
D2PrintImage(&data, RX(256),RY(ResolutionY-256*3), -1, 5, 0);
D2SetFont(1); D2SetFont(1);
for (int i=0; i<nbStatsInterface; i++) for (int i=0; i<nbStatsInterface; i++)
@ -193,10 +399,12 @@ void STDCALL printNewStatsPageTwo(int currentPage)
D2PrintString(text, x, y, WHITE, 0); D2PrintString(text, x, y, WHITE, 0);
*/ */
if (printBackgroundOnMainPage) {
//print background previous/next page buttons //print background previous/next page buttons
setImage(&data, statsBackgroundImages); setImage(&data, statsBackgroundImages);
setFrame(&data, D2GetResolution()?1:0); setFrame(&data, 1);
D2PrintImage(&data, getXPreviousPageBtn()-7, getYPreviousPageBtn()+8, -1, 5, 0); D2PrintImage(&data, getXPreviousPageBtn()-7, getYPreviousPageBtn()+8, -1, 5, 0);
}
//print button close //print button close
setImage(&data, D2LoadBuySelBtn()); setImage(&data, D2LoadBuySelBtn());
@ -211,7 +419,6 @@ void STDCALL printNewStatsPageTwo(int currentPage)
setFrame(&data, 14 + isDownBtn.nextPage); setFrame(&data, 14 + isDownBtn.nextPage);
D2PrintImage(&data, getXNextPageBtn(), getYNextPageBtn(), -1, 5, 0); D2PrintImage(&data, getXNextPageBtn(), getYNextPageBtn(), -1, 5, 0);
//////////////////// POPUP PRINTING //////////////////// //////////////////// POPUP PRINTING ////////////////////
//set MouseX & MouseY //set MouseX & MouseY
DWORD mx = D2GetMouseX(); DWORD mx = D2GetMouseX();

248
PlugY/NewInterfaces.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Interface functions Interface functions
@ -21,11 +22,39 @@ bool active_newInterfaces=false;
bool selectMainPageOnOpenning=true; bool selectMainPageOnOpenning=true;
bool printBackgroundOnMainPage=true; bool printBackgroundOnMainPage=true;
int posXNextPageBtn = -1;
int posYNextPageBtn = -1;
int posXPrevPageBtn = -1;
int posYPrevPageBtn = -1;
int posXClosePageBtn = -1;
int posYClosePageBtn = -1;
int posXNextRuneBtn = -1;
int posYNextRuneBtn = -1;
int posXPrevRuneBtn = -1;
int posYPrevRuneBtn = -1;
int posXRunesList = -1;
int posYRunesList = -1;
int runesPerPage = -1;
DWORD getXNextPageBtn() {return RX(posXNextPageBtn);}
DWORD getYNextPageBtn() {return RY(posYNextPageBtn);}
DWORD getXPreviousPageBtn() {return RX(posXPrevPageBtn);}
DWORD getYPreviousPageBtn() {return RY(posYPrevPageBtn);}
DWORD getXCloseBtn() {return RX(posXClosePageBtn);}
DWORD getYCloseBtn() {return RY(posYClosePageBtn);}
DWORD getXNextRunesBtn() {return RX(posXNextRuneBtn);}
DWORD getYNextRunesBtn() {return RY(posYNextRuneBtn);}
DWORD getXPrevRunesBtn() {return RX(posXPrevRuneBtn);}
DWORD getYPrevRunesBtn() {return RY(posYPrevRuneBtn);}
DWORD bDontPrintBorder=false; DWORD bDontPrintBorder=false;
int selectedPage=0; int selectedPage=0;
int lastPage=0; int lastPage=0;
int extraHiddenPage=0; int extraHiddenPage=0;
int curRunesPage=0;
int maxRunesPage=0xFFFF;
BtnState isDownBtn={0};
void GoNextStatPage() void GoNextStatPage()
{ {
@ -43,8 +72,12 @@ void GoPreviousStatPage()
void GoStatPage(int page) void GoStatPage(int page)
{ {
if ( (page >= 0) && (page <= lastPage + (D2GetResolution()? extraHiddenPage : 0)) ) if ( (page >= 0) && (page <= (lastPage + extraHiddenPage)) )
selectedPage = page; selectedPage = page;
else if (page < 0)
selectedPage = lastPage + extraHiddenPage;
else
selectedPage = 0;
} }
int GetCurrentPage() int GetCurrentPage()
@ -82,6 +115,16 @@ DWORD STDCALL mouseCustomPageLeftDown(sWinMessage* msg)
DWORD STDCALL mouseCustomPageLeftUp(sWinMessage* msg) DWORD STDCALL mouseCustomPageLeftUp(sWinMessage* msg)
{ {
if(onRealm) return -1; if(onRealm) return -1;
if (selectedPage == 0) return -1;
if (!isOnStatsPage(msg->x,msg->y)) return 1;
statsLeftUp(msg);
D2CleanStatMouseUp();
freeMessage(msg);
isDownBtn.all=0;
return 0;
/*
if ( (selectedPage > 0) && (selectedPage <= lastPage) ) if ( (selectedPage > 0) && (selectedPage <= lastPage) )
return mouseNewStatsPageTwoLeftUp(msg); return mouseNewStatsPageTwoLeftUp(msg);
else if (selectedPage == lastPage+1) else if (selectedPage == lastPage+1)
@ -90,8 +133,103 @@ DWORD STDCALL mouseCustomPageLeftUp(sWinMessage* msg)
return mouseNewStatsPageLeftUp(msg); return mouseNewStatsPageLeftUp(msg);
else else
return -1; return -1;
*/
} }
DWORD STDCALL statsLeftDown(sWinMessage* msg)
{
if (isOnCloseBtn(msg->x,msg->y) && selectedPage != 0)
{
log_msg("push down left button close\n");
isDownBtn.close = 1;
D2PlaySound(4,0,0,0,0);
return 1;
}
else if (isOnPreviousPageBtn(msg->x,msg->y))
{
log_msg("push down left button previous page\n");
isDownBtn.previousPage = 1;
D2PlaySound(4,0,0,0,0);
return 1;
}
else if (isOnNextPageBtn(msg->x,msg->y))
{
log_msg("push down left button next page\n");
isDownBtn.nextPage = 1;
D2PlaySound(4,0,0,0,0);
return 1;
}
else if (isOnPrevRunesBtn(msg->x,msg->y) && selectedPage == (lastPage + extraHiddenPage))
{
log_msg("push down left button prev runes\n");
isDownBtn.prevRunes = 1;
D2PlaySound(4,0,0,0,0);
return 1;
}
else if (isOnNextRunesBtn(msg->x,msg->y) && selectedPage == (lastPage + extraHiddenPage))
{
log_msg("push down left button next runes\n");
isDownBtn.nextRunes = 1;
D2PlaySound(4,0,0,0,0);
return 1;
}
return 0;
}
DWORD STDCALL statsLeftUp(sWinMessage* msg)
{
if (isOnCloseBtn(msg->x,msg->y) && selectedPage != 0)
{
log_msg("push up left button close\n");
if (isDownBtn.close)
D2TogglePage(2,1,0);
return 1;
}
else if (isOnPreviousPageBtn(msg->x,msg->y))
{
log_msg("push up left button previous page\n");
if (isDownBtn.previousPage)
GoStatPage(selectedPage-1);
return 1;
}
else if (isOnNextPageBtn(msg->x,msg->y))
{
log_msg("push up left button next page\n");
if (isDownBtn.nextPage)
GoStatPage(selectedPage+1);
return 1;
}
else if (isOnPrevRunesBtn(msg->x,msg->y) && selectedPage == (lastPage + extraHiddenPage))
{
log_msg("push up left button prev runes\n");
if (isDownBtn.prevRunes && curRunesPage)
curRunesPage--;
return 1;
}
else if (isOnNextRunesBtn(msg->x,msg->y) && selectedPage == (lastPage + extraHiddenPage))
{
log_msg("push up left button next runes\n");
if (isDownBtn.nextRunes && (curRunesPage < maxRunesPage))
curRunesPage++;
return 1;
}
return 0;
}
FCT_ASM ( caller_DontPrintBorder_114 )
MOV ECX,bDontPrintBorder
TEST ECX,ECX
JE printBorder
MOV bDontPrintBorder,0
ADD DWORD PTR SS:[ESP],0xC1
RETN
printBorder:
POP ECX
PUSH 0x48
LEA EAX,DWORD PTR SS:[EBP-0x48]
JMP ECX
}}
FCT_ASM ( caller_DontPrintBorder_111 ) FCT_ASM ( caller_DontPrintBorder_111 )
MOV ECX,bDontPrintBorder MOV ECX,bDontPrintBorder
TEST ECX,ECX TEST ECX,ECX
@ -116,6 +254,30 @@ printBorder:
RETN RETN
}} }}
FCT_ASM ( caller_mouseCustomPageLeftDown_114 )
PUSH EAX
PUSH ESI
CALL mouseCustomPageLeftDown
TEST EAX,EAX
POP EAX
JE end_mouseNewPageLDown
JG continue_mouseNewPageLDown
LEA ECX,DWORD PTR DS:[EAX+0x80]
RETN
continue_mouseNewPageLDown:
POP EAX
ADD EAX,0x172
PUSH EDI
JMP EAX
RETN
end_mouseNewPageLDown:
ADD ESP,4
POP ESI
POP EBX
POP EBP
RETN 4
}}
FCT_ASM ( caller_mouseCustomPageLeftDown_111 ) FCT_ASM ( caller_mouseCustomPageLeftDown_111 )
PUSH EAX PUSH EAX
@ -185,7 +347,27 @@ end_mouseNewPageLDown:
RETN 4 RETN 4
}} }}
FCT_ASM ( caller_mouseCustomPageLeftUp_114 )
PUSH EBP
CALL mouseCustomPageLeftUp
TEST EAX,EAX
JE end_mouseNewPageLUp
JG continue_mouseNewPageLUp
MOV EAX,DWORD PTR DS:[ptWindowStartX]
MOV EAX,DWORD PTR DS:[EAX]
RETN
continue_mouseNewPageLUp:
ADD DWORD PTR SS:[ESP],0x17D
RETN
end_mouseNewPageLUp:
ADD ESP,4
POP EDI
POP ESI
POP EBX
MOV ESP,EBP
POP EBP
RETN 4
}}
FCT_ASM ( caller_mouseCustomPageLeftUp_111 ) FCT_ASM ( caller_mouseCustomPageLeftUp_111 )
PUSH EBP PUSH EBP
@ -257,7 +439,18 @@ end_mouseNewPageLUp:
FCT_ASM ( caller_resetSelected_114 )
CMP ECX,2
JNZ NO_RESET
MOV selectedPage, 0
NO_RESET:
POP EAX
PUSH EBX
PUSH ESI
PUSH EDI
MOV EDI,ECX
JMP EAX
}}
FCT_ASM ( caller_resetSelectedPageByToolBar ) FCT_ASM ( caller_resetSelectedPageByToolBar )
@ -306,12 +499,22 @@ void Install_NewInterfaces()
if (selectMainPageOnOpenning) if (selectMainPageOnOpenning)
{ {
if ( version_D2Client >= V111 ) if ( version_D2Client >= V114a )
{
mem_seek R8(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 55F24);
memt_byte( 0x53, 0xE8 ); // CALL caller_resetSelectedPage
MEMT_REF4( 0xF98B5756, caller_resetSelected_114);
//00455F24 |. 53 PUSH EBX
//00455F25 |. 56 PUSH ESI
//00455F26 |. 57 PUSH EDI
//00455F27 |. 8BF9 MOV EDI,ECX
}
else if ( version_D2Client >= V111 )
{ {
//Reset selectedPage variable on opening stats page //Reset selectedPage variable on opening stats page
mem_seek R7(D2Client, 0000, 0000, 0000, 4B79E, 8F73E, 55E0E, 65F5E, C41FE); mem_seek R8(D2Client, 0000, 0000, 0000, 4B79E, 8F73E, 55E0E, 65F5E, C41FE, 7EC5C);
memt_byte( 0x83, 0xE8 ); // CALL caller_resetSelectedPage memt_byte( version_D2Client == V114d ? 0xB9 : 0x83, 0xE8 ); // CALL caller_resetSelectedPage
MEMT_REF4( 0x1F7426F8, caller_resetSelectedPageByToolBar); MEMT_REF4( version_D2Client == V114d ? 0x00000002 : 0x1F7426F8, caller_resetSelectedPageByToolBar);
//6FAFB79E > 83F8 26 CMP EAX,26 //6FAFB79E > 83F8 26 CMP EAX,26
//6FAFB7A1 . 74 1F JE SHORT D2Client.6FAFB7C2 //6FAFB7A1 . 74 1F JE SHORT D2Client.6FAFB7C2
//6FB3F73E > 83F8 26 CMP EAX,26 //6FB3F73E > 83F8 26 CMP EAX,26
@ -322,8 +525,11 @@ void Install_NewInterfaces()
//6FB15F61 . 74 1F JE SHORT D2Client.6FB15F82 //6FB15F61 . 74 1F JE SHORT D2Client.6FB15F82
//6FB741FE > 83F8 26 CMP EAX,26 //6FB741FE > 83F8 26 CMP EAX,26
//6FB74201 . 74 1F JE SHORT D2Client.6FB05E32 //6FB74201 . 74 1F JE SHORT D2Client.6FB05E32
//6FB741FE > 83F8 26 CMP EAX,26
//6FB74201 . 74 1F JE SHORT D2Client.6FB74222
//0047EC5C > B9 02000000 MOV ECX,2
mem_seek R7(D2Client, 0000, 0000, 0000, 1E55A, 6A8FA, A31DA, 3C5EA, 3E39A); mem_seek R8(D2Client, 0000, 0000, 0000, 1E55A, 6A8FA, A31DA, 3C5EA, 3E39A, 0000);
memt_byte( 0x55, 0xE8 ); // CALL caller_resetSelectedPage memt_byte( 0x55, 0xE8 ); // CALL caller_resetSelectedPage
MEMT_REF4( 0xD53BED33, caller_resetSelectedPageByKey); MEMT_REF4( 0xD53BED33, caller_resetSelectedPageByKey);
//6FACE55A . 55 PUSH EBP //6FACE55A . 55 PUSH EBP
@ -358,7 +564,7 @@ void Install_NewInterfaces()
//6FB3EF92 |. 3928 CMP DWORD PTR DS:[EAX],EBP //6FB3EF92 |. 3928 CMP DWORD PTR DS:[EAX],EBP
} else { } else {
//Reset selectedPage variable on opening stats page //Reset selectedPage variable on opening stats page
mem_seek R7(D2Client, 88B58, 87ED8, 83478, A1FBE, 6571E, 8EF8E, 0000, 0000);//((DWORD)D2TogglePage+0x218); mem_seek R8(D2Client, 88B58, 87ED8, 83478, A1FBE, 6571E, 8EF8E, 0000, 0000, 0000);//((DWORD)D2TogglePage+0x218);
memt_byte( 0x85, 0xE8 ); // CALL caller_resetSelectedPage memt_byte( 0x85, 0xE8 ); // CALL caller_resetSelectedPage
MEMT_REF4( 0xC2940FC0, caller_resetSelectedPage); MEMT_REF4( 0xC2940FC0, caller_resetSelectedPage);
//6FB23478 |. 85C0 TEST EAX,EAX //6FB23478 |. 85C0 TEST EAX,EAX
@ -368,7 +574,7 @@ void Install_NewInterfaces()
} }
// Print custom page // Print custom page
mem_seek R7(D2Client, 87697, 86A17, 81FAB, A3759, 66B59, 902B9, C3B49, 1D549); mem_seek R8(D2Client, 87697, 86A17, 81FAB, A3759, 66B59, 902B9, C3B49, 1D549, 57052);
MEMC_REF4( D2PrintStatsPage, printCustomPage); MEMC_REF4( D2PrintStatsPage, printCustomPage);
//6FB21FAA . E8 B1DDFAFF CALL D2Client.6FACFD60 //6FB21FAA . E8 B1DDFAFF CALL D2Client.6FACFD60
//6FB53758 . E8 43F1FDFF CALL D2Client.6FB328A0 //6FB53758 . E8 43F1FDFF CALL D2Client.6FB328A0
@ -376,22 +582,26 @@ void Install_NewInterfaces()
//6FB402B8 |. E8 C3AFFDFF CALL D2Client.6FB1B280 //6FB402B8 |. E8 C3AFFDFF CALL D2Client.6FB1B280
//6FB73B48 |. E8 5393FFFF CALL D2Client.6FB6CEA0 //6FB73B48 |. E8 5393FFFF CALL D2Client.6FB6CEA0
//6FACD548 |. E8 F3200A00 CALL D2Client.6FB1B280 //6FACD548 |. E8 F3200A00 CALL D2Client.6FB1B280
//00457051 |. E8 AA0C0500 CALL Game.004A7D00
// Don't print Border // Don't print Border
mem_seek R7(D2Client, 58EF6, 58EF6, 5F4C6, 2D366, B5A46, 82166, 271C6, 6D2B6); mem_seek R8(D2Client, 58EF6, 58EF6, 5F4C6, 2D366, B5A46, 82166, 271C6, 6D2B6, 98636);
memt_byte( 0xB9, 0xE8 ); // CALL caller_DontPrintBorder memt_byte( version_D2Client >= V114d ? 0x6A : 0xB9, 0xE8 ); // CALL caller_DontPrintBorder
MEMT_REF4( 0x00000012, version_D2Client >= V111 ? caller_DontPrintBorder_111 : caller_DontPrintBorder); MEMT_REF4( version_D2Client >= V114d ? 0xB8458D48 : 0x00000012, version_D2Client >= V114d ? caller_DontPrintBorder_114 : version_D2Client >= V111 ? caller_DontPrintBorder_111 : caller_DontPrintBorder);
//6FAFF4C6 > B9 12000000 MOV ECX,12 //6FAFF4C6 > B9 12000000 MOV ECX,12
//6FADD366 |. B9 12000000 MOV ECX,12 //6FADD366 |. B9 12000000 MOV ECX,12
//6FB65A46 |. B9 12000000 MOV ECX,12 //6FB65A46 |. B9 12000000 MOV ECX,12
//6FB32166 |. B9 12000000 MOV ECX,12 //6FB32166 |. B9 12000000 MOV ECX,12
//6FAD71C6 |. B9 12000000 MOV ECX,12 //6FAD71C6 |. B9 12000000 MOV ECX,12
//6FB1D2B6 |. B9 12000000 MOV ECX,12 //6FB1D2B6 |. B9 12000000 MOV ECX,12
//00498636 |. 6A 48 PUSH 48
//00498638 |. 8D45 B8 LEA EAX,DWORD PTR SS:[EBP-48]
/* Conflicts with D2ExpRes
// Manage mouse down (Play sound) // Manage mouse down (Play sound)
mem_seek R7(D2Client, 2A9DC, 2A9CC, 312A5, 82736, 891B6, 6B116, BCD36, BF4D6); mem_seek R8(D2Client, 2A9DC, 2A9CC, 312A5, 82736, 891B6, 6B116, BCD36, BF4D6, A7731);
memt_byte( 0x8D, 0xE8 ); // CALL memt_byte( 0x8D, 0xE8 ); // CALL
MEMT_REF4( 0x00008088, version_D2Client >= V111 ? caller_mouseCustomPageLeftDown_111 : version_D2Client == V110 ? caller_mouseCustomPageLeftDown : caller_mouseCustomPageLeftDown_9); MEMT_REF4( 0x00008088, version_D2Client == V114d ? caller_mouseCustomPageLeftDown_114 : version_D2Client >= V111 ? caller_mouseCustomPageLeftDown_111 : version_D2Client == V110 ? caller_mouseCustomPageLeftDown : caller_mouseCustomPageLeftDown_9);
memt_byte( 0x00, 0x90 ); // NOP memt_byte( 0x00, 0x90 ); // NOP
//6FAD12A5 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80] //6FAD12A5 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//6FB32736 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80] //6FB32736 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
@ -399,18 +609,20 @@ void Install_NewInterfaces()
//6FB1B116 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80] //6FB1B116 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//6FB6CD36 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80] //6FB6CD36 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//6FB6F4D6 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80] //6FB6F4D6 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
//004A7731 . 8D88 80000000 LEA ECX,DWORD PTR DS:[EAX+80]
*/
// Manage mouse up // Manage mouse up
mem_seek R7(D2Client, 2ABBB, 2ABAB, 3148D, 836D9, 8A159, 6C0B9, BDCB9, C0459); mem_seek R8(D2Client, 2ABBB, 2ABAB, 3148D, 836D9, 8A159, 6C0B9, BDCB9, C0459, A78DA);
memt_byte( 0xA1, 0xE8 ); // CALL caller_mouseCustomPageLeftUp memt_byte( 0xA1, 0xE8 ); // CALL caller_mouseCustomPageLeftUp
MEMT_REF4( ptWindowStartX, version_D2Client >= V111 ? caller_mouseCustomPageLeftUp_111 : version_D2Client == V110 ? caller_mouseCustomPageLeftUp : caller_mouseCustomPageLeftUp_9); MEMT_REF4( ptWindowStartX, version_D2Client >= V114d ? caller_mouseCustomPageLeftUp_114 : version_D2Client >= V111 ? caller_mouseCustomPageLeftUp_111 : version_D2Client == V110 ? caller_mouseCustomPageLeftUp : caller_mouseCustomPageLeftUp_9);
//6FAD148D . A1 48A7BB6F MOV EAX,DWORD PTR DS:[6FBBA748] //6FAD148D . A1 48A7BB6F MOV EAX,DWORD PTR DS:[6FBBA748]
//6FB336D9 . A1 24BDBC6F MOV EAX,DWORD PTR DS:[6FBCBD24] //6FB336D9 . A1 24BDBC6F MOV EAX,DWORD PTR DS:[6FBCBD24]
//6FB3A159 . A1 F8BEBC6F MOV EAX,DWORD PTR DS:[6FBCBEF8] //6FB3A159 . A1 F8BEBC6F MOV EAX,DWORD PTR DS:[6FBCBEF8]
//6FB1C0B9 . A1 28BDBC6F MOV EAX,DWORD PTR DS:[6FBCBD28] //6FB1C0B9 . A1 28BDBC6F MOV EAX,DWORD PTR DS:[6FBCBD28]
//6FB6DCB9 . A1 A0B9BC6F MOV EAX,DWORD PTR DS:[6FBCB9A0] //6FB6DCB9 . A1 A0B9BC6F MOV EAX,DWORD PTR DS:[6FBCB9A0]
//6FB70459 . A1 54D3BC6F MOV EAX,DWORD PTR DS:[6FBCD354] //6FB70459 . A1 54D3BC6F MOV EAX,DWORD PTR DS:[6FBCD354]
//004A78DA |. A1 58287A00 MOV EAX,DWORD PTR DS:[7A2858]
// open page : 6FB23515 |> 892CB5 A8A6BB6>MOV DWORD PTR DS:[ESI*4+6FBBA6A8],EBP // open page : 6FB23515 |> 892CB5 A8A6BB6>MOV DWORD PTR DS:[ESI*4+6FBBA6A8],EBP
//6FB2347D |. 8914B5 A8A6BB6F MOV DWORD PTR DS:[ESI*4+6FBBA6A8],EDX //6FB2347D |. 8914B5 A8A6BB6F MOV DWORD PTR DS:[ESI*4+6FBBA6A8],EDX

4
PlugY/OthersFeatures.cpp
View File

@ -9,7 +9,6 @@
bool active_othersFeatures = false; bool active_othersFeatures = false;
/* /*
// Remove protect on the save file .d2s // Remove protect on the save file .d2s
mem_seek( offset_D2Game + 0x77080);//6FC8DD5E-6FAA0000 mem_seek( offset_D2Game + 0x77080);//6FC8DD5E-6FAA0000
@ -111,8 +110,6 @@ void Install_Test2()
isInstalled = true; isInstalled = true;
}*/ }*/
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
void Install_OthersFeatures() void Install_OthersFeatures()
{ {
static int isInstalled = false; static int isInstalled = false;
@ -120,6 +117,7 @@ void Install_OthersFeatures()
log_msg("Patch. (OthersFeatures)\n"); log_msg("Patch. (OthersFeatures)\n");
// Install_RemoveExperienceDiminushingReturn();
// Install_ChangeResolution(); // Install_ChangeResolution();
// Install_Test(); // Install_Test();

630
PlugY/Parameters.cpp
View File

@ -1,5 +1,6 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add DoNotCloseNihlathakPortal by haxifix.
Loading parameters from ini file. Loading parameters from ini file.
@ -13,9 +14,9 @@
#include <time.h> #include <time.h>
#define PARAMETERS_FILENAME "PlugY.ini" const char* PARAMETERS_FILENAME = "PlugY.ini";
#define PARAM_FIXED_FILENAME "PlugY\\PlugYFixed.ini" const char* PARAM_FIXED_FILENAME = "PlugY\\PlugYFixed.ini";
#define PARAM_DEFAULT_FILENAME "PlugY\\PlugYDefault.ini" const char* PARAM_DEFAULT_FILENAME = "PlugY\\PlugYDefault.ini";
#define BUFSIZE 0x400 #define BUFSIZE 0x400
@ -35,6 +36,7 @@
#include "commands.h" #include "commands.h"
#include "language.h" #include "language.h"
#include "windowed.h" #include "windowed.h"
#include "savePlayerData.h"
char* modDataDirectory = "PlugY"; char* modDataDirectory = "PlugY";
@ -48,14 +50,15 @@ TargetMod selectModParam = MOD_NO;
const char* S_GENERAL = "GENERAL"; const char* S_GENERAL = "GENERAL";
const char* S_dllFilenames = "DllToLoad";
const char* S_dllFilenames2 = "DllToLoad2";
const char* S_active_plugin = "ActivePlugin"; const char* S_active_plugin = "ActivePlugin";
const char* S_active_DisableBattleNet = "DisableBattleNet"; const char* S_active_DisableBattleNet = "DisableBattleNet";
const char* S_active_logFile = "ActiveLogFile"; const char* S_active_logFile = "ActiveLogFile";
const char* S_active_CheckMemory = "ActiveCheckMemory"; const char* S_dllFilenames = "DllToLoad";
const char* S_dllFilenames2 = "DllToLoad2";
const char* S_active_Commands = "ActiveCommands"; const char* S_active_Commands = "ActiveCommands";
const char* S_active_CheckMemory = "ActiveCheckMemory";
const char* S_active_othersFeatures = "ActiveAllOthersFeatures"; const char* S_active_othersFeatures = "ActiveAllOthersFeatures";
const char* S_saveFileStackSize = "SaveFileStackSize";
const char* S_WINDOWED = "WINDOWED"; const char* S_WINDOWED = "WINDOWED";
const char* S_ActiveWindowed = "ActiveWindowed"; const char* S_ActiveWindowed = "ActiveWindowed";
@ -79,44 +82,76 @@ const char* S_availableLanguages = "AvailableLanguages";
const char* S_SAVEPATH = "SAVEPATH"; const char* S_SAVEPATH = "SAVEPATH";
const char* S_active_changingSavePath = "ActiveSavePathChange"; const char* S_active_changingSavePath = "ActiveSavePathChange";
const char* S_savePath = "SavePath"; const char* S_savePath = "SavePath";
const char* S_active_AutoBackup = "ActiveAutoBackup";
const char* S_maxBackupPerCharacter = "MaxBackupPerCharacter";
const char* S_MAIN_SCREEN = "MAIN SCREEN"; const char* S_MAIN_SCREEN = "MAIN SCREEN";
const char* S_active_VersionTextChange = "ActiveVersionTextChange"; const char* S_active_VersionTextChange = "ActiveVersionTextChange";
const char* S_active_VersionTextChanges = "ActiveVersionTextChanges";
const char* S_versionText = "VersionText"; const char* S_versionText = "VersionText";
const char* S_modVersionColor = "ColorOfVersionText"; const char* S_modVersionColor = "ColorOfVersionText";
const char* S_active_PrintPlugYVersion = "ActivePrintPlugYVersion"; const char* S_active_PrintPlugYVersion = "ActivePrintPlugYVersion";
const char* S_colorOfPlugYVersion = "ColorOfPlugYVersion"; const char* S_colorOfPlugYVersion = "ColorOfPlugYVersion";
const char* S_STASH = "STASH"; const char* S_STASH = "STASH";
const char* S_active_bigStash = "ActiveBigStash";
const char* S_active_multiPageStash = "ActiveMultiPageStash"; const char* S_active_multiPageStash = "ActiveMultiPageStash";
const char* S_maxSelfPages = "MaxPersonnalPages";
const char* S_nbPagesPerIndex = "NbPagesPerIndex"; const char* S_nbPagesPerIndex = "NbPagesPerIndex";
const char* S_nbPagesPerIndex2 = "NbPagesPerIndex2"; const char* S_nbPagesPerIndex2 = "NbPagesPerIndex2";
const char* S_active_sharedStash = "ActiveSharedStash"; const char* S_maxSelfPages = "MaxPersonnalPages";
const char* S_openSharedStashOnLoading = "OpenSharedStashOnLoading"; const char* S_autoRenameStashPage = "AutoRenameStashPage";
const char* S_maxSharedPages = "MaxSharedPages"; const char* S_PersonalNormalPageColor = "PersonalNormalPageColor";
const char* S_sharedStashFilename = "SharedStashFilename"; const char* S_PersonalIndexPageColor = "PersonalIndexPageColor";
const char* S_separateHardSoftStash = "SeparateHardcoreStash"; const char* S_PersonalMainIndexPageColor = "PersonalMainIndexPageColor";
const char* S_active_bigStash = "ActiveBigStash"; const char* S_SharedNormalPageColor = "SharedNormalPageColor";
const char* S_displaySharedSetItemNameInGreen = "DisplaySharedSetItemNameInGreen"; const char* S_SharedIndexPageColor = "SharedIndexPageColor";
const char* S_active_sharedGold = "ActiveSharedGold"; const char* S_SharedMainIndexPageColor = "SharedMainIndexPageColor";
const char* S_active_sharedStash = "ActiveSharedStash";
const char* S_active_SharedStashInMultiPlayer = "ActiveSharedStashInMultiPlayer";
const char* S_separateHardSoftStash = "SeparateHardcoreStash";
const char* S_openSharedStashOnLoading = "OpenSharedStashOnLoading";
const char* S_sharedStashFilename = "SharedStashFilename";
const char* S_displaySharedSetItemNameInGreen = "DisplaySharedSetItemNameInGreen";
const char* S_maxSharedPages = "MaxSharedPages";
const char* S_active_sharedGold = "ActiveSharedGold";
const char* S_posXPreviousBtn = "PosXPreviousBtn"; const char* S_posXPreviousBtn = "PosXPreviousBtn";
const char* S_posYPreviousBtn = "PosYPreviousBtn"; const char* S_posYPreviousBtn = "PosYPreviousBtn";
const char* S_posWPreviousBtn = "PosWPreviousBtn";
const char* S_posHPreviousBtn = "PosHPreviousBtn";
const char* S_posXNextBtn = "PosXNextBtn"; const char* S_posXNextBtn = "PosXNextBtn";
const char* S_posYNextBtn = "PosYNextBtn"; const char* S_posYNextBtn = "PosYNextBtn";
const char* S_posWNextBtn = "PosWNextBtn";
const char* S_posHNextBtn = "PosHNextBtn";
const char* S_posXSharedBtn = "PosXSharedBtn"; const char* S_posXSharedBtn = "PosXSharedBtn";
const char* S_posYSharedBtn = "PosYSharedBtn"; const char* S_posYSharedBtn = "PosYSharedBtn";
const char* S_posWSharedBtn = "PosWSharedBtn";
const char* S_posHSharedBtn = "PosHSharedBtn";
const char* S_posXPreviousIndexBtn = "PosXPreviousIndexBtn"; const char* S_posXPreviousIndexBtn = "PosXPreviousIndexBtn";
const char* S_posYPreviousIndexBtn = "PosYPreviousIndexBtn"; const char* S_posYPreviousIndexBtn = "PosYPreviousIndexBtn";
const char* S_posWPreviousIndexBtn = "PosWPreviousIndexBtn";
const char* S_posHPreviousIndexBtn = "PosHPreviousIndexBtn";
const char* S_posXNextIndexBtn = "PosXNextIndexBtn"; const char* S_posXNextIndexBtn = "PosXNextIndexBtn";
const char* S_posYNextIndexBtn = "PosYNextIndexBtn"; const char* S_posYNextIndexBtn = "PosYNextIndexBtn";
const char* S_posWNextIndexBtn = "PosWNextIndexBtn";
const char* S_posHNextIndexBtn = "PosHNextIndexBtn";
const char* S_posXPutGoldBtn = "PosXPutGoldBtn"; const char* S_posXPutGoldBtn = "PosXPutGoldBtn";
const char* S_posYPutGoldBtn = "PosYPutGoldBtn"; const char* S_posYPutGoldBtn = "PosYPutGoldBtn";
const char* S_posWPutGoldBtn = "PosWPutGoldBtn";
const char* S_posHPutGoldBtn = "PosHPutGoldBtn";
const char* S_posXTakeGoldBtn = "PosXTakeGoldBtn"; const char* S_posXTakeGoldBtn = "PosXTakeGoldBtn";
const char* S_posYTakeGoldBtn = "PosYTakeGoldBtn"; const char* S_posYTakeGoldBtn = "PosYTakeGoldBtn";
const char* S_posWTakeGoldBtn = "PosWTakeGoldBtn";
const char* S_posHTakeGoldBtn = "PosHTakeGoldBtn";
const char* S_posXStashNameField = "PosXStashNameField";
const char* S_posYStashNameField = "PosYStashNameField";
const char* S_posWStashNameField = "PosWStashNameField";
const char* S_posHStashNameField = "PosHStashNameField";
const char* S_posXStashGoldField = "PosXStashGoldField";
const char* S_posYStashGoldField = "PosYStashGoldField";
const char* S_posWStashGoldField = "PosWStashGoldField";
const char* S_posHStashGoldField = "PosHStashGoldField";
const char* S_STATS_POINTS = "STATS POINTS"; const char* S_STATS_POINTS = "STATS POINTS";
const char* S_active_StatsPoints = "ActiveStatsUnassignment"; const char* S_active_StatsPoints = "ActiveStatsUnassignment";
@ -124,14 +159,20 @@ const char* S_keyUsedForUnassignStatPoint = "KeyUsed";
const char* S_active_StatsShiftClickLimit = "ActiveShiftClickLimit"; const char* S_active_StatsShiftClickLimit = "ActiveShiftClickLimit";
const char* S_limitValueToShiftClick = "LimitValueToShiftClick"; const char* S_limitValueToShiftClick = "LimitValueToShiftClick";
const char* S_SKILL_ON_LEVEL_UP = "SKILL ON LEVEL UP";
const char* S_active_SkillPerLevelUpChange = "ActiveSkillPerLevelUp";
const char* S_skillPerLevelUp = "SkillPerLevelUp";
const char* S_STAT_ON_LEVEL_UP = "STAT ON LEVEL UP"; const char* S_STAT_ON_LEVEL_UP = "STAT ON LEVEL UP";
const char* S_active_StatPerLevelUpChange = "ActiveStatPerLevelUp"; const char* S_active_StatPerLevelUpChange = "ActiveStatPerLevelUp";
const char* S_statPerLevelUp = "StatPerLevelUp"; const char* S_statPerLevelUp = "StatPerLevelUp";
const char* S_SKILLS_POINTS = "SKILLS POINTS";
const char* S_active_SkillsPoints = "ActiveSkillsUnassignment";
const char* S_unassignSkillsPointsOneForOne = "ActiveSkillsUnassignmentOneForOne";
const char* S_posXUnassignSkillBtn = "PosXUnassignSkillBtn";
const char* S_posYUnassignSkillBtn = "PosYUnassignSkillBtn";
const char* S_SKILL_ON_LEVEL_UP = "SKILL ON LEVEL UP";
const char* S_active_SkillPerLevelUpChange = "ActiveSkillPerLevelUp";
const char* S_skillPerLevelUp = "SkillPerLevelUp";
const char* S_WORLD_EVENT = "WORLD EVENT"; const char* S_WORLD_EVENT = "WORLD EVENT";
const char* S_active_WorldEvent = "ActiveWorldEvent"; const char* S_active_WorldEvent = "ActiveWorldEvent";
const char* S_showSOJSoldCounterInAllDiff = "ShowCounterInAllDifficulty"; const char* S_showSOJSoldCounterInAllDiff = "ShowCounterInAllDifficulty";
@ -148,28 +189,59 @@ const char* S_timeBeforeAutoSellDelta = "TimeBeforeAutoSellMax";
const char* S_UBER_QUEST = "UBER QUEST"; const char* S_UBER_QUEST = "UBER QUEST";
const char* S_active_UberQuest = "ActiveUberQuest"; const char* S_active_UberQuest = "ActiveUberQuest";
const char* S_UberMephistoX = "UberMephistoX";
const char* S_UberMephistoY = "UberMephistoY";
const char* S_UberDiabloX = "UberDiabloX";
const char* S_UberDiabloY = "UberDiabloY";
const char* S_UberBaalX = "UberBaalX";
const char* S_UberBaalY = "UberBaalY";
const char* S_SKILLS_POINTS = "SKILLS POINTS"; const char* S_active_UberMinions = "ActiveUberMinions";
const char* S_active_SkillsPoints = "ActiveSkillsUnassignment"; //const char* S_UberMephistoMinions = "UberMephistoMinions";
const char* S_unassignSkillsPointsOneByOne = "ActiveSkillsUnassignmentOneByOne"; const char* S_UberMephistoSpawnPercent = "UberMephistoSpawnPercent";
const char* S_posXUnassignSkillBtn = "PosXUnassignSkillBtn"; const char* S_UberMephistoSpawnRadius = "UberMephistoSpawnRadius";
const char* S_posYUnassignSkillBtn = "PosYUnassignSkillBtn"; //const char* S_UberBaalMinions = "UberBaalMinions";
const char* S_UberBaalSpawnPercent = "UberBaalSpawnPercent";
const char* S_UberBaalSpawnRadius = "UberBaalSpawnRadius";
//const char* S_UberDiabloMinions = "UberDiabloMinions";
const char* S_UberDiabloSpawnPercent = "UberDiabloSpawnPercent";
const char* S_UberDiabloSpawnRadius = "UberDiabloSpawnRadius";
const char* S_active_UberDiabloRushTweekAI = "ActiveUberDiabloRushTweekAI";
const char* S_active_UberBaalTeleportTweekAI = "ActiveUberBaalTeleportTweekAI";
const char* S_active_UberBaalChillingArmorTweekAI = "ActiveUberBaalChillingArmorTweekAI";
const char* S_uberBaalChillingArmorTimer = "UberBaalChillingArmorTimer";
const char* S_INTERFACE = "INTERFACE"; const char* S_INTERFACE = "INTERFACE";
const char* S_active_newInterfaces = "ActiveNewStatsInterface"; const char* S_active_newInterfaces = "ActiveNewStatsInterface";
const char* S_selectMainPageOnOpenning = "SelectMainPageOnOpenning"; const char* S_selectMainPageOnOpenning = "SelectMainPageOnOpenning";
const char* S_printBackgroundOnMainPage = "PrintButtonsBackgroundOnMainStatsPage"; const char* S_printBackgroundOnMainPage = "PrintButtonsBackgroundOnMainStatsPage";
const char* S_posXNextPageBtn = "PosXNextPageBtn";
const char* S_posYNextPageBtn = "PosYNextPageBtn";
const char* S_posXPrevPageBtn = "PosXPrevPageBtn";
const char* S_posYPrevPageBtn = "PosYPrevPageBtn";
const char* S_posXClosePageBtn = "PosXClosePageBtn";
const char* S_posYClosePageBtn = "PosYClosePageBtn";
const char* S_posXNextRuneBtn = "PosXNextRuneBtn";
const char* S_posYNextRuneBtn = "PosYNextRuneBtn";
const char* S_posXPrevRuneBtn = "PosXPrevRuneBtn";
const char* S_posYPrevRuneBtn = "PosYPrevRuneBtn";
const char* S_posXRunesList = "PosXRunesList";
const char* S_posYRunesList = "PosYRunesList";
const char* S_runesPerPage = "RunesPerPage";
const char* S_EXTRA = "EXTRA"; const char* S_EXTRA = "EXTRA";
const char* S_active_RunLODs = "ActiveLaunchAnyNumberOfLOD";
const char* S_active_alwaysRegenMapInSP = "AlwaysRegenMapInSP"; const char* S_active_alwaysRegenMapInSP = "AlwaysRegenMapInSP";
const char* S_nbPlayersCommandByDefault = "NBPlayersByDefault"; const char* S_nbPlayersCommandByDefault = "NBPlayersByDefault";
const char* S_active_DisplayItemLevel = "ActiveDisplayItemLevel"; const char* S_active_DisplayItemLevel = "ActiveDisplayItemLevel";
const char* S_active_RunLODs = "ActiveLaunchAnyNumberOfLOD";
const char* S_active_AlwaysDisplayLifeMana = "AlwaysDisplayLifeAndManaValues"; const char* S_active_AlwaysDisplayLifeMana = "AlwaysDisplayLifeAndManaValues";
const char* S_active_EnabledTXTFilesWithMSExcel= "EnabledTXTFilesWhenMSExcelOpenIt"; const char* S_active_EnabledTXTFilesWithMSExcel= "EnabledTXTFilesWhenMSExcelOpenIt";
const char* S_active_DisplayBaseStatsValue = "ActiveDisplayBaseStatsValue"; const char* S_active_DisplayBaseStatsValue = "ActiveDisplayBaseStatsValue";
const char* S_active_LadderRunewords = "ActiveLadderRunewords"; const char* S_active_LadderRunewords = "ActiveLadderRunewords";
const char* S_active_EnabledCowPortalWhenCowKingWasKill = "ActiveCowPortalWhenCowKingWasKilled"; const char* S_active_EnabledCowPortalWhenCowKingWasKill = "ActiveCowPortalWhenCowKingWasKilled";
const char* S_active_DoNotCloseNihlathakPortal = "ActiveDoNotCloseNihlathakPortal";
const char* S_active_MoveCainNearHarrogathWaypoint = "MoveCainNearHarrogathWaypoint";
const char* S_active_RemoveExperienceDiminushingReturn = "RemoveExperienceDiminushingReturn";
const char* S_DLL = "DLL:\t"; const char* S_DLL = "DLL:\t";
const char* S_DEFAULT = "DEFAULT:"; const char* S_DEFAULT = "DEFAULT:";
@ -206,6 +278,13 @@ else log_msg(S_DEFAULT); \
else log_msg(S_FIXED); \ else log_msg(S_FIXED); \
else log_msg(S_USER) else log_msg(S_USER)
int getColor(char* buffer)
{
int val = atoi(buffer);
if (val < 1 || val > 19 || val == 17)
return 0;
return val;
}
void init_ActivePlugin(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize) void init_ActivePlugin(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize)
{ {
@ -226,8 +305,18 @@ void init_General(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFi
log_msg("active_DisableBattleNet\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"); GET_PRIVATE_PROFILE_STRING(S_GENERAL, S_active_logFile, "0");
active_logFile = atoi(buffer)+1; active_logFile = atoi(buffer) + 1;
log_msg("active_logFile\t\t\t\t= %d\n", active_logFile-1); log_msg("active_logFile\t\t\t\t= %d\n", active_logFile);
GET_PRIVATE_PROFILE_STRING(S_GENERAL,S_dllFilenames,"");
strcat(buffer,"|");
char* buf = &buffer[strlen(buffer)];
if (!iniFixedFile->GetPrivateProfileString(S_GENERAL, S_dllFilenames2, NULL, buf, maxSize))
if (!iniFile->GetPrivateProfileString(S_GENERAL, S_dllFilenames2, NULL, buf, maxSize))
iniDefaultFile->GetPrivateProfileString(S_GENERAL, S_dllFilenames2, NULL, buf, maxSize);
dllFilenames = (char*)D2FogMemAlloc(strlen(buffer)+1,__FILE__,__LINE__,0);
strcpy(dllFilenames,buffer);
log_msg("dllFilenames\t\t\t\t= %s\n", dllFilenames);
GET_PRIVATE_PROFILE_STRING(S_GENERAL, S_active_Commands, "0"); GET_PRIVATE_PROFILE_STRING(S_GENERAL, S_active_Commands, "0");
active_Commands = atoi(buffer) != 0; active_Commands = atoi(buffer) != 0;
@ -241,16 +330,9 @@ void init_General(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFi
active_othersFeatures = atoi(buffer) != 0; active_othersFeatures = atoi(buffer) != 0;
log_msg("active_othersFeatures\t\t= %u\n", active_othersFeatures); log_msg("active_othersFeatures\t\t= %u\n", active_othersFeatures);
GET_PRIVATE_PROFILE_STRING(S_GENERAL,S_dllFilenames,""); GET_PRIVATE_PROFILE_STRING(S_GENERAL, S_saveFileStackSize, "8192");
strcat(buffer,"|"); saveFileStackSize = atoi(buffer);
char* buf = &buffer[strlen(buffer)]; log_msg("SaveFileStackSize\t\t\t= %u\n", saveFileStackSize);
if (!iniFixedFile->GetPrivateProfileString(S_GENERAL, S_dllFilenames2, NULL, buf, maxSize))
if (!iniFile->GetPrivateProfileString(S_GENERAL, S_dllFilenames2, NULL, buf, maxSize))
iniDefaultFile->GetPrivateProfileString(S_GENERAL, S_dllFilenames2, NULL, buf, maxSize);
dllFilenames = (char*)D2FogMemAlloc(strlen(buffer)+1,__FILE__,__LINE__,0);
strcpy(dllFilenames,buffer);
log_msg("dllFilenames\t\t\t\t= %s\n",dllFilenames);
log_msg("\n"); log_msg("\n");
} }
@ -276,7 +358,7 @@ void init_Windowed(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultF
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_SetWindowPos, "0"); GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_SetWindowPos, "0");
active_SetWindowPos = atoi(buffer) != 0; active_SetWindowPos = atoi(buffer) != 0;
log_msg("active_MoveAndResizeWindow\t= %d\n", active_SetWindowPos); log_msg("active_SetWindowPos\t= %d\n", active_SetWindowPos);
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_X, "0"); GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_X, "0");
windowedX = atoi(buffer); windowedX = atoi(buffer);
@ -286,11 +368,11 @@ void init_Windowed(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultF
windowedY = atoi(buffer); windowedY = atoi(buffer);
log_msg("windowedY\t\t\t\t\t= %d\n", windowedY); log_msg("windowedY\t\t\t\t\t= %d\n", windowedY);
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_Width, "0"); GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_Width, "800");
windowedWidth = atoi(buffer); windowedWidth = atoi(buffer);
log_msg("windowedWidth\t\t\t\t= %d\n", windowedWidth); log_msg("windowedWidth\t\t\t\t= %d\n", windowedWidth);
GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_Height, "0"); GET_PRIVATE_PROFILE_STRING(S_WINDOWED, S_Height, "600");
windowedHeight = atoi(buffer); windowedHeight = atoi(buffer);
log_msg("windowedHeight\t\t\t\t= %d\n", windowedHeight); log_msg("windowedHeight\t\t\t\t= %d\n", windowedHeight);
@ -387,7 +469,6 @@ void init_ActiveLanguage(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDe
log_msg("\n"); log_msg("\n");
} }
void init_SavePath(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize) void init_SavePath(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize)
{ {
GET_PRIVATE_PROFILE_STRING3(S_SAVEPATH, S_active_changingSavePath, "0"); GET_PRIVATE_PROFILE_STRING3(S_SAVEPATH, S_active_changingSavePath, "0");
@ -415,7 +496,6 @@ void init_SavePath(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultF
{ {
active_changingSavePath = false; active_changingSavePath = false;
log_msg("active_changingSavePath\t\t= %u (no valid savePath)\n\n", active_changingSavePath); log_msg("active_changingSavePath\t\t= %u (no valid savePath)\n\n", active_changingSavePath);
// log_msg("\tsavePath\t\t\t= %s\n", savePath);
return; return;
} }
@ -423,7 +503,7 @@ void init_SavePath(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultF
{ {
char buf[MAX_PATH]; char buf[MAX_PATH];
buf[0]=NULL; buf[0]=NULL;
D2FogGetInstallPath(buf,MAX_PATH); D2FogGetSavePath(buf,MAX_PATH);
savePath = (char*)D2FogMemAlloc(strlen(buf) + curSize - start + 1,__FILE__,__LINE__,0); savePath = (char*)D2FogMemAlloc(strlen(buf) + curSize - start + 1,__FILE__,__LINE__,0);
strcpy(savePath,buf); strcpy(savePath,buf);
strcat(savePath,&buffer[start]); strcat(savePath,&buffer[start]);
@ -433,10 +513,18 @@ void init_SavePath(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultF
} }
log_msg("savePath\t\t\t\t\t= %s\n", savePath); log_msg("savePath\t\t\t\t\t= %s\n", savePath);
} }
GET_PRIVATE_PROFILE_STRING3(S_SAVEPATH, S_active_AutoBackup, "0");
active_AutoBackup = atoi(buffer) != 0;
log_msg("active_autoBackup\t\t= %u\n", active_AutoBackup);
GET_PRIVATE_PROFILE_STRING3(S_SAVEPATH, S_maxBackupPerCharacter, "20");
maxBackupPerCharacter = atoi(buffer);
log_msg("maxBackupPerCharacter\t\t= %u\n", maxBackupPerCharacter);
log_msg("\n"); log_msg("\n");
} }
void init_VersionText(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize) void init_VersionText(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize)
{ {
GET_PRIVATE_PROFILE_STRING(S_MAIN_SCREEN, S_active_VersionTextChange, "0"); GET_PRIVATE_PROFILE_STRING(S_MAIN_SCREEN, S_active_VersionTextChange, "0");
@ -448,29 +536,31 @@ void init_VersionText(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefau
GET_PRIVATE_PROFILE_STRING(S_MAIN_SCREEN, S_versionText, versionText); GET_PRIVATE_PROFILE_STRING(S_MAIN_SCREEN, S_versionText, versionText);
if (!buffer[0]) if (!buffer[0])
{ {
switch(version_D2Game)
{
//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 "); strcpy(buffer, "v ");
strcat(buffer, GetVersionString(version_D2Game)); strcat(buffer, GetVersionString(version_D2Game));
break; //switch(version_D2Game)
default: //{
active_VersionTextChange=0; ////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;
//}
} }
versionText = (char*)D2FogMemAlloc(strlen(buffer)+1,__FILE__,__LINE__,0); versionText = (char*)D2FogMemAlloc(strlen(buffer)+1,__FILE__,__LINE__,0);
@ -478,7 +568,7 @@ void init_VersionText(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefau
log_msg("versionText\t\t\t\t\t= %s\n", versionText); log_msg("versionText\t\t\t\t\t= %s\n", versionText);
GET_PRIVATE_PROFILE_STRING(S_MAIN_SCREEN, S_modVersionColor, "0"); GET_PRIVATE_PROFILE_STRING(S_MAIN_SCREEN, S_modVersionColor, "0");
modVersionColor = atoi(buffer); modVersionColor = getColor(buffer);
log_msg("modVersionColor\t\t\t\t= %u\n", modVersionColor); log_msg("modVersionColor\t\t\t\t= %u\n", modVersionColor);
} }
@ -489,7 +579,7 @@ void init_VersionText(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefau
if (active_PrintPlugYVersion) if (active_PrintPlugYVersion)
{ {
GET_PRIVATE_PROFILE_STRING(S_MAIN_SCREEN, S_colorOfPlugYVersion, "4"); GET_PRIVATE_PROFILE_STRING(S_MAIN_SCREEN, S_colorOfPlugYVersion, "4");
colorOfPlugYVersion = atoi(buffer); colorOfPlugYVersion = getColor(buffer);
log_msg("colorOfPlugYVersion\t\t\t= %u\n", colorOfPlugYVersion); log_msg("colorOfPlugYVersion\t\t\t= %u\n", colorOfPlugYVersion);
} }
@ -509,11 +599,6 @@ void init_Stash(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile
if (active_multiPageStash) if (active_multiPageStash)
{ {
active_PlayerCustomData = true; active_PlayerCustomData = true;
// log_msg("active_PlayerCustomData\t\t= %d\n", active_PlayerCustomData);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_maxSelfPages, "0");
maxSelfPages = atoi(buffer) - 1;
log_msg("maxSelfPages\t\t\t\t= %u\n", maxSelfPages);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_nbPagesPerIndex, "10"); GET_PRIVATE_PROFILE_STRING(S_STASH, S_nbPagesPerIndex, "10");
nbPagesPerIndex = atoi(buffer); nbPagesPerIndex = atoi(buffer);
@ -525,71 +610,179 @@ void init_Stash(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile
if (!nbPagesPerIndex2) nbPagesPerIndex2=100; if (!nbPagesPerIndex2) nbPagesPerIndex2=100;
log_msg("nbPagesPerIndex2\t\t\t= %u\n", nbPagesPerIndex2); log_msg("nbPagesPerIndex2\t\t\t= %u\n", nbPagesPerIndex2);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_maxSelfPages, "0");
maxSelfPages = atoi(buffer) - 1;
log_msg("maxSelfPages\t\t\t\t= %u\n", maxSelfPages);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_autoRenameStashPage, "0");
autoRenameStashPage = atoi(buffer) != 0;
log_msg("autoRenameStashPage\t\t\t= %d\n", autoRenameStashPage);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_PersonalNormalPageColor, "0");
PersonalNormalPageColor = getColor(buffer);
log_msg("PersonalNormalPageColor\t\t\t= %d\n", PersonalNormalPageColor);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_PersonalIndexPageColor, "12");
PersonalIndexPageColor = getColor(buffer);
log_msg("PersonalIndexPageColor\t\t\t= %d\n", PersonalIndexPageColor);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_PersonalMainIndexPageColor, "9");
PersonalMainIndexPageColor = getColor(buffer);
log_msg("PersonalMainIndexPageColor\t\t\t= %d\n", PersonalMainIndexPageColor);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_SharedNormalPageColor, "4");
SharedNormalPageColor = getColor(buffer);
log_msg("SharedNormalPageColor\t\t\t= %d\n", SharedNormalPageColor);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_SharedIndexPageColor, "8");
SharedIndexPageColor = getColor(buffer);
log_msg("SharedIndexPageColor\t\t\t= %d\n", SharedIndexPageColor);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_SharedMainIndexPageColor, "1");
SharedMainIndexPageColor = getColor(buffer);
log_msg("SharedMainIndexPageColor\t\t\t= %d\n", SharedMainIndexPageColor);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_active_sharedStash, "0"); GET_PRIVATE_PROFILE_STRING(S_STASH, S_active_sharedStash, "0");
active_sharedStash = atoi(buffer) != 0; active_sharedStash = atoi(buffer) != 0;
log_msg("active_sharedStash\t\t\t= %u\n", active_sharedStash); log_msg("active_sharedStash\t\t\t= %u\n", active_sharedStash);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXPreviousBtn,"-1");
posXPreviousBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYPreviousBtn,"-1");
posYPreviousBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXNextBtn,"-1");
posXNextBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYNextBtn,"-1");
posYNextBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXSharedBtn,"-1");
posXSharedBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYSharedBtn,"-1");
posYSharedBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXPreviousIndexBtn,"-1");
posXPreviousIndexBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYPreviousIndexBtn,"-1");
posYPreviousIndexBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXNextIndexBtn,"-1");
posXNextIndexBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYNextIndexBtn,"-1");
posYNextIndexBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXPutGoldBtn,"-1");
posXPutGoldBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYPutGoldBtn,"-1");
posYPutGoldBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXTakeGoldBtn,"-1");
posXTakeGoldBtn = atoi(buffer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYTakeGoldBtn,"-1");
posYTakeGoldBtn = atoi(buffer);
log_msg("\t Buttons Positions: %d %d %d %d %d %d %d %d %d %d\n",posXPreviousBtn,posYPreviousBtn,posXNextBtn,posYNextBtn,posXSharedBtn,posYSharedBtn,posXPreviousIndexBtn,posYPreviousIndexBtn,posXNextIndexBtn,posYNextIndexBtn);
}
if (active_sharedStash) if (active_sharedStash)
{ {
GET_PRIVATE_PROFILE_STRING(S_STASH, S_active_SharedStashInMultiPlayer, "0");
active_SharedStashInMultiPlayer = atoi(buffer) ? 2 : 1;
log_msg("active_SharedStashInMultiPlayer = %u\n", active_SharedStashInMultiPlayer);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_separateHardSoftStash, "1");
separateHardSoftStash = atoi(buffer) != 0;
log_msg("separateHardSoftStash\t\t= %u\n", separateHardSoftStash);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_openSharedStashOnLoading, "0"); GET_PRIVATE_PROFILE_STRING(S_STASH, S_openSharedStashOnLoading, "0");
openSharedStashOnLoading = atoi(buffer) != 0; openSharedStashOnLoading = atoi(buffer) != 0;
log_msg("openSharedStashOnLoading\t\t= %u\n", openSharedStashOnLoading); 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);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_sharedStashFilename, "SharedStashSave"); GET_PRIVATE_PROFILE_STRING(S_STASH, S_sharedStashFilename, "SharedStashSave");
sharedStashFilename = (char*)D2FogMemAlloc(strlen(buffer)+1,__FILE__,__LINE__,0); sharedStashFilename = (char*)D2FogMemAlloc(strlen(buffer)+1,__FILE__,__LINE__,0);
strcpy(sharedStashFilename, buffer); strcpy(sharedStashFilename, buffer);
log_msg("sharedStashFilename\t\t\t= %s\n", sharedStashFilename); log_msg("sharedStashFilename\t\t\t= %s\n", sharedStashFilename);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_separateHardSoftStash, "1");
separateHardSoftStash = atoi(buffer) != 0;
log_msg("separateHardSoftStash\t\t= %u\n", separateHardSoftStash);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_displaySharedSetItemNameInGreen, "1"); GET_PRIVATE_PROFILE_STRING(S_STASH, S_displaySharedSetItemNameInGreen, "1");
displaySharedSetItemNameInGreen = atoi(buffer) != 0; displaySharedSetItemNameInGreen = atoi(buffer) != 0;
log_msg("displaySharedSetItemNameInGreen = %u\n", displaySharedSetItemNameInGreen); log_msg("displaySharedSetItemNameInGreen = %u\n", displaySharedSetItemNameInGreen);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_maxSharedPages, "0");
maxSharedPages = atoi(buffer) - 1;
log_msg("maxSharedPages\t\t\t\t= %u\n", maxSharedPages);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_active_sharedGold, "1"); GET_PRIVATE_PROFILE_STRING(S_STASH, S_active_sharedGold, "1");
active_sharedGold = atoi(buffer) != 0; active_sharedGold = atoi(buffer) != 0;
log_msg("active_sharedGold\t\t\t= %u\n", active_sharedGold); log_msg("active_sharedGold\t\t\t= %u\n", active_sharedGold);
} }
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXPreviousBtn,"-1");
posXPreviousBtn = atoi(buffer);
log_msg("posXPreviousBtn\t\t\t= %d\n", posXPreviousBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYPreviousBtn,"-1");
posYPreviousBtn = atoi(buffer);
log_msg("posYPreviousBtn\t\t\t= %d\n", posYPreviousBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posWPreviousBtn,"32");
posWPreviousBtn = atoi(buffer);
log_msg("posWPreviousBtn\t\t\t= %d\n", posWPreviousBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posHPreviousBtn,"32");
posHPreviousBtn = atoi(buffer);
log_msg("posHPreviousBtn\t\t\t= %d\n", posHPreviousBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXNextBtn,"-1");
posXNextBtn = atoi(buffer);
log_msg("posXNextBtn\t\t\t= %d\n", posXNextBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYNextBtn,"-1");
posYNextBtn = atoi(buffer);
log_msg("posYNextBtn\t\t\t= %d\n", posYNextBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posWNextBtn,"32");
posWNextBtn = atoi(buffer);
log_msg("posWNextBtn\t\t\t= %d\n", posWNextBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posHNextBtn,"32");
posHNextBtn = atoi(buffer);
log_msg("posHNextBtn\t\t\t= %d\n", posHNextBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXSharedBtn,"-1");
posXSharedBtn = atoi(buffer);
log_msg("posXSharedBtn\t\t\t= %d\n", posXSharedBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYSharedBtn,"-1");
posYSharedBtn = atoi(buffer);
log_msg("posYSharedBtn\t\t\t= %d\n", posYSharedBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posWSharedBtn,"32");
posWSharedBtn = atoi(buffer);
log_msg("posWSharedBtn\t\t\t= %d\n", posWSharedBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posHSharedBtn,"32");
posHSharedBtn = atoi(buffer);
log_msg("posHSharedBtn\t\t\t= %d\n", posHSharedBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXPreviousIndexBtn,"-1");
posXPreviousIndexBtn = atoi(buffer);
log_msg("posXPreviousIndexBtn\t\t\t= %d\n", posXPreviousIndexBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYPreviousIndexBtn,"-1");
posYPreviousIndexBtn = atoi(buffer);
log_msg("posYPreviousIndexBtn\t\t\t= %d\n", posYPreviousIndexBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posWPreviousIndexBtn,"32");
posWPreviousIndexBtn = atoi(buffer);
log_msg("posWPreviousIndexBtn\t\t\t= %d\n", posWPreviousIndexBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posHPreviousIndexBtn,"32");
posHPreviousIndexBtn = atoi(buffer);
log_msg("posHPreviousIndexBtn\t\t\t= %d\n", posHPreviousIndexBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXNextIndexBtn,"-1");
posXNextIndexBtn = atoi(buffer);
log_msg("posXNextIndexBtn\t\t\t= %d\n", posXNextIndexBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYNextIndexBtn,"-1");
posYNextIndexBtn = atoi(buffer);
log_msg("posYNextIndexBtn\t\t\t= %d\n", posYNextIndexBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posWNextIndexBtn,"32");
posWNextIndexBtn = atoi(buffer);
log_msg("posWNextIndexBtn\t\t\t= %d\n", posWNextIndexBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posHNextIndexBtn,"32");
posHNextIndexBtn = atoi(buffer);
log_msg("posHNextIndexBtn\t\t\t= %d\n", posHNextIndexBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXPutGoldBtn,"-1");
posXPutGoldBtn = atoi(buffer);
log_msg("posXPutGoldBtn\t\t\t= %d\n", posXPutGoldBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYPutGoldBtn,"-1");
posYPutGoldBtn = atoi(buffer);
log_msg("posYPutGoldBtn\t\t\t= %d\n", posYPutGoldBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posWPutGoldBtn,"32");
posWPutGoldBtn = atoi(buffer);
log_msg("posWPutGoldBtn\t\t\t= %d\n", posWPutGoldBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posHPutGoldBtn,"32");
posHPutGoldBtn = atoi(buffer);
log_msg("posHPutGoldBtn\t\t\t= %d\n", posHPutGoldBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXTakeGoldBtn,"-1");
posXTakeGoldBtn = atoi(buffer);
log_msg("posXTakeGoldBtn\t\t\t= %d\n", posXTakeGoldBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYTakeGoldBtn,"-1");
posYTakeGoldBtn = atoi(buffer);
log_msg("posYTakeGoldBtn\t\t\t= %d\n", posYTakeGoldBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posWTakeGoldBtn,"32");
posWTakeGoldBtn = atoi(buffer);
log_msg("posWTakeGoldBtn\t\t\t= %d\n", posWTakeGoldBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posHTakeGoldBtn,"32");
posHTakeGoldBtn = atoi(buffer);
log_msg("posHTakeGoldBtn\t\t\t= %d\n", posHTakeGoldBtn);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXStashNameField,"-1");
posXStashNameField = atoi(buffer);
log_msg("posXStashNameField\t\t\t= %d\n", posXStashNameField);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYStashNameField,"-1");
posYStashNameField = atoi(buffer);
log_msg("posYStashNameField\t\t\t= %d\n", posYStashNameField);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posWStashNameField,"175");
posWStashNameField = atoi(buffer);
log_msg("posWStashNameField\t\t\t= %d\n", posWStashNameField);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posHStashNameField,"20");
posHStashNameField = atoi(buffer);
log_msg("posHStashNameField\t\t\t= %d\n", posHStashNameField);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posXStashGoldField,"-1");
posXStashGoldField = atoi(buffer);
log_msg("posXStashGoldField\t\t\t= %d\n", posXStashGoldField);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posYStashGoldField,"-1");
posYStashGoldField = atoi(buffer);
log_msg("posYStashGoldField\t\t\t= %d\n", posYStashGoldField);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posWStashGoldField,"152");
posWStashGoldField = atoi(buffer);
log_msg("posWStashGoldField\t\t\t= %d\n", posWStashGoldField);
GET_PRIVATE_PROFILE_STRING(S_STASH, S_posHStashGoldField,"18");
posHStashGoldField = atoi(buffer);
log_msg("posHStashGoldField\t\t\t= %d\n", posHStashGoldField);
}
log_msg("\n"); log_msg("\n");
} }
@ -619,7 +812,6 @@ void init_StatsPoints(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefau
log_msg("\n"); log_msg("\n");
} }
void init_StatPerLevelUp(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize) void init_StatPerLevelUp(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize)
{ {
GET_PRIVATE_PROFILE_STRING(S_STAT_ON_LEVEL_UP, S_active_StatPerLevelUpChange, "0"); GET_PRIVATE_PROFILE_STRING(S_STAT_ON_LEVEL_UP, S_active_StatPerLevelUpChange, "0");
@ -641,15 +833,17 @@ void init_SkillsPoints(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefa
active_SkillsPoints = atoi(buffer) != 0; active_SkillsPoints = atoi(buffer) != 0;
log_msg("active_SkillsPoints\t\t\t= %d\n", active_SkillsPoints); log_msg("active_SkillsPoints\t\t\t= %d\n", active_SkillsPoints);
GET_PRIVATE_PROFILE_STRING(S_SKILLS_POINTS, S_unassignSkillsPointsOneByOne, "0"); GET_PRIVATE_PROFILE_STRING(S_SKILLS_POINTS, S_unassignSkillsPointsOneForOne, "0");
unassignSkillsPointsOneByOne = atoi(buffer) != 0; unassignSkillsPointsOneForOne = atoi(buffer) != 0;
log_msg("unassignSkillsPointsOneByOne\t\t\t= %d\n", unassignSkillsPointsOneByOne); log_msg("unassignSkillsPointsOneForOne\t\t\t= %d\n", unassignSkillsPointsOneForOne);
if (unassignSkillsPointsOneByOne) if (unassignSkillsPointsOneForOne)
{ {
active_SkillsPoints = true; active_SkillsPoints = true;
log_msg("active_SkillsPoints\t\t\t= %d\n", active_SkillsPoints); log_msg("active_SkillsPoints\t\t\t= %d\n", active_SkillsPoints);
} }
if (active_SkillsPoints)
{
GET_PRIVATE_PROFILE_STRING(S_SKILLS_POINTS, S_posXUnassignSkillBtn,"-1"); GET_PRIVATE_PROFILE_STRING(S_SKILLS_POINTS, S_posXUnassignSkillBtn,"-1");
posXUnassignSkillBtn = atoi(buffer); posXUnassignSkillBtn = atoi(buffer);
log_msg("posXUnassignSkillBtn\t\t\t= %d\n", posXUnassignSkillBtn); log_msg("posXUnassignSkillBtn\t\t\t= %d\n", posXUnassignSkillBtn);
@ -657,7 +851,7 @@ void init_SkillsPoints(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefa
GET_PRIVATE_PROFILE_STRING(S_SKILLS_POINTS, S_posYUnassignSkillBtn,"-1"); GET_PRIVATE_PROFILE_STRING(S_SKILLS_POINTS, S_posYUnassignSkillBtn,"-1");
posYUnassignSkillBtn = atoi(buffer); posYUnassignSkillBtn = atoi(buffer);
log_msg("posXUnassignSkillBtn\t\t\t= %d\n", posYUnassignSkillBtn); log_msg("posXUnassignSkillBtn\t\t\t= %d\n", posYUnassignSkillBtn);
}
log_msg("\n"); log_msg("\n");
} }
@ -676,12 +870,11 @@ void init_SkillPerLevelUp(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniD
log_msg("\n"); log_msg("\n");
} }
void init_WorldEvent(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize) void init_WorldEvent(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize)
{ {
GET_PRIVATE_PROFILE_STRING(S_WORLD_EVENT, S_active_WorldEvent, "0"); GET_PRIVATE_PROFILE_STRING(S_WORLD_EVENT, S_active_WorldEvent, "0");
active_WorldEvent = atoi(buffer) != 0; active_WorldEvent = atoi(buffer) != 0;
if (active_WorldEvent && ((version_D2Game == V109b) || (version_D2Game == V109d)) ) { if (active_WorldEvent && version_D2Game < V110) {
active_WorldEvent = 0; active_WorldEvent = 0;
log_msg("active_WorldEvent\t\t\t= %d (Warning : this feature is only for LoD version 1.10 or higher, so it's automatically disabled)\n", active_WorldEvent); log_msg("active_WorldEvent\t\t\t= %d (Warning : this feature is only for LoD version 1.10 or higher, so it's automatically disabled)\n", active_WorldEvent);
} else } else
@ -720,7 +913,7 @@ void init_WorldEvent(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaul
log_msg("triggerAtSolJSoldMin\t\t= %d\n", triggerAtSolJSoldMin); log_msg("triggerAtSolJSoldMin\t\t= %d\n", triggerAtSolJSoldMin);
GET_PRIVATE_PROFILE_STRING(S_WORLD_EVENT, S_triggerAtSolJSoldDelta, "125"); GET_PRIVATE_PROFILE_STRING(S_WORLD_EVENT, S_triggerAtSolJSoldDelta, "125");
triggerAtSolJSoldDelta = atoi(buffer)-triggerAtSolJSoldMin+1; triggerAtSolJSoldDelta = atoi(buffer) - triggerAtSolJSoldMin + 1;
log_msg("triggerAtSolJSoldDelta\t\t= %d\n", triggerAtSolJSoldDelta); log_msg("triggerAtSolJSoldDelta\t\t= %d\n", triggerAtSolJSoldDelta);
@ -746,15 +939,102 @@ void init_UberQuest(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefault
{ {
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_active_UberQuest, "0"); GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_active_UberQuest, "0");
active_UberQuest = atoi(buffer) != 0; active_UberQuest = atoi(buffer) != 0;
if (active_UberQuest && ((version_D2Game == V109b) || (version_D2Game == V109d) || (version_D2Game == V110)) ) { if (active_UberQuest && version_D2Game < V111) {
active_UberQuest = 0; active_UberQuest = 0;
log_msg("active_UberQuest\t\t= %d (Warning : this feature is only for LoD version 1.11 or higher, so it's automatically disabled)\n", active_UberQuest); log_msg("active_UberQuest\t\t= %d (Warning : this feature is only for LoD version 1.11 or higher, so it's automatically disabled)\n", active_UberQuest);
} else } else
log_msg("active_UberQuest\t\t\t= %d\n", active_UberQuest); log_msg("active_UberQuest\t\t\t= %d\n", active_UberQuest);
if (active_UberQuest)
{
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberMephistoX, "25130");
UberMephistoX = atoi(buffer);
log_msg("UberMephistoX\t\t= %d\n", UberMephistoX);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberMephistoY, "5143");
UberMephistoY = atoi(buffer);
log_msg("UberMephistoY\t\t= %d\n", UberMephistoY);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberDiabloX, "25139");
UberDiabloX = atoi(buffer);
log_msg("UberDiabloX\t\t= %d\n", UberDiabloX);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberDiabloY, "5139");
UberDiabloY = atoi(buffer);
log_msg("UberDiabloY\t\t= %d\n", UberDiabloY);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberBaalX, "25139");
UberBaalX = atoi(buffer);
log_msg("UberBaalX\t\t= %d\n", UberBaalX);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberBaalY, "5135");
UberBaalY = atoi(buffer);
log_msg("UberBaalY\t\t= %d\n", UberBaalY);
if (version_D2Game >= V113c)
{
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_active_UberMinions, "1");
active_UberMinions = atoi(buffer) != 0;
log_msg("active_UberMinions\t\t= %d\n", active_UberMinions);
//GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberMephistoMinions, "1");
//UberMephistoNbMinions = atoi(buffer);
//UberMephistoMinions = atoi(buffer);
//log_msg("ActiveUberMinions\t= %d\n", UberMephistoMinions);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberMephistoSpawnPercent, "80");
UberMephistoSpawnPercent = atoi(buffer);
log_msg("UberMephistoSpawnPercent\t\t= %d\n", UberMephistoSpawnPercent);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberMephistoSpawnRadius, "30");
UberMephistoSpawnRadius = atoi(buffer);
log_msg("UberMephistoSpawnRadius\t\t= %d\n", UberMephistoSpawnRadius);
//GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberBaalMinions, "1");
//UberBaalNbMinions = atoi(buffer);
//UberBaalMinions = atoi(buffer);
//log_msg("UberBaalMinions\t\t= %d\n", UberBaalMinions);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberBaalSpawnPercent, "30");
UberBaalSpawnPercent = atoi(buffer);
log_msg("UberBaalSpawnPercent\t\t= %d\n", UberBaalSpawnPercent);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberBaalSpawnRadius, "30");
UberBaalSpawnRadius = atoi(buffer);
log_msg("UberBaalSpawnRadius\t\t= %d\n", UberBaalSpawnRadius);
//GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberDiabloMinions, "1");
//UberDiabloNbMinions = atoi(buffer);
//UberDiabloMinions = atoi(buffer);
//log_msg("UberDiabloMinions\t\t= %d\n", UberDiabloMinions);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberDiabloSpawnPercent, "30");
UberDiabloSpawnPercent = atoi(buffer);
log_msg("UberDiabloSpawnPercent\t\t= %d\n", UberDiabloSpawnPercent);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_UberDiabloSpawnRadius, "30");
UberDiabloSpawnRadius = atoi(buffer);
log_msg("UberDiabloSpawnRadius\t\t= %d\n", UberDiabloSpawnRadius);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_active_UberDiabloRushTweekAI, "1");
active_UberDiabloRushTweekAI = atoi(buffer) != 0;
log_msg("active_UberDiabloRushTweekAI\t\t= %d\n", active_UberDiabloRushTweekAI);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_active_UberBaalTeleportTweekAI, "1");
active_UberBaalTeleportTweekAI = atoi(buffer) != 0;
log_msg("active_UberBaalTeleportTweekAI\t\t= %d\n", active_UberBaalTeleportTweekAI);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_active_UberBaalChillingArmorTweekAI, "1");
active_UberBaalChillingArmorTweekAI = atoi(buffer) != 0;
log_msg("active_UberBaalChillingArmorTweekAI\t\t= %d\n", active_UberBaalChillingArmorTweekAI);
GET_PRIVATE_PROFILE_STRING(S_UBER_QUEST, S_uberBaalChillingArmorTimer, "6000");
uberBaalChillingArmorTimer = atoi(buffer);
log_msg("uberBaalChillingArmorTimer\t\t= %d\n", uberBaalChillingArmorTimer);
}
}
log_msg("\n"); log_msg("\n");
} }
void init_NewInterfaces(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize) void init_NewInterfaces(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize)
{ {
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_active_newInterfaces, "0"); GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_active_newInterfaces, "0");
@ -770,57 +1050,122 @@ void init_NewInterfaces(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDef
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_printBackgroundOnMainPage, "1"); GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_printBackgroundOnMainPage, "1");
printBackgroundOnMainPage = atoi(buffer) != 0; printBackgroundOnMainPage = atoi(buffer) != 0;
log_msg("printBackgroundOnMainPage\t= %u\n", printBackgroundOnMainPage); log_msg("printBackgroundOnMainPage\t= %u\n", printBackgroundOnMainPage);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posXNextPageBtn, "161");
posXNextPageBtn = atoi(buffer);
log_msg("posXNextPageBtn\t= %d\n", posXNextPageBtn);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posYNextPageBtn, "64");
posYNextPageBtn = atoi(buffer);
log_msg("posYNextPageBtn\t= %d\n", posYNextPageBtn);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posXPrevPageBtn, "119");
posXPrevPageBtn = atoi(buffer);
log_msg("posXPrevPageBtn\t= %d\n", posXPrevPageBtn);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posYPrevPageBtn, "64");
posYPrevPageBtn = atoi(buffer);
log_msg("posYPrevPageBtn\t= %d\n", posYPrevPageBtn);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posXClosePageBtn, "360");
posXClosePageBtn = atoi(buffer);
log_msg("posXClosePageBtn\t= %d\n", posXClosePageBtn);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posYClosePageBtn, "64");
posYClosePageBtn = atoi(buffer);
log_msg("posYClosePageBtn\t= %d\n", posYClosePageBtn);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posXNextRuneBtn, "302");
posXNextRuneBtn = atoi(buffer);
log_msg("posXNextRuneBtn\t= %d\n", posXNextRuneBtn);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posYNextRuneBtn, "64");
posYNextRuneBtn = atoi(buffer);
log_msg("posYNextRuneBtn\t= %d\n", posYNextRuneBtn);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posXPrevRuneBtn, "260");
posXPrevRuneBtn = atoi(buffer);
log_msg("posXPrevRuneBtn\t= %d\n", posXPrevRuneBtn);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posYPrevRuneBtn, "64");
posYPrevRuneBtn = atoi(buffer);
log_msg("posYPrevRuneBtn\t= %d\n", posYPrevRuneBtn);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posXRunesList, "50");
posXRunesList = atoi(buffer);
log_msg("posXRunesList\t= %d\n", posXRunesList);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_posYRunesList, "45");
posYRunesList = atoi(buffer);
log_msg("posYRunesList\t= %d\n", posYRunesList);
GET_PRIVATE_PROFILE_STRING(S_INTERFACE, S_runesPerPage, "30");
runesPerPage = atoi(buffer);
log_msg("runesPerPage\t= %d\n", runesPerPage);
} }
log_msg("\n"); log_msg("\n");
} }
void init_ExtraOptions(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize) void init_ExtraOptions(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefaultFile, char* buffer, DWORD maxSize)
{ {
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_RunLODs, "0");
active_RunLODs = atoi(buffer) != 0;
log_msg("active_RunLODs\t\t\t\t= %u\n", active_RunLODs);
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_alwaysRegenMapInSP, "0"); GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_alwaysRegenMapInSP, "0");
active_alwaysRegenMapInSP = atoi(buffer); active_alwaysRegenMapInSP = atoi(buffer) != 0;
log_msg("active_alwaysRegenMapInSP\t= %d\n", active_alwaysRegenMapInSP); log_msg("active_alwaysRegenMapInSP\t= %d\n", active_alwaysRegenMapInSP);
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_nbPlayersCommandByDefault, "0"); GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_nbPlayersCommandByDefault, "0");
nbPlayersCommandByDefault = atoi(buffer); nbPlayersCommandByDefault = atoi(buffer);
if (version_D2Common == V110) if (version_D2Common == V109 || version_D2Common == V109b)
{if (nbPlayersCommandByDefault > 8) nbPlayersCommandByDefault=8;} {if (nbPlayersCommandByDefault > 64) nbPlayersCommandByDefault=64;}
else if (nbPlayersCommandByDefault > 64) nbPlayersCommandByDefault=64; else if (nbPlayersCommandByDefault > 8) nbPlayersCommandByDefault=8;
log_msg("nbPlayersCommandByDefault\t= %d\n", nbPlayersCommandByDefault); log_msg("nbPlayersCommandByDefault\t= %d\n", nbPlayersCommandByDefault);
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_DisplayItemLevel, "0"); GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_DisplayItemLevel, "0");
active_DisplayItemLevel = atoi(buffer); active_DisplayItemLevel = atoi(buffer) != 0;
log_msg("active_DisplayItemLevel\t\t= %d\n", active_DisplayItemLevel); log_msg("active_DisplayItemLevel\t\t= %d\n", active_DisplayItemLevel);
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_AlwaysDisplayLifeMana, "0"); GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_AlwaysDisplayLifeMana, "0");
active_AlwaysDisplayLifeMana = atoi(buffer); active_AlwaysDisplayLifeMana = atoi(buffer);
log_msg("active_AlwaysDisplayLifeMana= %d\n", active_AlwaysDisplayLifeMana); log_msg("active_AlwaysDisplayLifeMana= %d\n", active_AlwaysDisplayLifeMana);
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_RunLODs, "0");
active_RunLODs = atoi(buffer);
log_msg("active_RunLODs\t\t\t\t= %u\n", active_RunLODs);
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_EnabledTXTFilesWithMSExcel, "0"); GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_EnabledTXTFilesWithMSExcel, "0");
active_EnabledTXTFilesWithMSExcel = atoi(buffer); active_EnabledTXTFilesWithMSExcel = atoi(buffer) != 0;
log_msg("active_EnabledTXTFilesWithMSExcel= %u\n\n", active_EnabledTXTFilesWithMSExcel); log_msg("active_EnabledTXTFilesWithMSExcel= %u\n\n", active_EnabledTXTFilesWithMSExcel);
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_DisplayBaseStatsValue, "0"); GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_DisplayBaseStatsValue, "0");
active_DisplayBaseStatsValue = atoi(buffer); active_DisplayBaseStatsValue = atoi(buffer) != 0;
log_msg("active_DisplayBaseStatsValue= %u\n\n", active_DisplayBaseStatsValue); log_msg("active_DisplayBaseStatsValue= %u\n\n", active_DisplayBaseStatsValue);
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_LadderRunewords, "0"); GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_LadderRunewords, "0");
active_LadderRunewords = atoi(buffer); active_LadderRunewords = atoi(buffer) != 0;
if (active_LadderRunewords && (version_D2Common == V109b || version_D2Common == V109d) ) { if (active_LadderRunewords && version_D2Common < V110) {
active_LadderRunewords = 0; active_LadderRunewords = 0;
log_msg("active_LadderRunewords\t= %d (Warning : Warning : this feature is only for LoD version 1.10 or higher, so it's automatically disabled)\n", active_WorldEvent); log_msg("active_LadderRunewords\t= %d (Warning : this feature is only for LoD version 1.10 or higher, so it's automatically disabled)\n", active_WorldEvent);
} else } else
log_msg("active_LadderRunewords\t= %u\n\n", active_LadderRunewords); log_msg("active_LadderRunewords\t= %u\n\n", active_LadderRunewords);
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_EnabledCowPortalWhenCowKingWasKill, "0"); GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_EnabledCowPortalWhenCowKingWasKill, "0");
active_EnabledCowPortalWhenCowKingWasKill = atoi(buffer); active_EnabledCowPortalWhenCowKingWasKill = atoi(buffer) != 0;
log_msg("active_EnabledCowPortalWhenCowKingWasKill= %u\n\n", active_EnabledCowPortalWhenCowKingWasKill); log_msg("active_EnabledCowPortalWhenCowKingWasKill= %u\n\n", active_EnabledCowPortalWhenCowKingWasKill);
}
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_DoNotCloseNihlathakPortal, "0");
active_DoNotCloseNihlathakPortal = atoi(buffer) != 0;
log_msg("active_DoNotCloseNihlathakPortal= %u\n\n", active_DoNotCloseNihlathakPortal);
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_MoveCainNearHarrogathWaypoint, "0");
active_MoveCainNearHarrogathWaypoint = atoi(buffer) != 0;
log_msg("active_MoveCainNearHarrogathWaypoint= %u\n\n", active_MoveCainNearHarrogathWaypoint);
GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_RemoveExperienceDiminushingReturn, "0");
active_RemoveExperienceDiminushingReturn = atoi(buffer) != 0;
if (active_RemoveExperienceDiminushingReturn)
{
if (version_D2Common == V114d)
log_msg("active_RemoveExperienceDiminushingReturn= %u\n\n", active_RemoveExperienceDiminushingReturn);
else
{
active_RemoveExperienceDiminushingReturn = 0;
log_msg("active_RemoveExperienceDiminushingReturn\t= %d (Warning : this feature is only for LoD version 1.14d or higher, so it's automatically disabled)\n", active_RemoveExperienceDiminushingReturn);
}
}
}
void loadParameters() void loadParameters()
@ -853,6 +1198,7 @@ void loadParameters()
if(loading) if(loading)
{ {
log_msg("Reading parameters.\n\n"); log_msg("Reading parameters.\n\n");
init_ActivePlugin(iniFile, iniFixedFile, iniDefaultFile, buffer, BUFSIZE); init_ActivePlugin(iniFile, iniFixedFile, iniDefaultFile, buffer, BUFSIZE);
if (active_plugin) if (active_plugin)
{ {

119
PlugY/PlayerCustomData.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Adding custom data. Adding custom data.
Save and load infinity & shared Stash Save and load infinity & shared Stash
@ -13,7 +14,7 @@
#include "loadPlayerData.h" //Install_LoadPlayerData() #include "loadPlayerData.h" //Install_LoadPlayerData()
#include "common.h" #include "common.h"
bool active_PlayerCustomData = true; bool active_PlayerCustomData = false;
bool openSharedStashOnLoading = false; bool openSharedStashOnLoading = false;
@ -28,7 +29,9 @@ Stash* getStashFromItem(Unit* ptChar, Unit* ptItem)
{ {
if (curStash == PCPY->currentStash) if (curStash == PCPY->currentStash)
curItem = D2InventoryGetFirstItem(PCInventory); curItem = D2InventoryGetFirstItem(PCInventory);
else curItem = curStash->ptListItem; else
curItem = curStash->ptListItem;
while (curItem) while (curItem)
{ {
if (D2GetRealItem(curItem) == ptItem) return curStash; if (D2GetRealItem(curItem) == ptItem) return curStash;
@ -60,26 +63,33 @@ Unit* FASTCALL updateItem(Game* ptGame, DWORD type, DWORD itemNum, Unit* ptChar)
if (ptGame->isLODGame && (D2ItemGetPage(ptItem) == 4)) if (ptGame->isLODGame && (D2ItemGetPage(ptItem) == 4))
{ {
Stash* ptStash = getStashFromItem(ptChar, ptItem); Stash* ptStash = getStashFromItem(ptChar, ptItem);
//log_msg("- updateItem PCPY->currentStash->id : %d // ptStash->id : %d\n", PCPY->currentStash?PCPY->currentStash->id:-1, ptStash?ptStash->id:-1);
if (!ptStash) return NULL; if (!ptStash) return NULL;
selectStash(ptChar, ptStash); selectStash(ptChar, ptStash, ptStash->id == 0);
} }
return ptItem; return ptItem;
} }
void FASTCALL updateItem_111(Unit* ptItem, Unit* ptChar)
{
if (PCGame->isLODGame && (D2ItemGetPage(ptItem) == 4))
{
Stash* ptStash = getStashFromItem(ptChar, ptItem);
if (ptStash)
selectStash(ptChar, ptStash, ptStash->id == 0);
}
}
void STDCALL updateClientPlayerOnLoading(Unit* ptChar) void STDCALL updateClientPlayerOnLoading(Unit* ptChar)
{ {
log_msg("--- Start updateClientPlayerOnLoading ---\n"); log_msg("--- Start updateClientPlayerOnLoading ---\n");
if (PCGame->isLODGame) if (PCGame->isLODGame)
{ {
//selectStash(ptChar, openSharedStashOnLoading ? PCPY->sharedStash : PCPY->selfStash); PCPY->showSharedStash = openSharedStashOnLoading && active_sharedStash;
if (openSharedStashOnLoading) selectStash(ptChar, PCPY->showSharedStash ? PCPY->sharedStash : PCPY->selfStash, true);
toggleToSharedStash(ptChar);
else
toggleToSelfStash(ptChar);
log_msg("End update client on loading.\n\n");
} }
updateClient(ptChar, UC_SHARED_GOLD, PCPY->sharedGold, 0, 0); updateClient(ptChar, UC_SHARED_GOLD, PCPY->sharedGold, 0, 0);
log_msg("End update client on loading.\n\n");
} }
/**************************** INIT CUSTOM DATA ****************************/ /**************************** INIT CUSTOM DATA ****************************/
@ -164,15 +174,12 @@ Unit* STDCALL getNextItemToFree(Unit* ptChar, Unit* ptItem)
/************************ INSTALL PLAYER CUSTOM DATA ****************************/ /************************ INSTALL PLAYER CUSTOM DATA ****************************/
void FASTCALL updateItem_111(Unit* ptItem, Unit* ptChar) FCT_ASM ( caller_updateItem_114 )
{ PUSH EDI
if (PCGame->isLODGame && (D2ItemGetPage(ptItem) == 4)) PUSH DWORD PTR SS:[ESP+0x8]
{ CALL updateItem
Stash* ptStash = getStashFromItem(ptChar, ptItem); RETN 4
if (ptStash) }}
selectStash(ptChar, ptStash);
}
}
FCT_ASM ( caller_updateItem_111 ) FCT_ASM ( caller_updateItem_111 )
MOV ECX,ESI MOV ECX,ESI
@ -207,6 +214,16 @@ FCT_ASM ( caller_updateItem_9 )
RETN 4 RETN 4
}} }}
FCT_ASM ( caller_updateClientPlayerOnLoading_114 )
PUSH DWORD PTR SS:[ESP+0x14]
CALL updateClientPlayerOnLoading
POP ECX
POP EDI
POP ESI
XOR EAX,EAX
POP EBX
JMP ECX
}}
FCT_ASM ( caller_updateClientPlayerOnLoading ) FCT_ASM ( caller_updateClientPlayerOnLoading )
PUSH DWORD PTR SS:[ESP+0x14] PUSH DWORD PTR SS:[ESP+0x14]
@ -219,6 +236,13 @@ FCT_ASM ( caller_updateClientPlayerOnLoading )
JMP ECX JMP ECX
}} }}
FCT_ASM ( callerServer_getNextItemToFree_114 )
PUSH DWORD PTR SS:[ESP+4]
PUSH DWORD PTR SS:[EBP-8]
CALL getNextItemToFree
RETN 4
}}
FCT_ASM ( callerServer_getNextItemToFree_111 ) FCT_ASM ( callerServer_getNextItemToFree_111 )
PUSH DWORD PTR SS:[ESP+4] PUSH DWORD PTR SS:[ESP+4]
PUSH DWORD PTR SS:[ESP+0x30] PUSH DWORD PTR SS:[ESP+0x30]
@ -240,6 +264,12 @@ FCT_ASM ( callerServer_getNextItemToFree_9 )
RETN 4 RETN 4
}} }}
FCT_ASM ( callerClient_getNextItemToFree_114 )
PUSH DWORD PTR SS:[ESP+4]
PUSH DWORD PTR SS:[EBP-4]
CALL getNextItemToFree
RETN 4
}}
FCT_ASM ( callerClient_getNextItemToFree_111 ) FCT_ASM ( callerClient_getNextItemToFree_111 )
PUSH DWORD PTR SS:[ESP+4] PUSH DWORD PTR SS:[ESP+4]
@ -266,7 +296,7 @@ FCT_ASM ( callerClient_getNextItemToFree_9 )
void Install_PlayerCustomData() void Install_PlayerCustomData()
{ {
static int isInstalled = false; static int isInstalled = false;
if (isInstalled || !active_PlayerCustomData) return; if (isInstalled) return;
Install_SavePlayerData(); Install_SavePlayerData();
Install_LoadPlayerData(); Install_LoadPlayerData();
@ -275,7 +305,7 @@ void Install_PlayerCustomData()
log_msg("Patch D2Game & D2Client & D2Common for Player's custom data. (PlayerCustomData)\n"); log_msg("Patch D2Game & D2Client & D2Common for Player's custom data. (PlayerCustomData)\n");
// Initialize custom data. // Initialize custom data.
mem_seek(version_D2Client == V113d ? offset_D2Common + 0x170DE : version_D2Client == V113c ? offset_D2Common + 0x309BE : version_D2Client == V112 ? offset_D2Common + 0x585EE : version_D2Client == V111b ? offset_D2Common + 0x5BFCE : version_D2Common == V111 ? offset_D2Common + 0x4ED5E :(DWORD)D2InitPlayerData + 0x62 ); mem_seek(version_D2Client == V114d ? offset_D2Common + 0x221FDD : version_D2Client == V113d ? offset_D2Common + 0x170DE : version_D2Client == V113c ? offset_D2Common + 0x309BE : version_D2Client == V112 ? offset_D2Common + 0x585EE : version_D2Client == V111b ? offset_D2Common + 0x5BFCE : version_D2Common == V111 ? offset_D2Common + 0x4ED5E :(DWORD)D2InitPlayerData + 0x62 );
MEMJ_REF4( D2AllocMem, init_PlayerCustomData); MEMJ_REF4( D2AllocMem, init_PlayerCustomData);
//01BD0381 |. E8 C03F0000 CALL <JMP.&Fog.#10045> //01BD0381 |. E8 C03F0000 CALL <JMP.&Fog.#10045>
//6FD9ED5D |. E8 94A4FBFF CALL <JMP.&Fog.#10045> //6FD9ED5D |. E8 94A4FBFF CALL <JMP.&Fog.#10045>
@ -283,11 +313,12 @@ void Install_PlayerCustomData()
//6FDA85ED |. E8 240CFBFF CALL <JMP.&Fog.#10045> //6FDA85ED |. E8 240CFBFF CALL <JMP.&Fog.#10045>
//6FD809BD |. E8 6088FDFF CALL <JMP.&Fog.#10045> //6FD809BD |. E8 6088FDFF CALL <JMP.&Fog.#10045>
//6FD670DD |. E8 0C3EFFFF CALL <JMP.&Fog.#10045> //6FD670DD |. E8 0C3EFFFF CALL <JMP.&Fog.#10045>
//00621FDC |. E8 4F94DEFF CALL Game.0040B430 ; \Game.0040B430
if ( version_D2Game >= V111 ) if ( version_D2Game >= V111 && version_D2Game <= V113d)
{ {
// update item // update item
mem_seek R7(D2Game, 10933, 10C03, 1100D, 8BC71, C3C51, 5F2A1, 9BB91, 75C81); mem_seek R8(D2Game, 10933, 10C03, 1100D, 8BC71, C3C51, 5F2A1, 9BB91, 75C81, 0000);
memt_byte( 0x8B ,0xE8); // CALL memt_byte( 0x8B ,0xE8); // CALL
MEMT_REF4( 0x52182454, caller_updateItem_111); MEMT_REF4( 0x52182454, caller_updateItem_111);
//0200BC71 |> 8B5424 18 |MOV EDX,DWORD PTR SS:[ESP+18] //0200BC71 |> 8B5424 18 |MOV EDX,DWORD PTR SS:[ESP+18]
@ -301,7 +332,7 @@ void Install_PlayerCustomData()
//6FC95C81 |> 8B5424 18 |MOV EDX,DWORD PTR SS:[ESP+18] //6FC95C81 |> 8B5424 18 |MOV EDX,DWORD PTR SS:[ESP+18]
//6FC95C85 |. 52 |PUSH EDX //6FC95C85 |. 52 |PUSH EDX
mem_seek R7(D2Game, 1097B, 10C4B, 11058, 8BCD1, C3CB1, 5F301, 9BBF1, 75CE1); mem_seek R8(D2Game, 1097B, 10C4B, 11058, 8BCD1, C3CB1, 5F301, 9BBF1, 75CE1, 0000);
memt_byte( 0x8B ,0xE8); // CALL memt_byte( 0x8B ,0xE8); // CALL
MEMT_REF4( 0x52182454, caller_updateItemB_111); MEMT_REF4( 0x52182454, caller_updateItemB_111);
//0200BCD1 |> 8B5424 18 ||MOV EDX,DWORD PTR SS:[ESP+18] //0200BCD1 |> 8B5424 18 ||MOV EDX,DWORD PTR SS:[ESP+18]
@ -317,18 +348,20 @@ void Install_PlayerCustomData()
} else { } else {
// update item // update item
mem_seek R7(D2Game, 10933, 10C03, 1100D, 8BC71, C3C51, 5F2A1, 0000, 0000); mem_seek R8(D2Game, 10933, 10C03, 1100D, 8BC71, C3C51, 5F2A1, 0000, 0000, 1978F3);
MEMC_REF4( D2GameGetObject, version_D2Game == V110?caller_updateItem: caller_updateItem_9); MEMC_REF4( D2GameGetObject, version_D2Game >= V114a ? caller_updateItem_114 : version_D2Game >= V110 ? caller_updateItem : caller_updateItem_9);
//6FC4100C |. E8 EFAA0700 |CALL D2Game.6FCBBB00 //6FC4100C |. E8 EFAA0700 |CALL D2Game.6FCBBB00
mem_seek R7(D2Game, 1097B, 10C4B, 11058, 8BCD1, C3CB1, 5F301, 0000, 0000); //005978F2 |. E8 69B6FBFF |CALL Game.00552F60 ; \Game.00552F60
MEMC_REF4( D2GameGetObject, version_D2Game == V110?caller_updateItem: caller_updateItem_9); mem_seek R8(D2Game, 1097B, 10C4B, 11058, 8BCD1, C3CB1, 5F301, 0000, 0000, 197943);
MEMC_REF4( D2GameGetObject, version_D2Game >= V114a ? caller_updateItem_114 : version_D2Game >= V110 ? caller_updateItem : caller_updateItem_9);
//6FC41057 |. E8 A4AA0700 ||CALL D2Game.6FCBBB00 //6FC41057 |. E8 A4AA0700 ||CALL D2Game.6FCBBB00
//00597942 |. E8 19B6FBFF |CALL Game.00552F60 ; \Game.00552F60 //005978F2 |. E8 69B6FBFF |CALL Game.00552F60 ; \Game.00552F60
} }
// Update client on loading // Update client on loading
mem_seek R7(D2Game, 23EB, 2426, 25D4, 53482, C6A32, ED502, 4BF12, E7548);//6FC325D4-6FC30000 mem_seek R8(D2Game, 23EB, 2426, 25D4, 53482, C6A32, ED502, 4BF12, E7548, 139A20);//6FC325D4-6FC30000
memt_byte( 0x5F ,0xE8); // CALL memt_byte( 0x5F ,0xE8); // CALL
MEMT_REF4( 0xC0335D5E , caller_updateClientPlayerOnLoading); MEMT_REF4( version_D2Game >= V114d ? 0x5BC0335E : 0xC0335D5E , version_D2Game >= V114d ? caller_updateClientPlayerOnLoading_114 : caller_updateClientPlayerOnLoading);
//6FC325D4 |> 5F POP EDI //6FC325D4 |> 5F POP EDI
//6FC325D5 |. 5E POP ESI //6FC325D5 |. 5E POP ESI
//6FC325D6 |. 5D POP EBP //6FC325D6 |. 5D POP EBP
@ -353,9 +386,13 @@ void Install_PlayerCustomData()
//6FD07549 |. 5E POP ESI //6FD07549 |. 5E POP ESI
//6FD0754A |. 5D POP EBP //6FD0754A |. 5D POP EBP
//6FD0754B |. 33C0 XOR EAX,EAX //6FD0754B |. 33C0 XOR EAX,EAX
//00539A20 |> 5F POP EDI
//00539A21 |. 5E POP ESI
//00539A22 |. 33C0 XOR EAX,EAX
//00539A24 |. 5B POP EBX
// Free custom data. // Free custom data.
mem_seek R7(D2Common, 7055C, 7065C, 80483, 4F82D, 5C9CD, 5856D, 3093D, 1705D); mem_seek R8(D2Common, 7055C, 7065C, 80483, 4F82D, 5C9CD, 5856D, 3093D, 1705D, 2220DD);
MEMJ_REF4( D2FreeMem, free_PlayerCustomData); MEMJ_REF4( D2FreeMem, free_PlayerCustomData);
//01BD0482 |. E8 C53E0000 CALL <JMP.&Fog.#10046> //01BD0482 |. E8 C53E0000 CALL <JMP.&Fog.#10046>
//6FD9F82C |. E8 E399FBFF CALL <JMP.&Fog.#10046> //6FD9F82C |. E8 E399FBFF CALL <JMP.&Fog.#10046>
@ -363,51 +400,55 @@ void Install_PlayerCustomData()
//6FDA856C |. E8 E70CFBFF CALL <JMP.&Fog.#10046> //6FDA856C |. E8 E70CFBFF CALL <JMP.&Fog.#10046>
//6FD8093C |. E8 E788FDFF CALL <JMP.&Fog.#10046> //6FD8093C |. E8 E788FDFF CALL <JMP.&Fog.#10046>
//6FD6705C |. E8 CF3EFFFF CALL <JMP.&Fog.#10046> //6FD6705C |. E8 CF3EFFFF CALL <JMP.&Fog.#10046>
//006220DC |. E8 9F93DEFF CALL Game.0040B480 ; \Game.0040B480
// Free item in Stash (Server-side) // Free item in Stash (Server-side)
mem_seek R7(D2Game, 7D12B, 7D62B, 8D5A4, 99112, BFDB2, 94242, E1162, 6F7C2); mem_seek R8(D2Game, 7D12B, 7D62B, 8D5A4, 99112, BFDB2, 94242, E1162, 6F7C2, 155B34);
MEMJ_REF4( D2UnitGetNextItem, version_D2Game >= V111 ? callerServer_getNextItemToFree_111 : version_D2Game == V110 ? callerServer_getNextItemToFree : callerServer_getNextItemToFree_9);//0x0005E204 MEMJ_REF4( D2UnitGetNextItem, version_D2Game >= V114a ? callerServer_getNextItemToFree_114 : version_D2Game >= V111 ? callerServer_getNextItemToFree_111 : version_D2Game == V110 ? callerServer_getNextItemToFree : callerServer_getNextItemToFree_9);//0x0005E204
//6FCBD5A3 . E8 04E20500 CALL <JMP.&D2Common.#10304> //6FCBD5A3 . E8 04E20500 CALL <JMP.&D2Common.#10304>
//02019111 |. E8 5016F7FF |CALL <JMP.&D2Common.#10934> //02019111 |. E8 5016F7FF |CALL <JMP.&D2Common.#10934>
//0202FDB1 |. E8 30AAF4FF |CALL <JMP.&D2Common.#11140> //0202FDB1 |. E8 30AAF4FF |CALL <JMP.&D2Common.#11140>
//6FCB4241 |. E8 8862F7FF |CALL <JMP.&D2Common.#10770> //6FCB4241 |. E8 8862F7FF |CALL <JMP.&D2Common.#10770>
//6FD01161 |. E8 6693F2FF |CALL <JMP.&D2Common.#10464> //6FD01161 |. E8 6693F2FF |CALL <JMP.&D2Common.#10464>
//6FC8F7C1 |. E8 44AEF9FF |CALL <JMP.&D2Common.#10879> //6FC8F7C1 |. E8 44AEF9FF |CALL <JMP.&D2Common.#10879>
//00555B33 |. E8 68840E00 |CALL Game.0063DFA0 ; \Game.0063DFA0
// Free item in Stash (Client-side) // Free item in Stash (Client-side)
mem_seek R7(D2Client, 8EF8F, 8E30F, 89B32, 26404, 4C264, 1F2D4, A5C94, 621E4);//6FB29B31-6FAA0000 mem_seek R8(D2Client, 8EF8F, 8E30F, 89B32, 26404, 4C264, 1F2D4, A5C94, 621E4, 66D02);//6FB29B31-6FAA0000
MEMJ_REF4( D2UnitGetNextItem, version_D2Game >= V111 ? callerClient_getNextItemToFree_111 : version_D2Game == V110 ? callerClient_getNextItemToFree : callerClient_getNextItemToFree_9);//0x00040F34 MEMJ_REF4( D2UnitGetNextItem, version_D2Game >= V114d ? callerClient_getNextItemToFree_114 : version_D2Game >= V111 ? callerClient_getNextItemToFree_111 : version_D2Game == V110 ? callerClient_getNextItemToFree : callerClient_getNextItemToFree_9);//0x00040F34
//6FB29B31 E8 340F0400 CALL <JMP.&D2Common.#10304> //6FB29B31 E8 340F0400 CALL <JMP.&D2Common.#10304>
//6FAD6403 |. E8 925DFEFF |CALL <JMP.&D2Common.#10934> //6FAD6403 |. E8 925DFEFF |CALL <JMP.&D2Common.#10934>
//6FAFC263 |. E8 38FFFBFF |CALL <JMP.&D2Common.#11140> //6FAFC263 |. E8 38FFFBFF |CALL <JMP.&D2Common.#11140>
//6FACF2D3 |. E8 4CD1FEFF |CALL <JMP.&D2Common.#10770> //6FACF2D3 |. E8 4CD1FEFF |CALL <JMP.&D2Common.#10770>
//6FB55C93 |. E8 D068F6FF |CALL <JMP.&D2Common.#10464> //6FB55C93 |. E8 D068F6FF |CALL <JMP.&D2Common.#10464>
//6FB121E3 |. E8 7AA1FAFF |CALL <JMP.&D2Common.#10879> //6FB121E3 |. E8 7AA1FAFF |CALL <JMP.&D2Common.#10879>
//00466D01 E8 9A721D00 |CALL Game.0063DFA0
if ( version_D2Common >= V110 ) if ( version_D2Common >= V110 )
{ {
// Test if it's already removed from inventory // Test if it's already removed from inventory
mem_seek R7(D2Common, 0000, 0000, 4E689, 26E33, 42133, 6AE93, 21B23, 3B393); mem_seek R8(D2Common, 0000, 0000, 4E689, 26E33, 42133, 6AE93, 21B23, 3B393, 23ADB5);
memt_byte( 0x0D , 0x07); memt_byte( version_D2Common == V114d ? 0x0E : 0x0D , 0x07);
//01D2E688 75 0D JNZ SHORT D2Common.01D2E697 //01D2E688 75 0D JNZ SHORT D2Common.01D2E697
//6FD76E32 |. 74 0D JE SHORT D2Common.6FD76E41 //6FD76E32 |. 74 0D JE SHORT D2Common.6FD76E41
//6FD92132 |. 74 0D JE SHORT D2Common.6FD92141 //6FD92132 |. 74 0D JE SHORT D2Common.6FD92141
//6FDBAE92 |. 74 0D JE SHORT D2Common.6FDBAEA1 //6FDBAE92 |. 74 0D JE SHORT D2Common.6FDBAEA1
//6FD71B22 |. 74 0D JE SHORT D2Common.6FD71B31 //6FD71B22 |. 74 0D JE SHORT D2Common.6FD71B31
//6FD8B392 |. 74 0D JE SHORT D2Common.6FD8B3A1 //6FD8B392 |. 74 0D JE SHORT D2Common.6FD8B3A1
//0063ADB4 |. 74 0E JE SHORT Game.0063ADC4
} else { } else {
mem_seek R7(D2Game, 7D176, 7D676, 0000, 0000, 0000, 0000, 0000, 0000); mem_seek R8(D2Game, 7D176, 7D676, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0x74 , 0x90);//MOV EAX,EDI memt_byte( 0x74 , 0x90);//MOV EAX,EDI
memt_byte( 0x35 , 0x90);//NOP memt_byte( 0x35 , 0x90);//NOP
//6FCAD176 |. 74 35 |JE SHORT D2Game.6FCAD1AD //6FCAD176 |. 74 35 |JE SHORT D2Game.6FCAD1AD
mem_seek R7(D2Client, 8F0CA, 8E44A, 0000, 0000, 0000, 0000, 0000, 0000); mem_seek R8(D2Client, 8F0CA, 8E44A, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0x0F , 0x90);//MOV EAX,EDI memt_byte( 0x0F , 0x90);//MOV EAX,EDI
memt_byte( 0x84 , 0x90);//NOP memt_byte( 0x84 , 0x90);//NOP
memt_dword( 0x000000BF , 0x90909090);//NOP memt_dword( 0x000000BF , 0x90909090);//NOP
//6FB2F0CA |. 0F84 BF000000 |JE D2Client.6FB2F18F //6FB2F0CA |. 0F84 BF000000 |JE D2Client.6FB2F18F
mem_seek R7(D2Client, 8F13C, 8E4BC, 0000, 0000, 0000, 0000, 0000, 0000); mem_seek R8(D2Client, 8F13C, 8E4BC, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0x74 , 0x90);//MOV EAX,EDI memt_byte( 0x74 , 0x90);//MOV EAX,EDI
memt_byte( 0x6F , 0x90);//NOP memt_byte( 0x6F , 0x90);//NOP
//6FB2F13C |. 74 6F |JE SHORT D2Client.6FB2F1AD //6FB2F13C |. 74 6F |JE SHORT D2Client.6FB2F1AD

BIN
PlugY/PlugY.aps Normal file
View File

Binary file not shown.

BIN
PlugY/PlugY.rc
View File

Binary file not shown.

11
PlugY/PlugY.sln
View File

@ -1,7 +1,9 @@
 
Microsoft Visual Studio Solution File, Format Version 10.00 Microsoft Visual Studio Solution File, Format Version 12.00
# Visual C++ Express 2008 # Visual Studio Version 17
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PlugY", "PlugY.vcproj", "{EB63DF4E-A019-4522-A140-9E8C7350B331}" VisualStudioVersion = 17.2.32505.173
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PlugY", "PlugY.vcxproj", "{EB63DF4E-A019-4522-A140-9E8C7350B331}"
EndProject EndProject
Global Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution GlobalSection(SolutionConfigurationPlatforms) = preSolution
@ -17,4 +19,7 @@ Global
GlobalSection(SolutionProperties) = preSolution GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE HideSolutionNode = FALSE
EndGlobalSection EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {83A1632A-5376-46CE-89D9-F2D4E74FFE31}
EndGlobalSection
EndGlobal EndGlobal

BIN
PlugY/PlugY.suo
View File

Binary file not shown.

152
PlugY/PlugYFiles.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Adding custom data. Adding custom data.
Save and load infinity & shared Stash Save and load infinity & shared Stash
@ -29,12 +30,14 @@ DWORD STDCALL isModFile (char* filename)
{ {
if (strstr(filename, modDataDirectory) ) if (strstr(filename, modDataDirectory) )
{ {
log_msg("Load custom file : %s\n", filename);
if ((GetFileAttributesA(filename) & 0x10) == 0)
return true;
char fileTemp[0x104]; char fileTemp[0x104];
log_msg("Load custom file : %s", filename);
strcpy(fileTemp,filename); strcpy(fileTemp,filename);
D2FogGetInstallPath(filename,0x104-strlen(filename)); D2FogGetInstallPath(filename,0x104-strlen(filename));
strcat(filename,fileTemp); strcat(filename,fileTemp);
log_msg("-> %s\n", filename); log_msg("Load custom file full path : %s\n", filename);
if ((GetFileAttributesA(filename) & 0x10) == 0) if ((GetFileAttributesA(filename) & 0x10) == 0)
return true; return true;
} }
@ -42,6 +45,17 @@ DWORD STDCALL isModFile (char* filename)
} }
DWORD STDCALL isModFile_114 (char* filename)
{
if (strstr(filename, modDataDirectory) )
{
log_msg("Load custom file : %s\n", filename);
if ((GetFileAttributesA(filename) & 0x10) == 0)
return true;
}
return false;
}
FCT_ASM ( caller_isModFile ) FCT_ASM ( caller_isModFile )
TEST ESI,ESI TEST ESI,ESI
JNZ ISNOTMODDATA JNZ ISNOTMODDATA
@ -78,6 +92,39 @@ FCT_ASM ( caller_isModFile_111 )
ISNOTMODDATA: ISNOTMODDATA:
JMP DWORD PTR CS:[LeaveCriticalSection] JMP DWORD PTR CS:[LeaveCriticalSection]
}} }}
/*
FCT_ASM ( caller_isModFile_114 )
TEST ESI,ESI
JNZ ISNOTMODDATA
MOV ESI, DWORD PTR SS:[ESP+0x130]
PUSH ESI
CALL isModFile
TEST EAX,EAX
JE ISNOTMODDATA
MOV BL, BYTE PTR SS:[ESP+0x134]
POP EAX
POP EAX
MOV EAX,D2StormMPQOpenFile
ADD EAX,0x93
MOV EBP,GetFileAttributesA
JMP EAX
ISNOTMODDATA:
JMP DWORD PTR CS:[LeaveCriticalSection]
}}
*/
FCT_ASM( caller_isModFile_114 )
PUSH EDX
PUSH EBX
CALL isModFile_114
POP EDX
TEST EAX,EAX
JE ISNOTMODDATA
MOV EDX,1 // Active -direct command
ISNOTMODDATA:
LEA EAX,DWORD PTR SS:[EBP-0x108]
RETN
}}
void Install_PlugYFiles() void Install_PlugYFiles()
{ {
@ -87,17 +134,25 @@ void Install_PlugYFiles()
log_msg("Patch Storm to found custom file. (PlugYFiles)\n"); log_msg("Patch Storm to found custom file. (PlugYFiles)\n");
// Try in Diablo II\PlugY\ if file not found // Try in Diablo II\PlugY\ if file not found
mem_seek R7(Storm, 192C6, 19296, 18677, 2CC69, 14259, 121E9, 28D89, 2DA79);//( (DWORD)D2Storm268 + V7(Storm, 01A8, 01A8, 01AB, 0429, 0429, 0429, 0000) ); mem_seek R8(Storm, 192C6, 19296, 18677, 2CC69, 14259, 121E9, 28D89, 2DA79, 19369);//( (DWORD)D2Storm268 + V7(Storm, 01A8, 01A8, 01AB, 0429, 0429, 0429, 0000) );
if ( version_Storm >= V114a )
{
memt_byte( 0x8D ,0x90); // NOP
memt_byte( 0x85 ,0xE8); // CALL
MEMT_REF4(0xFFFFFEF8, caller_isModFile_114);
//00419369 |. 8D85 F8FEFFFF LEA EAX,DWORD PTR SS:[EBP-108]
} else {
memt_byte( 0xFF ,0x90); // NOP memt_byte( 0xFF ,0x90); // NOP
memt_byte( 0x15 ,0xE8); // CALL memt_byte( 0x15 ,0xE8); // CALL
MEMD_REF4( LeaveCriticalSection, version_Storm >= V111 ? caller_isModFile_111 : caller_isModFile); MEMD_REF4( LeaveCriticalSection, version_Storm >= V114a ? caller_isModFile_114 : version_Storm >= V111 ? caller_isModFile_111 : caller_isModFile);
//6FFC8677 |. FF15 F411FE6F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection //6FFC8677 |. FF15 F411FE6F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
//6FC1CC69 |. FF15 3832C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection //6FC1CC69 |. FF15 3832C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
//6FC04259 |. FF15 3832C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection //6FC04259 |. FF15 3832C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
//6FC021E9 |. FF15 4432C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection //6FC021E9 |. FF15 4432C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
//6FC18D89 |. FF15 5832C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection //6FC18D89 |. FF15 5832C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
//6FC1DA79 |. FF15 3C32C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection //6FC1DA79 |. FF15 3C32C36F CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
//0041BC81 |. FF15 14C26C00 CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
}
log_msg("\n" ); log_msg("\n" );
@ -136,24 +191,37 @@ void STDCALL loadCustomImages()
if ( active_newInterfaces ) loadImagesFile(&statsBackgroundImages, "StatsBackground"); if ( active_newInterfaces ) loadImagesFile(&statsBackgroundImages, "StatsBackground");
} }
#define freeImagesFile(I) if(I) {D2FreeImage(I);I=NULL;} #define FREE_IMAGE_FILE(I) if(I) {D2FreeImage(I);I=NULL;}
void STDCALL freeCustomImages() void STDCALL freeCustomImages()
{ {
freeImagesFile(unassignSkillsBtnImages); FREE_IMAGE_FILE(unassignSkillsBtnImages);
freeImagesFile(unassignStatsBtnImages); FREE_IMAGE_FILE(unassignStatsBtnImages);
freeImagesFile(stashBtnsImages); FREE_IMAGE_FILE(stashBtnsImages);
freeImagesFile(sharedGoldBtnsImages); FREE_IMAGE_FILE(sharedGoldBtnsImages);
freeImagesFile(newStatsInterfaceImages); FREE_IMAGE_FILE(newStatsInterfaceImages);
freeImagesFile(statsBackgroundImages); FREE_IMAGE_FILE(statsBackgroundImages);
} }
FCT_ASM ( caller_loadCustomImages_114 )
PUSH ECX
CALL loadCustomImages
POP ECX
JMP D2LoadResImage
}}
FCT_ASM ( caller_loadCustomImages ) FCT_ASM ( caller_loadCustomImages )
CALL loadCustomImages CALL loadCustomImages
MOV ECX,0x0C MOV ECX,0x0C
RETN RETN
}} }}
FCT_ASM ( caller_freeCustomImages_114 )
CALL freeCustomImages
CALL D2FreeResImages
RETN
}}
FCT_ASM ( caller_freeCustomImages ) FCT_ASM ( caller_freeCustomImages )
CALL freeCustomImages CALL freeCustomImages
MOV ECX,0x0C MOV ECX,0x0C
@ -170,7 +238,12 @@ void Install_PlugYImagesFiles()
log_msg("Patch D2Client to load/free custom images. (PlugYImagesFiles)\n"); log_msg("Patch D2Client to load/free custom images. (PlugYImagesFiles)\n");
// Load custom images // Load custom images
mem_seek R7(D2Client, 57E21, 57E21, 5E4B1, 2E101, B67E1, 82761, 27EAE, 6E0BE); mem_seek R8(D2Client, 57E21, 57E21, 5E4B1, 2E101, B67E1, 82761, 27EAE, 6E0BE, 9692F);
if (version_D2Client == V114d)
{
MEMC_REF4( D2LoadResImage , caller_loadCustomImages_114);
//0049692E |. E8 8DB7FBFF CALL Game.004520C0
} else {
memt_byte( 0xB9 ,0xE8); memt_byte( 0xB9 ,0xE8);
MEMT_REF4( 0x0000000C , caller_loadCustomImages); MEMT_REF4( 0x0000000C , caller_loadCustomImages);
//6FAFE4B1 |. B9 0C000000 MOV ECX,0C //6FAFE4B1 |. B9 0C000000 MOV ECX,0C
@ -179,9 +252,15 @@ void Install_PlugYImagesFiles()
//6FB32761 |. B9 0C000000 MOV ECX,0C //6FB32761 |. B9 0C000000 MOV ECX,0C
//6FAD7EAE |. B9 0C000000 MOV ECX,0C //6FAD7EAE |. B9 0C000000 MOV ECX,0C
//6FB1E0BE |. B9 0C000000 MOV ECX,0C //6FB1E0BE |. B9 0C000000 MOV ECX,0C
}
// Free custom images // Free custom images
mem_seek R7(D2Client, 57FA9, 57FA9, 5E639, 2D12D, B580D, 8158D, 26F8D, 6D07D); mem_seek R8(D2Client, 57FA9, 57FA9, 5E639, 2D12D, B580D, 8158D, 26F8D, 6D07D, 56DED);
if (version_D2Client == V114d)
{
MEMC_REF4( D2FreeResImages , caller_freeCustomImages_114);
//00456DEC . E8 9FFB0300 CALL Game.00496990
} else {
memt_byte( 0xB9 ,0xE8); memt_byte( 0xB9 ,0xE8);
MEMT_REF4( 0x0000000C , caller_freeCustomImages); MEMT_REF4( 0x0000000C , caller_freeCustomImages);
//6FAFE639 |> B9 0C000000 MOV ECX,0C //6FAFE639 |> B9 0C000000 MOV ECX,0C
@ -190,6 +269,7 @@ void Install_PlugYImagesFiles()
//6FB3158D |> B9 0C000000 MOV ECX,0C //6FB3158D |> B9 0C000000 MOV ECX,0C
//6FAD6F8D |> B9 0C000000 MOV ECX,0C //6FAD6F8D |> B9 0C000000 MOV ECX,0C
//6FB1D07D |> B9 0C000000 MOV ECX,0C //6FB1D07D |> B9 0C000000 MOV ECX,0C
}
log_msg("\n" ); log_msg("\n" );
@ -198,12 +278,36 @@ void Install_PlugYImagesFiles()
/****************************************************************************************************/ /****************************************************************************************************/
/*char* STDCALL isModCompileFile (char* filename)
{
if (strstr(filename, modDataDirectory) )
return ".";
return NULL;
}
char * fff = "%s";
FCT_ASM( caller_compileExcel_114 )
PUSH ECX
PUSH EDX
PUSH EDX
CALL isModCompileFile
POP EDX
POP ECX
TEST EAX,EAX
JE ISNOTMODDATA
POP EAX
MOV DWORD PTR SS:[ESP],EDX
PUSH fff
ADD EAX,5
PUSH EAX
ISNOTMODDATA:
LEA EAX,DWORD PTR SS:[EBP-0x108]
RETN
}}*/
void loadStatsInterfaceDesc(DWORD mempool); void loadStatsInterfaceDesc(DWORD mempool);
void freeStatsInterfaceDesc(); void freeStatsInterfaceDesc();
void FASTCALL loadTxtFiles(DWORD mempool) void FASTCALL loadTxtFiles(DWORD mempool)
{ {
loadStatsInterfaceDesc(mempool); loadStatsInterfaceDesc(mempool);
@ -232,7 +336,6 @@ FCT_ASM ( caller_freeTxtFiles )
JMP D2Fog10212 JMP D2Fog10212
}} }}
void Install_PlugYTxtFiles() void Install_PlugYTxtFiles()
{ {
static int isInstalled = false; static int isInstalled = false;
@ -245,8 +348,8 @@ void Install_PlugYTxtFiles()
// lookupItemStatCost = (void*)R7(D2Common, A1D70, A1D70, AA1D8, 0000, 0000, 0000, 0000); // lookupItemStatCost = (void*)R7(D2Common, A1D70, A1D70, AA1D8, 0000, 0000, 0000, 0000);
// Load custom txt files // Load custom txt files
mem_seek R7(D2Common, 7F4B, 7F4B, 2F7D7, 76854, 37444, 81C44, 5D6E4, 855E4); mem_seek R8(D2Common, 7F4B, 7F4B, 2F7D7, 76854, 37444, 81C44, 5D6E4, 855E4, 25A560);
MEMC_REF4( D2LoadSuperuniques, version_D2Common >= V111 ? caller_loadTxtFiles_111 : caller_loadTxtFiles ); MEMC_REF4( D2LoadSuperuniques, version_D2Common >= V111 && version_D2Common < V114a ? caller_loadTxtFiles_111 : caller_loadTxtFiles );
//6FD47F4A |. E8 B1750100 CALL D2Common.6FD5F500 //6FD47F4A |. E8 B1750100 CALL D2Common.6FD5F500
//6FD47F4A |. E8 C1750100 CALL D2Common.6FD5F510 //6FD47F4A |. E8 C1750100 CALL D2Common.6FD5F510
//01B6F7D6 |. E8 C5A7FFFF CALL D2Common.01B69FA0 //01B6F7D6 |. E8 C5A7FFFF CALL D2Common.01B69FA0
@ -255,9 +358,10 @@ void Install_PlugYTxtFiles()
//6FDD1C43 |. E8 58B6FFFF CALL D2Common.6FDCD2A0 ; \D2Common.6FDCD2A0 //6FDD1C43 |. E8 58B6FFFF CALL D2Common.6FDCD2A0 ; \D2Common.6FDCD2A0
//6FDAD6E3 |. E8 88C1FFFF CALL D2Common.6FDA9870 ; \D2Common.6FDA9870 //6FDAD6E3 |. E8 88C1FFFF CALL D2Common.6FDA9870 ; \D2Common.6FDA9870
//6FDD55E3 |. E8 58B6FFFF CALL D2Common.6FDD0C40 ; \D2Common.6FDD0C40 //6FDD55E3 |. E8 58B6FFFF CALL D2Common.6FDD0C40 ; \D2Common.6FDD0C40
//0065A55F |. E8 7CADFFFF CALL Game.006552E0
// Free custom txt files // Free custom txt files
mem_seek R7(D2Common, 79EC, 79EC, 10186, 332B3, 15AB3, 44E13, 5E8B3, FAA3); mem_seek R8(D2Common, 79EC, 79EC, 10186, 332B3, 15AB3, 44E13, 5E8B3, FAA3, 25A1C8);
MEMJ_REF4( D2Fog10212, caller_freeTxtFiles ); MEMJ_REF4( D2Fog10212, caller_freeTxtFiles );
//6FD479EB . E8 C8C00600 CALL <JMP.&Fog.#10212> //6FD479EB . E8 C8C00600 CALL <JMP.&Fog.#10212>
//6FD479EB . E8 C8C00600 CALL <JMP.&Fog.#10212> //6FD479EB . E8 C8C00600 CALL <JMP.&Fog.#10212>
@ -267,6 +371,16 @@ void Install_PlugYTxtFiles()
//6FD94E12 |. E8 1744FCFF CALL <JMP.&Fog.#10212> //6FD94E12 |. E8 1744FCFF CALL <JMP.&Fog.#10212>
//6FDAE8B2 |. E8 8FA9FAFF CALL <JMP.&Fog.#10212> //6FDAE8B2 |. E8 8FA9FAFF CALL <JMP.&Fog.#10212>
//6FD5FAA2 |. E8 5FB4FFFF CALL <JMP.&Fog.#10212> //6FD5FAA2 |. E8 5FB4FFFF CALL <JMP.&Fog.#10212>
//0065A1C7 . E8 E42E0600 CALL Game.006BD0B0 ; \Game.006BD0B0
/*if ( version_D2Client >= V114a )
{
mem_seek R8(Storm, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 2122A2);
memt_byte( 0x8D ,0x90); // NOP
memt_byte( 0x85 ,0xE8); // CALL
MEMT_REF4(0xFFFFFEF8, caller_compileExcel_114);
//006122A2 |. 8D85 F8FEFFFF LEA EAX,DWORD PTR SS:[EBP-108] ; |
}*/
log_msg("\n" ); log_msg("\n" );

78
PlugY/SavePath.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Changing the current save path. Changing the current save path.
@ -49,6 +50,50 @@ END_CHANGESP:
RETN RETN
}} }}
FCT_ASM( changeSavePath_114 )
PUSH EAX
PUSH EDI
PUSH EDX
PUSH ESI
MOV ESI, EBX
MOV EDI,DWORD PTR DS:[savePath]
XOR AL,AL
CLD
OR ECX,0xFFFFFFFF
REPNE SCAS BYTE PTR ES:[EDI]
NOT ECX
SUB EDI,ECX
XCHG EDI,ESI
CMP BYTE PTR [ESI+1],':'
JE END_CHANGESP
//RELATIVE_PATH:
MOV EDX,ECX
OR ECX,0xFFFFFFFF
REPNE SCAS BYTE PTR ES:[EDI]
DEC EDI
CMP BYTE PTR [EDI-1],'\\'
JE NEXT
MOV BYTE PTR [EDI],'\\'
INC EDI
NEXT:
MOV ECX,EDX
END_CHANGESP:
REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]
POP ESI
POP EDX
POP EDI
POP EAX
PUSH EBX
CALL DWORD PTR[GetFileAttributesA]
CMP EAX,-1
JE DONOT_JMP
ADD DWORD PTR SS:[ESP],0x5
RETN
DONOT_JMP:
ADD DWORD PTR SS:[ESP],0x1D
RETN
}}
FCT_ASM( changeSavePath_111 ) FCT_ASM( changeSavePath_111 )
PUSH EAX PUSH EAX
PUSH EDI PUSH EDI
@ -88,6 +133,7 @@ DONOT_JMP:
RETN RETN
}} }}
FCT_ASM ( forCreateSavePath ) FCT_ASM ( forCreateSavePath )
PUSH EDI PUSH EDI
MOV EDI,DWORD PTR DS:[savePath] MOV EDI,DWORD PTR DS:[savePath]
@ -111,7 +157,6 @@ END_CREATESP:
}} }}
void Install_ChangingSavePath() void Install_ChangingSavePath()
{ {
static int isInstalled = false; static int isInstalled = false;
@ -121,10 +166,10 @@ void Install_ChangingSavePath()
if (version_Fog >= V111) if (version_Fog >= V111)
{ {
// Appel de notre fct d'ajout d'un sous-répertoire // Call funtion to manage subfolder
mem_seek R7(Fog, 000, 000, 000, 185F6, 1C106, 1F086, 17F86, 1E146); mem_seek R8(Fog, 000, 000, 000, 185F6, 1C106, 1F086, 17F86, 1E146, 71A6);
memt_byte( 0x83 ,0xE8); // CALL changeSavePath memt_byte( 0x83 ,0xE8); // CALL changeSavePath
MEMT_REF4( 0x0575FFF8, changeSavePath_111); MEMT_REF4( 0x0575FFF8, version_Fog == V114d ? changeSavePath_114 : changeSavePath_111);
//6FF685F6 . 83F8 FF CMP EAX,-1 //6FF685F6 . 83F8 FF CMP EAX,-1
//6FF685F9 . 75 05 JNZ SHORT fog.6FF68600 //6FF685F9 . 75 05 JNZ SHORT fog.6FF68600
//6FF6C106 . 83F8 FF CMP EAX,-1 //6FF6C106 . 83F8 FF CMP EAX,-1
@ -135,22 +180,27 @@ void Install_ChangingSavePath()
//6FF67F89 . 75 05 JNZ SHORT Fog.6FF67F90 //6FF67F89 . 75 05 JNZ SHORT Fog.6FF67F90
//6FF6E146 . 83F8 FF CMP EAX,-1 //6FF6E146 . 83F8 FF CMP EAX,-1
//6FF6E149 . 75 05 JNZ SHORT Fog.6FF50F64 //6FF6E149 . 75 05 JNZ SHORT Fog.6FF50F64
//004071A6 |. 83F8 FF CMP EAX,-1
//004071A9 |. 75 05 JNZ SHORT Game.004071B0
// Pour créer le bon chemin de sauvegarde // Create the right save path
mem_seek R7(Fog, 000, 000, 000, 18616, 1C126, 1F0A6, 17FA6, 1E166); if (version_Fog < V114a)
{
mem_seek R8(Fog, 000, 000, 000, 18616, 1C126, 1F0A6, 17FA6, 1E166, 71CA);
MEMJ_REF4( D2Storm503, forCreateSavePath); MEMJ_REF4( D2Storm503, forCreateSavePath);
//6FF68615 . E8 A246FFFF CALL <JMP.&Storm.#503> //6FF68615 . E8 A246FFFF CALL <JMP.&Storm.#503>
//6FF6C125 . E8 C20BFFFF CALL <JMP.&Storm.#503> //6FF6C125 . E8 C20BFFFF CALL <JMP.&Storm.#503>
//6FF6F0A5 . E8 34DDFEFF CALL <JMP.&Storm.#503> //6FF6F0A5 . E8 34DDFEFF CALL <JMP.&Storm.#503>
//6FF67FA5 . E8 504EFFFF CALL <JMP.&Storm.#503> //6FF67FA5 . E8 504EFFFF CALL <JMP.&Storm.#503>
//6FF6E165 . E8 6AEBFEFF CALL <JMP.&Storm.#503> //6FF6E165 . E8 6AEBFEFF CALL <JMP.&Storm.#503>
//004071C9 |. E8 82C50000 CALL Game.00413750 ; \Game.00413750
}
// Remove registry update // Remove registry update
mem_seek R7(Fog, 000, 000, 000, 1861A, 1C12A, 1F0AA, 17FAA, 1E16A); mem_seek R8(Fog, 000, 000, 000, 1861A, 1C12A, 1F0AA, 17FAA, 1E16A, 71E9);
memt_byte( 0x56 ,0xEB); // JMP SHORT fog.6FF6862C memt_byte( version_Fog == V114d ? 0x53 : 0x56 ,0xEB); // JMP SHORT fog.6FF6862C
memt_byte( 0x6A ,0x10); // memt_byte( 0x6A ,0x10); //
memt_byte( 0x00 ,0x90); // NOP memt_byte( version_Fog == V114d ? 0x01 : 0x00 ,0x90); // NOP
//6FF6861A . 56 PUSH ESI //6FF6861A . 56 PUSH ESI
//6FF6861B . 6A 00 PUSH 0 //6FF6861B . 6A 00 PUSH 0
//6FF6861D . 68 7C7BF76F PUSH fog.6FF77B7C ; ASCII "Save Path" //6FF6861D . 68 7C7BF76F PUSH fog.6FF77B7C ; ASCII "Save Path"
@ -170,10 +220,10 @@ void Install_ChangingSavePath()
//6FF67FAB . 6A 00 PUSH 0 //6FF67FAB . 6A 00 PUSH 0
//6FF6E16A . 56 PUSH ESI //6FF6E16A . 56 PUSH ESI
//6FF6E16B . 6A 00 PUSH 0 //6FF6E16B . 6A 00 PUSH 0
//004071E9 |> 53 PUSH EBX ; /Arg4
//004071EA |. 6A 01 PUSH 1 ; |Arg3 = 00000001
} else { } else {
// Call funtion to manage subfolder
// Appel de notre fct d'ajout d'un sous-répertoire
mem_seek( (DWORD)D2FogGetSavePath + 0x28);//6FF61928-6FF50000 mem_seek( (DWORD)D2FogGetSavePath + 0x28);//6FF61928-6FF50000
memt_byte( 0x56 ,0x90); // NOP memt_byte( 0x56 ,0x90); // NOP
memt_byte( 0xFF ,0xE8); // CALL changeSavePath memt_byte( 0xFF ,0xE8); // CALL changeSavePath
@ -182,7 +232,7 @@ void Install_ChangingSavePath()
//6FF61929 FFD5 CALL EBP //6FF61929 FFD5 CALL EBP
//6FF6192B 83F8 FF CMP EAX,-1 //6FF6192B 83F8 FF CMP EAX,-1
// Pour créer le bon chemin de sauvegarde // Create the right save path
mem_seek( (DWORD)D2FogGetSavePath + 0xBD);//6FF619BC mem_seek( (DWORD)D2FogGetSavePath + 0xBD);//6FF619BC
MEMJ_REF4( D2Storm503, forCreateSavePath); MEMJ_REF4( D2Storm503, forCreateSavePath);
//6FF619BC . E8 5D2A0000 CALL <JMP.&Storm.#503> //6FF619BC . E8 5D2A0000 CALL <JMP.&Storm.#503>

322
PlugY/SavePlayerData.cpp
View File

@ -6,11 +6,153 @@
=================================================================*/ =================================================================*/
#include <time.h>
#include <stdio.h>
#include "infinityStash.h" #include "infinityStash.h"
#include "extendedSaveFile.h" #include "extendedSaveFile.h"
#include "sharedSaveFile.h" #include "sharedSaveFile.h"
#include "common.h" #include "common.h"
bool active_AutoBackup = false;
int maxBackupPerCharacter = 20;
/*backup
Save SP :
00530441 |. E8 CAC5FFFF CALL Game.0052CA10
0052CA5A |. E8 A1590000 |CALL Game.00532400 ; \Game.00532400
005324EB |. E8 50FDFFFF CALL Game.00532240 ; \Game.00532240
00532275 |. E8 B6C95256 CALL PlugY.caller_SaveSPPlayerCustomData
00530503 |. E8 98980000 |CALL Game.00539DA0
00539E03 . E8 F82AFFFF CALL Game.0052C900
0052C93B |. E8 C05A0000 CALL Game.00532400 ; \Game.00532400
005324EB |. E8 50FDFFFF CALL Game.00532240 ; \Game.00532240
00532275 |. E8 B6C95256 CALL PlugY.caller_SaveSPPlayerCustomData
Save MP :
00530441 |. E8 CAC5FFFF CALL Game.0052CA10
0052CA5A |. E8 A1590000 |CALL Game.00532400 ; \Game.00532400
005324FD |. E8 3EFEFFFF CALL Game.00532340 ; \Game.00532340
00532399 |. E8 62D15256 CALL PlugY.caller_SendSaveFilesToSave_11>
00530503 |. E8 98980000 |CALL Game.00539DA0
00539E03 . E8 F82AFFFF CALL Game.0052C900
0052C93B |. E8 C05A0000 CALL Game.00532400 ; \Game.00532400
005324FD |. E8 3EFEFFFF CALL Game.00532340 ; \Game.00532340
*/
void backupSaveFiles(char* name, int isHardCoreGame)
{
if (!active_AutoBackup)
return;
char savePath[MAX_PATH];
char backupPath[MAX_PATH];
char szSaveName[MAX_PATH];
char szBackupName[MAX_PATH];
D2FogGetSavePath(savePath, MAX_PATH);
// backupfiles
time_t t = time(NULL);
struct tm* tm = localtime(&t);
sprintf(backupPath, "%sbackup", savePath);
CreateDirectory(backupPath, NULL);
sprintf(backupPath, "%sbackup\\%s_%04d%02d%02d_%02d%02d%02d\\", savePath, name, tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
CreateDirectory(backupPath, NULL);
log_msg("backup directory:%s isHardcore:%d\n", backupPath, isHardCoreGame);
sprintf(szSaveName, "%s%s.d2s", savePath, name);
sprintf(szBackupName, "%s%s.d2s", backupPath, name);
CopyFile(szSaveName, szBackupName, true);
sprintf(szSaveName, "%s%s.d2x", savePath, name);
sprintf(szBackupName, "%s%s.d2x", backupPath, name);
CopyFile(szSaveName, szBackupName, true);
sprintf(szSaveName, "%s%s.ma0", savePath, name);
sprintf(szBackupName, "%s%s.ma0", backupPath, name);
CopyFile(szSaveName, szBackupName, true);
sprintf(szSaveName, "%s%s.ma1", savePath, name);
sprintf(szBackupName, "%s%s.ma1", backupPath, name);
CopyFile(szSaveName, szBackupName, true);
sprintf(szSaveName, "%s%s.ma2", savePath, name);
sprintf(szBackupName, "%s%s.ma2", backupPath, name);
CopyFile(szSaveName, szBackupName, true);
sprintf(szSaveName, "%s%s.ma3", savePath, name);
sprintf(szBackupName, "%s%s.ma3", backupPath, name);
CopyFile(szSaveName, szBackupName, true);
sprintf(szSaveName, "%s%s.map", savePath, name);
sprintf(szBackupName, "%s%s.map", backupPath, name);
CopyFile(szSaveName, szBackupName, true);
if (separateHardSoftStash && isHardCoreGame != 0)
{
sprintf(szSaveName, "%s%s%s.sss", savePath, "_LOD_HC_", sharedStashFilename);
sprintf(szBackupName, "%s%s%s.sss", backupPath, "_LOD_HC_", sharedStashFilename);
CopyFile(szSaveName, szBackupName, true);
}
if (!separateHardSoftStash || isHardCoreGame != 1)
{
sprintf(szSaveName, "%s%s%s.sss", savePath, separateHardSoftStash && isHardCoreGame != 0? "_LOD_HC_" : "_LOD_", sharedStashFilename);
sprintf(szBackupName, "%s%s%s.sss", backupPath, separateHardSoftStash && isHardCoreGame != 0? "_LOD_HC_" : "_LOD_", sharedStashFilename);
CopyFile(szSaveName, szBackupName, true);
}
// delete older backup
if (maxBackupPerCharacter > 0)
{
sprintf(szBackupName, "%sbackup\\%s_*", savePath, name);
WIN32_FIND_DATA FindFileData;
HANDLE hFind = FindFirstFile(szBackupName, &FindFileData);
if (hFind)
{
// Count nb backup folders
int nbFolders = (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY;
while(FindNextFile(hFind, &FindFileData))
nbFolders += (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY;
// delete nbFolders - maxfolder
log_msg("Backup nbFolders: %d\n", nbFolders);
nbFolders -= maxBackupPerCharacter;
if (nbFolders > 0)
{
hFind = FindFirstFile(szBackupName, &FindFileData);
do
{
if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
{
sprintf(backupPath, "%sbackup\\%s\\", savePath, FindFileData.cFileName);
log_msg("Delete backup : %s\n", backupPath);
sprintf(szBackupName, "%s%s.d2s", backupPath, name);
DeleteFile(szBackupName);
sprintf(szBackupName, "%s%s.d2x", backupPath, name);
DeleteFile(szBackupName);
sprintf(szBackupName, "%s%s.ma0", backupPath, name);
DeleteFile(szBackupName);
sprintf(szBackupName, "%s%s.ma1", backupPath, name);
DeleteFile(szBackupName);
sprintf(szBackupName, "%s%s.ma2", backupPath, name);
DeleteFile(szBackupName);
sprintf(szBackupName, "%s%s.ma3", backupPath, name);
DeleteFile(szBackupName);
sprintf(szBackupName, "%s%s.map", backupPath, name);
DeleteFile(szBackupName);
sprintf(szBackupName, "%s_LOD_%s.sss", backupPath, sharedStashFilename);
DeleteFile(szBackupName);
sprintf(szBackupName, "%s_LOD_HC_%s.sss", backupPath, sharedStashFilename);
DeleteFile(szBackupName);
RemoveDirectory(backupPath);
nbFolders--;
}
FindNextFile(hFind, &FindFileData);
}
while (nbFolders > 0);
}
}
}
}
void STDCALL SaveSPPlayerCustomData(Unit* ptChar) void STDCALL SaveSPPlayerCustomData(Unit* ptChar)
{ {
@ -18,6 +160,11 @@ void STDCALL SaveSPPlayerCustomData(Unit* ptChar)
log_msg("\n--- Start SaveSPPlayerCustomData ---\n"); log_msg("\n--- Start SaveSPPlayerCustomData ---\n");
NetClient* ptClient = D2GetClient(ptChar,__FILE__,__LINE__);
backupSaveFiles(PCPlayerData->name, ptClient->isHardCoreGame);
if (active_PlayerCustomData)
{
if (PCPY->selfStashIsOpened) if (PCPY->selfStashIsOpened)
{ {
DWORD curSizeExt = 0; DWORD curSizeExt = 0;
@ -37,21 +184,45 @@ void STDCALL SaveSPPlayerCustomData(Unit* ptChar)
d2_assert(!dataShr, "Error : Memory allocation Shared SaveFile", __FILE__, __LINE__); d2_assert(!dataShr, "Error : Memory allocation Shared SaveFile", __FILE__, __LINE__);
saveSharedSaveFile(ptChar, &dataShr, &maxSizeShr, &curSizeShr); saveSharedSaveFile(ptChar, &dataShr, &maxSizeShr, &curSizeShr);
NetClient* ptClient = D2GetClient(ptChar,__FILE__,__LINE__);
writeSharedSaveFile(PCPlayerData->name, dataShr, curSizeShr, ptClient->isHardCoreGame ); writeSharedSaveFile(PCPlayerData->name, dataShr, curSizeShr, ptClient->isHardCoreGame );
D2FreeMem(PCGame->memoryPool, dataShr,__FILE__,__LINE__,0); D2FreeMem(PCGame->memoryPool, dataShr,__FILE__,__LINE__,0);
} }
}
log_msg("End saving.\n\n"); log_msg("End saving.\n\n");
} }
FCT_ASM ( caller_SaveSPPlayerCustomData_114 )
MOV EAX,DWORD PTR SS:[ESP+8]
TEST EAX,EAX
JE next
PUSH ECX
PUSH EDX
PUSH EDX
CALL SaveSPPlayerCustomData
POP EDX
POP ECX
next:
JMP D2SaveSPChar
}}
FCT_ASM ( caller_SaveSPPlayerCustomData_111 ) FCT_ASM ( caller_SaveSPPlayerCustomData_111 )
MOV EAX,DWORD PTR SS:[ESP+0x14]
TEST EAX,EAX
JE next
PUSH DWORD PTR SS:[ESP+0x8]
CALL SaveSPPlayerCustomData
next:
JMP D2SaveSPChar
}}
/*FCT_ASM ( caller_SaveSPPlayerCustomData_111 )
CALL D2FogGetSavePath CALL D2FogGetSavePath
PUSH DWORD PTR SS:[ESP+0x2608] PUSH DWORD PTR SS:[ESP+0x2608]
CALL SaveSPPlayerCustomData CALL SaveSPPlayerCustomData
RETN RETN
}} }}*/
FCT_ASM ( caller_SaveSPPlayerCustomData ) FCT_ASM ( caller_SaveSPPlayerCustomData )
CALL D2FogGetSavePath CALL D2FogGetSavePath
@ -186,7 +357,7 @@ void STDCALL SendSaveFilesToSave( Unit* ptChar )
dataToSend->sizeShared = curSizeShr; dataToSend->sizeShared = curSizeShr;
dataToSend->curShared = 0; dataToSend->curShared = 0;
dataToSend->dataShared = dataShr; dataToSend->dataShared = dataShr;
log_msg("clientID=%d\t init=%d\t sizeExtended=%X\t curExtended=%X\t dataExtended=%X\t sizeShared=%X\t curShared=%X\t dataShared=%08X\n", log_msg("SendSaveFilesToSave : clientID=%d\t init=%d\t sizeExtended=%d\t curExtended=%d\t dataExtended=%d\t sizeShared=%d\t curShared=%d\t dataShared=%08X\n",
dataToSend->clientID, dataToSend->init, dataToSend->sizeExtended, dataToSend->curExtended, dataToSend->dataExtended, dataToSend->sizeShared, dataToSend->curShared, dataToSend->dataShared); dataToSend->clientID, dataToSend->init, dataToSend->sizeExtended, dataToSend->curExtended, dataToSend->dataExtended, dataToSend->sizeShared, dataToSend->curShared, dataToSend->dataShared);
/* NetClient* ptClient = D2GetClient(ptChar,__FILE__,__LINE__); /* NetClient* ptClient = D2GetClient(ptChar,__FILE__,__LINE__);
@ -201,19 +372,19 @@ void STDCALL SendSaveFilesToSave( Unit* ptChar )
D2FreeMem(PCGame->memoryPool, dataShr,__FILE__,__LINE__,0); D2FreeMem(PCGame->memoryPool, dataShr,__FILE__,__LINE__,0);
} }
*/ */
log_msg("End SendSaveFilesToSave.\n\n"); log_msg("SendSaveFilesToSave : End\n\n");
} }
DWORD STDCALL ManageNextPacketToSend(NetClient* ptClient) DWORD STDCALL ManageNextPacketToSend(NetClient* ptClient)
{ {
log_msg("ManageNextPacketToSend: "); log_msg("ManageNextPacketToSend\n");
s_dataToSend* dataToSend = ptDataToSend; s_dataToSend* dataToSend = ptDataToSend;
while (dataToSend && (dataToSend->clientID != ptClient->clientID)) while (dataToSend && (dataToSend->clientID != ptClient->clientID))
dataToSend = dataToSend->next; dataToSend = dataToSend->next;
if (!dataToSend) return 1; if (!dataToSend) return 1;
log_msg("clientID=%d\t init=%d\t sizeExtended=%X\t curExtended=%X\t dataExtended=%X\t sizeShared=%X\t curShared=%X\t dataShared=%08X\n", log_msg("ManageNextPacketToSend : clientID=%d\t init=%d\t sizeExtended=%d\t curExtended=%d\t dataExtended=%08X\t sizeShared=%d\t curShared=%d\t dataShared=%08X\n",
dataToSend->clientID, dataToSend->init, dataToSend->sizeExtended, dataToSend->curExtended, dataToSend->dataExtended, dataToSend->sizeShared, dataToSend->curShared, dataToSend->dataShared); dataToSend->clientID, dataToSend->init, dataToSend->sizeExtended, dataToSend->curExtended, dataToSend->dataExtended, dataToSend->sizeShared, dataToSend->curShared, dataToSend->dataShared);
if (dataToSend->sizeExtended && dataToSend->dataExtended && (dataToSend->curExtended < dataToSend->sizeExtended)) if (dataToSend->sizeExtended && dataToSend->dataExtended && (dataToSend->curExtended < dataToSend->sizeExtended))
@ -227,7 +398,7 @@ DWORD STDCALL ManageNextPacketToSend(NetClient* ptClient)
msg->isCustom = true; msg->isCustom = true;
msg->packSize = remainingData > 0xFE ? 0xFF : (BYTE)remainingData + 1; msg->packSize = remainingData > 0xFE ? 0xFF : (BYTE)remainingData + 1;
CopyMemory(msg->data, &dataToSend->dataExtended[dataToSend->curExtended], msg->packSize); CopyMemory(msg->data, &dataToSend->dataExtended[dataToSend->curExtended], msg->packSize);
log_msg("Saving Send Packet: type=%X\t init=%d\t finalSize=%X\t packSize=%02X\t data=%08X\n", msg->type, msg->init, msg->finalSize, msg->packSize, msg->data); log_msg("ManageNextPacketToSend : type=%d\t init=%d\t finalSize=%d\t packSize=%d\t data=%08X\n", msg->type, msg->init, msg->finalSize, msg->packSize, msg->data);
D2SendToClient(0, dataToSend->clientID, msg, msg->packSize+7); D2SendToClient(0, dataToSend->clientID, msg, msg->packSize+7);
dataToSend->init = false; dataToSend->init = false;
dataToSend->curExtended += msg->packSize - 1; dataToSend->curExtended += msg->packSize - 1;
@ -239,7 +410,7 @@ DWORD STDCALL ManageNextPacketToSend(NetClient* ptClient)
D2FreeMem(PClientGame->memoryPool, dataToSend->dataExtended,__FILE__,__LINE__,0); D2FreeMem(PClientGame->memoryPool, dataToSend->dataExtended,__FILE__,__LINE__,0);
dataToSend->dataExtended = NULL; dataToSend->dataExtended = NULL;
} }
log_msg("End Send Packet\n"); log_msg("ManageNextPacketToSend : End\n");
return 0;//ManageNextPacketToSend(ptClient);//return 0; return 0;//ManageNextPacketToSend(ptClient);//return 0;
} }
@ -254,7 +425,7 @@ DWORD STDCALL ManageNextPacketToSend(NetClient* ptClient)
msg->isCustom = true; msg->isCustom = true;
msg->packSize = remainingData > 0xFE ? 0xFF : (BYTE)remainingData + 1; msg->packSize = remainingData > 0xFE ? 0xFF : (BYTE)remainingData + 1;
CopyMemory(msg->data, &dataToSend->dataShared[dataToSend->curShared], msg->packSize); CopyMemory(msg->data, &dataToSend->dataShared[dataToSend->curShared], msg->packSize);
log_msg("Saving Send Packet: type=%X\t init=%d\t finalSize=%X\t packSize=%02X\t data=%08X\n", msg->type, msg->init, msg->finalSize, msg->packSize, msg->data); log_msg("ManageNextPacketToSend : type=%d\t init=%d\t finalSize=%d\t packSize=%d\t data=%08X\n", msg->type, msg->init, msg->finalSize, msg->packSize, msg->data);
D2SendToClient(0, dataToSend->clientID, msg, msg->packSize+7); D2SendToClient(0, dataToSend->clientID, msg, msg->packSize+7);
dataToSend->init = false; dataToSend->init = false;
dataToSend->curShared += msg->packSize - 1; dataToSend->curShared += msg->packSize - 1;
@ -266,11 +437,11 @@ DWORD STDCALL ManageNextPacketToSend(NetClient* ptClient)
D2FreeMem(PClientGame->memoryPool, dataToSend->dataShared,__FILE__,__LINE__,0); D2FreeMem(PClientGame->memoryPool, dataToSend->dataShared,__FILE__,__LINE__,0);
dataToSend->dataShared = NULL; dataToSend->dataShared = NULL;
} }
log_msg("End Send Packet\n"); log_msg("ManageNextPacketToSend : End\n");
return 0;//ManageNextPacketToSend(ptClient);//return 0; return 0;//ManageNextPacketToSend(ptClient);//return 0;
} }
log_msg("End Send Packet\n"); log_msg("ManageNextPacketToSend : End\n");
return 1; return 1;
} }
@ -279,7 +450,7 @@ DWORD STDCALL ReceiveSaveFilesToSave(t_rcvMsg* msg)
{ {
if( (msg->packID != customPackID) || !msg->isCustom) return 0; if( (msg->packID != customPackID) || !msg->isCustom) return 0;
log_msg("Saving Receive Packet: type=%X\t init=%d\t finalSize=%X\t packSize=%02X\t data=%08X\n", msg->type, msg->init, msg->finalSize, msg->packSize, msg->data); log_msg("ReceiveSaveFilesToSave : Receive Packet - type=%d\t init=%d\t finalSize=%d\t packSize=%d\t data=%08X\n", msg->type, msg->init, msg->finalSize, msg->packSize, msg->data);
bool isShared; bool isShared;
@ -294,10 +465,10 @@ DWORD STDCALL ReceiveSaveFilesToSave(t_rcvMsg* msg)
{ {
D2FogMemDeAlloc(receivedSaveFiles.dataExtended,__FILE__,__LINE__,0); D2FogMemDeAlloc(receivedSaveFiles.dataExtended,__FILE__,__LINE__,0);
D2FogMemDeAlloc(receivedSaveFiles.dataShared,__FILE__,__LINE__,0); D2FogMemDeAlloc(receivedSaveFiles.dataShared,__FILE__,__LINE__,0);
ZeroMemory(&receivedSaveFiles, sizeof(receivedSaveFiles));//TODO ZeroMemory(&receivedSaveFiles, sizeof(receivedSaveFiles));
} }
log_msg("receivedSaveFiles: sizeExtended=%d\t curExtended=%d\t dataExtended=%08X\t sizeShared=%d\t curShared=%d\t dataShared=%08X\n", receivedSaveFiles.sizeExtended, receivedSaveFiles.curExtended, receivedSaveFiles.dataExtended, receivedSaveFiles.sizeShared, receivedSaveFiles.curShared, receivedSaveFiles.dataShared); log_msg("ReceiveSaveFilesToSave : sizeExtended=%d\t curExtended=%d\t dataExtended=%08X\t sizeShared=%d\t curShared=%d\t dataShared=%08X\n", receivedSaveFiles.sizeExtended, receivedSaveFiles.curExtended, receivedSaveFiles.dataExtended, receivedSaveFiles.sizeShared, receivedSaveFiles.curShared, receivedSaveFiles.dataShared);
DWORD size = msg->packSize - 1; DWORD size = msg->packSize - 1;
if (isShared) if (isShared)
@ -324,38 +495,44 @@ DWORD STDCALL ReceiveSaveFilesToSave(t_rcvMsg* msg)
CopyMemory(&receivedSaveFiles.dataExtended[receivedSaveFiles.curExtended], msg->data, size); CopyMemory(&receivedSaveFiles.dataExtended[receivedSaveFiles.curExtended], msg->data, size);
receivedSaveFiles.curExtended += size; receivedSaveFiles.curExtended += size;
} }
log_msg("End Save Receive Packet\n"); log_msg("ReceiveSaveFilesToSave : End\n");
return 1; return 1;
} }
void STDCALL SaveMPPlayerCustomData(BYTE* dataD2Savefile ) void STDCALL SaveMPPlayerCustomData(BYTE* dataD2Savefile )
{ {
log_msg("Start SaveMPPlayerCustomData.\n"); log_msg("SaveMPPlayerCustomData - Start.\n");
Unit* ptChar = D2GetClientPlayer(); Unit* ptChar = D2GetClientPlayer();
if( receivedSaveFiles.sizeExtended && (receivedSaveFiles.sizeExtended == receivedSaveFiles.curExtended) && receivedSaveFiles.sizeShared && (receivedSaveFiles.sizeShared == receivedSaveFiles.curShared) ) backupSaveFiles(PCPlayerData->name, (dataD2Savefile[0x24] & 4) == 4);
if (active_PlayerCustomData)
{ {
log_msg("Saving can start\n"); if( receivedSaveFiles.sizeExtended && (receivedSaveFiles.sizeExtended == receivedSaveFiles.curExtended) && (!active_sharedStash || receivedSaveFiles.sizeShared && (receivedSaveFiles.sizeShared == receivedSaveFiles.curShared)) )
{
log_msg("SaveMPPlayerCustomData - Saving can start\n");
if (ptChar) if (ptChar)
{ {
writeExtendedSaveFile(PCPlayerData->name, receivedSaveFiles.dataExtended, receivedSaveFiles.sizeExtended); writeExtendedSaveFile(PCPlayerData->name, receivedSaveFiles.dataExtended, receivedSaveFiles.sizeExtended);
D2FogMemDeAlloc(receivedSaveFiles.dataExtended,__FILE__,__LINE__,0); D2FogMemDeAlloc(receivedSaveFiles.dataExtended,__FILE__,__LINE__,0);
if (active_sharedStash) if (active_sharedStash)
{
writeSharedSaveFile(PCPlayerData->name, receivedSaveFiles.dataShared, receivedSaveFiles.sizeShared, (dataD2Savefile[0x24] & 4) == 4);//6FBAB9A4-6FAA0000 writeSharedSaveFile(PCPlayerData->name, receivedSaveFiles.dataShared, receivedSaveFiles.sizeShared, (dataD2Savefile[0x24] & 4) == 4);//6FBAB9A4-6FAA0000
D2FogMemDeAlloc(receivedSaveFiles.dataShared,__FILE__,__LINE__,0); D2FogMemDeAlloc(receivedSaveFiles.dataShared,__FILE__,__LINE__,0);
}
ZeroMemory(&receivedSaveFiles,sizeof(receivedSaveFiles)); ZeroMemory(&receivedSaveFiles,sizeof(receivedSaveFiles));
} }
log_msg("Receive Savefiles completed\n\n"); log_msg("SaveMPPlayerCustomData - Receive Savefiles completed\n\n");
} else { } else {
if (ptChar) if (ptChar)
{ {
log_box("Connection error : back up current save file then save with client data."); log_box("Connection error : save with client data.");
backupSharedSaveFile();
backupExtendedSaveFile(PCPlayerData->name);
SaveSPPlayerCustomData(ptChar); SaveSPPlayerCustomData(ptChar);
} }
} }
log_msg("--- End SaveMPPlayerCustomData. ---\n\n"); }
log_msg("--- SaveMPPlayerCustomData End ---\n\n");
} }
@ -426,7 +603,12 @@ end_caller_ManageNextPacketToSend_9d:
RETN RETN
}} }}
FCT_ASM( caller_SendSaveFilesToSave_114 )
PUSH DWORD PTR SS:[ESP+0x4]
CALL SendSaveFilesToSave
MOV EDI,DWORD PTR SS:[EBP-0x2008]
RETN
}}
FCT_ASM( caller_SendSaveFilesToSave_111 ) FCT_ASM( caller_SendSaveFilesToSave_111 )
PUSH DWORD PTR SS:[ESP+0x2014] PUSH DWORD PTR SS:[ESP+0x2014]
@ -452,6 +634,21 @@ FCT_ASM( caller_SendSaveFilesToSave_9 )
RETN RETN
}} }}
FCT_ASM ( caller_ReceivedSaveFilesToSave_114 )
CMP EDX,-1
JE continue_rcvFct
PUSH ECX
PUSH EDX
PUSH ECX
CALL ReceiveSaveFilesToSave
POP EDX
POP ECX
TEST EAX,EAX
JE continue_rcvFct
RETN
continue_rcvFct:
JMP D2ReceivePacket
}}
FCT_ASM ( caller_ReceivedSaveFilesToSave_111 ) FCT_ASM ( caller_ReceivedSaveFilesToSave_111 )
LEA EAX,DWORD PTR SS:[ESP+0x10] LEA EAX,DWORD PTR SS:[ESP+0x10]
@ -498,8 +695,6 @@ FCT_ASM ( caller_SaveMPPlayerCustomData_111 )
RETN RETN
}} }}
FCT_ASM ( caller_SaveMPPlayerCustomData ) FCT_ASM ( caller_SaveMPPlayerCustomData )
PUSH ECX PUSH ECX
PUSH ECX PUSH ECX
@ -511,29 +706,45 @@ FCT_ASM ( caller_SaveMPPlayerCustomData )
}} }}
void Install_SavePlayerData() void Install_SavePlayerData()
{ {
static int isInstalled = false; static int isInstalled = false;
if (isInstalled || !active_PlayerCustomData) return; if (isInstalled) return;
log_msg("Patch D2Game & D2Client for save Player's custom data. (SavePlayerData)\n"); log_msg("Patch D2Game & D2Client for save Player's custom data. (SavePlayerData)\n");
//Save single player custom data. //Save single player custom data.
mem_seek R7(D2Game, 4DF04, 4E304, 5A624, B9365, 25475, 44165, 53F35, 39835); if (version_D2Game >= V111)
MEMJ_REF4( D2FogGetSavePath, version_D2Game >= V111 ? caller_SaveSPPlayerCustomData_111 : version_D2Game != V109b ? caller_SaveSPPlayerCustomData : caller_SaveSPPlayerCustomData_9); {
mem_seek R8(D2Game, 0000, 0000, 0000, B9801, 25911, 44601, 543D1, 39CD1, 1324EC);
MEMC_REF4( D2SaveSPChar, version_D2Game >= V114a ? caller_SaveSPPlayerCustomData_114 : version_D2Game >= V111 ? caller_SaveSPPlayerCustomData_111 : version_D2Game != V109b ? caller_SaveSPPlayerCustomData : caller_SaveSPPlayerCustomData_9);
//6FCD9800 |. E8 3BFBFFFF CALL D2Game.6FCD9340
//6FC45910 |. E8 3BFBFFFF CALL D2Game.6FC45450
//6FC64600 |. E8 3BFBFFFF CALL D2Game.6FC64140
//6FC743D0 |. E8 3BFBFFFF CALL D2Game.6FC73F10
//6FC59CD0 |. E8 3BFBFFFF CALL D2Game.6FC59810
//005324EB |. E8 50FDFFFF CALL Game.00532240 ; \Game.00532240
}
else
{
mem_seek R8(D2Game, 4DF04, 4E304, 5A624, B9365, 25475, 44165, 53F35, 39835, 132276);
MEMJ_REF4( D2FogGetSavePath, /*version_D2Game >= V114a ? caller_SaveSPPlayerCustomData : version_D2Game >= V111 ? caller_SaveSPPlayerCustomData_111 :*/ version_D2Game != V109b ? caller_SaveSPPlayerCustomData : caller_SaveSPPlayerCustomData_9);
//6FC8A623 E8 3E210900 CALL <JMP.&Fog.#10115> //6FC8A623 E8 3E210900 CALL <JMP.&Fog.#10115>
//02039364 |. E8 3B0FF5FF CALL <JMP.&Fog.#10115> //02039364 |. E8 3B0FF5FF CALL <JMP.&Fog.#10115>
//01F95474 |. E8 C34EFEFF CALL <JMP.&Fog.#10115> //01F95474 |. E8 C34EFEFF CALL <JMP.&Fog.#10115>
//6FC64164 |. E8 EB61FCFF CALL <JMP.&Fog.#10115> //6FC64164 |. E8 EB61FCFF CALL <JMP.&Fog.#10115>
//6FC73F34 |. E8 DD63FBFF CALL <JMP.&Fog.#10115> //6FC73F34 |. E8 DD63FBFF CALL <JMP.&Fog.#10115>
//6FC59834 |. E8 FB0AFDFF CALL <JMP.&Fog.#10115> //6FC59834 |. E8 FB0AFDFF CALL <JMP.&Fog.#10115>
//00532275 |. E8 D64DEDFF CALL Game.00407050
}
if (active_PlayerCustomData)
{
//Send SaveFiles //Send SaveFiles
mem_seek R7(D2Game, 4DFFA, 4E3FA, 5A720, B92DB, 253EB, 440DB, 53EAB, 397AB); mem_seek R8(D2Game, 4DFFA, 4E3FA, 5A720, B92DB, 253EB, 440DB, 53EAB, 397AB, 132398);
memt_byte( 0x8B ,0x90); // NOP memt_byte( 0x8B ,0x90); // NOP
memt_byte( version_D2Game >= V111 ? 0x44 : version_D2Game != V109b ? 0x7C : 0x74 ,0xE8); // CALL memt_byte( version_D2Game >= V114d ? 0xBD : version_D2Game >= V111 ? 0x44 : version_D2Game != V109b ? 0x7C : 0x74, 0xE8); // CALL
MEMT_REF4( version_D2Game >= V111 ? 0xC0850424 : version_D2Game != V109b ? 0xFF851024 : 0xF6851024, version_D2Game >= V111 ? caller_SendSaveFilesToSave_111 : version_D2Game != V109b ? caller_SendSaveFilesToSave : caller_SendSaveFilesToSave_9); MEMT_REF4( version_D2Game >= V114d ? 0xFFFFDFF8 : version_D2Game >= V111 ? 0xC0850424 : version_D2Game != V109b ? 0xFF851024 : 0xF6851024, version_D2Game >= V114d ? caller_SendSaveFilesToSave_114 : version_D2Game >= V111 ? caller_SendSaveFilesToSave_111 : version_D2Game != V109b ? caller_SendSaveFilesToSave : caller_SendSaveFilesToSave_9);
//6FC8A720 |. 8B7C24 10 MOV EDI,DWORD PTR SS:[ESP+10] //6FC8A720 |. 8B7C24 10 MOV EDI,DWORD PTR SS:[ESP+10]
//6FC8A724 |. 85FF TEST EDI,EDI //6FC8A724 |. 85FF TEST EDI,EDI
//020392DB |. 8B4424 04 MOV EAX,DWORD PTR SS:[ESP+4] //020392DB |. 8B4424 04 MOV EAX,DWORD PTR SS:[ESP+4]
@ -546,8 +757,9 @@ void Install_SavePlayerData()
//6FC73EAF |. 85C0 TEST EAX,EAX //6FC73EAF |. 85C0 TEST EAX,EAX
//6FC597AB |. 8B4424 04 MOV EAX,DWORD PTR SS:[ESP+4] //6FC597AB |. 8B4424 04 MOV EAX,DWORD PTR SS:[ESP+4]
//6FC597AF |. 85C0 TEST EAX,EAX //6FC597AF |. 85C0 TEST EAX,EAX
//00532398 |. 8BBD F8DFFFFF MOV EDI,DWORD PTR SS:[EBP-2008]
mem_seek R7(D2Game, 7993, 7A13, 7BBB, E2943, E6D83, A89D3, 2D173, BEDD3); mem_seek R8(D2Game, 7993, 7A13, 7BBB, E2943, E6D83, A89D3, 2D173, BEDD3, 12E13E);
memt_byte( 0x8B ,0x90); // NOP memt_byte( 0x8B ,0x90); // NOP
memt_byte( version_D2Game >= V110 ? 0x8E : 0x86 ,0xE8); // CALL memt_byte( version_D2Game >= V110 ? 0x8E : 0x86 ,0xE8); // CALL
MEMT_REF4( version_D2Game >= V110 ? 0x0000017C : version_D2Game == V109d ? 0x0000174 : 0x00000150, version_D2Game >= V110 ? caller_ManageNextPacketToSend : version_D2Game == V109d ? caller_ManageNextPacketToSend_9d : caller_ManageNextPacketToSend_9); MEMT_REF4( version_D2Game >= V110 ? 0x0000017C : version_D2Game == V109d ? 0x0000174 : 0x00000150, version_D2Game >= V110 ? caller_ManageNextPacketToSend : version_D2Game == V109d ? caller_ManageNextPacketToSend_9d : caller_ManageNextPacketToSend_9);
@ -557,18 +769,24 @@ void Install_SavePlayerData()
//6FCC89D3 |. 8B8E 7C010000 MOV ECX,DWORD PTR DS:[ESI+17C] //6FCC89D3 |. 8B8E 7C010000 MOV ECX,DWORD PTR DS:[ESI+17C]
//6FC4D173 |. 8B8E 7C010000 MOV ECX,DWORD PTR DS:[ESI+17C] //6FC4D173 |. 8B8E 7C010000 MOV ECX,DWORD PTR DS:[ESI+17C]
//6FCDEDD3 |. 8B8E 7C010000 MOV ECX,DWORD PTR DS:[ESI+17C] //6FCDEDD3 |. 8B8E 7C010000 MOV ECX,DWORD PTR DS:[ESI+17C]
//0052E13E |> 8B8E 7C010000 MOV ECX,DWORD PTR DS:[ESI+17C]
// mem_seek R7(D2Game, 7B82, 7C05, 7DCF, 0000, 0000, 0000, 0000);//117FC, 117EC, 11DBC // mem_seek R7(D2Game, 7B82, 7C05, 7DCF, 0000, 0000, 0000, 0000);//117FC, 117EC, 11DBC
// memt_byte( 0x8B ,0xE8); // CALL // memt_byte( 0x8B ,0xE8); // CALL
// MEMT_REF4( (version_D2Game == V110) ? 0x50CD8BD3 : 0x50CF8BD3, (version_D2Game == V110) ? caller_SendSaveFilesToSave : caller_SendSaveFilesToSave_9); // MEMT_REF4( (version_D2Game == V110) ? 0x50CD8BD3 : 0x50CF8BD3, (version_D2Game == V110) ? caller_SendSaveFilesToSave : caller_SendSaveFilesToSave_9);
//6FC37DCF |. 8BD3 |MOV EDX,EBX //6FC37DCF |. 8BD3 |MOV EDX,EBX
//6FC37DD1 |. 8BCD |MOV ECX,EBP //6FC37DD1 |. 8BCD |MOV ECX,EBP
//6FC37DD3 |. 50 |PUSH EAX //6FC37DD3 |. 50 |PUSH EAX
if ( version_D2Game >= V111 )
{
//Received SaveFiles //Received SaveFiles
mem_seek R7(D2Client, 116F0, 116E0, 11CB0, 89246, 32076, 7BCD6, 43946, 448E6); mem_seek R8(D2Client, 116F0, 116E0, 11CB0, 89246, 32076, 7BCD6, 43946, 448E6, 4C70D);
if ( version_D2Game >= V114a )
{
MEMC_REF4( D2ReceivePacket, caller_ReceivedSaveFilesToSave_114);
//0044C70C |. E8 3F010100 |CALL Game.0045C850
}
else if ( version_D2Game >= V111 )
{
memt_byte( 0x0F ,0xE8); memt_byte( 0x0F ,0xE8);
MEMT_REF4( 0x0C2444B6, caller_ReceivedSaveFilesToSave_111); MEMT_REF4( 0x0C2444B6, caller_ReceivedSaveFilesToSave_111);
//6FB39246 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C] //6FB39246 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C]
@ -576,9 +794,19 @@ void Install_SavePlayerData()
//6FB2BCD6 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C] //6FB2BCD6 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C]
//6FAF3946 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C] //6FAF3946 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C]
//6FAF48E6 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C] //6FAF48E6 |. 0FB64424 0C |MOVZX EAX,BYTE PTR SS:[ESP+C]
} else {
//Received SaveFiles
memt_byte( 0x81 ,0x90); // NOP
memt_byte( 0xEC ,0xE8); // CALL
MEMT_REF4( 0x000005F4, caller_ReceivedSaveFilesToSave);
//6FAB1CB0 |$ 81EC F4050000 SUB ESP,5F4
}
}
if ( version_D2Game >= V111 )
{
// Save multiplayer player custom data. // Save multiplayer player custom data.
mem_seek R7(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, AC572, 829C2); mem_seek R8(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, AC572, 829C2, 5C565);
memt_byte( 0x81 ,0xE8); // CALL memt_byte( 0x81 ,0xE8); // CALL
MEMT_REF4( 0x55AA55F9, caller_SaveMPPlayerCustomData_111); MEMT_REF4( 0x55AA55F9, caller_SaveMPPlayerCustomData_111);
memt_byte( 0xAA ,0x90); // CALL memt_byte( 0xAA ,0x90); // CALL
@ -587,16 +815,10 @@ void Install_SavePlayerData()
//6FB14A22 |. 81F9 55AA55AA CMP ECX,AA55AA55 //6FB14A22 |. 81F9 55AA55AA CMP ECX,AA55AA55
//6FB5C572 |. 81F9 55AA55AA CMP ECX,AA55AA55 //6FB5C572 |. 81F9 55AA55AA CMP ECX,AA55AA55
//6FB329C2 |. 81F9 55AA55AA CMP ECX,AA55AA55 //6FB329C2 |. 81F9 55AA55AA CMP ECX,AA55AA55
//0045C565 |. 81F9 55AA55AA CMP ECX,AA55AA55
} else { } else {
//Received SaveFiles
mem_seek R7(D2Client, 116F0, 116E0, 11CB0, 89246, 32076, 7BCD6, 0000, 0000);
memt_byte( 0x81 ,0x90); // NOP
memt_byte( 0xEC ,0xE8); // CALL
MEMT_REF4( 0x000005F4, caller_ReceivedSaveFilesToSave);
//6FAB1CB0 |$ 81EC F4050000 SUB ESP,5F4
// Save multiplayer player custom data. // Save multiplayer player custom data.
mem_seek R7(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, 0000, 0000); mem_seek R8(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, 0000, 0000, 0000);
memt_byte( 0x8B ,0xE8); // CALL memt_byte( 0x8B ,0xE8); // CALL
MEMT_REF4( 0x04518B01, caller_SaveMPPlayerCustomData); MEMT_REF4( 0x04518B01, caller_SaveMPPlayerCustomData);
//6FAB1DBC |. 8B01 MOV EAX,DWORD PTR DS:[ECX] //6FAB1DBC |. 8B01 MOV EAX,DWORD PTR DS:[ECX]

38
PlugY/SharedSaveFile.cpp
View File

@ -15,9 +15,7 @@
#define BUFFER_SIZE 0x4000 #define BUFFER_SIZE 0x4000
#define FILE_VERSION 0x3230 //"02" #define FILE_VERSION 0x3230 //"02"
//6FC8CE8A |. E8 A16BFAFF CALL D2Game.6FC33A30
//$+C0 > 1F 00 00 00 03 00 00 06 .....
// 28 0010 1000
BYTE* readSharedSaveFile(char* name, DWORD* size) BYTE* readSharedSaveFile(char* name, DWORD* size)
{ {
char filename[512]; char filename[512];
@ -157,40 +155,6 @@ void writeSharedSaveFile(char* name, BYTE* data, DWORD size, bool isHardcore)
log_box("Could not create the shared save file."); log_box("Could not create the shared save file.");
} }
void backupSharedSaveFile()
{
char szBackupName[MAX_PATH];
char szSaveName[MAX_PATH];
D2FogGetSavePath( szSaveName, MAX_PATH-30);
strcat(szSaveName, "_LOD_");
strcat(szSaveName, sharedStashFilename);
strcat(szSaveName,".sss");
D2FogGetSavePath( szBackupName, MAX_PATH-30);
strcat(szBackupName, "_LOD_");
strcat(szBackupName, sharedStashFilename);
strcat(szBackupName,".sss.backup");
CopyFile(szSaveName, szBackupName, true);
if (separateHardSoftStash)
{
D2FogGetSavePath( szSaveName, MAX_PATH-30);
strcat(szSaveName, "_LOD_HC_");
strcat(szSaveName, sharedStashFilename);
strcat(szSaveName,".sss");
D2FogGetSavePath( szBackupName, MAX_PATH-30);
strcat(szBackupName, "_LOD_HC_");
strcat(szBackupName, sharedStashFilename);
strcat(szBackupName,".sss.backup");
CopyFile(szSaveName, szBackupName, true);
}
}
void saveSharedSaveFile(Unit* ptChar, BYTE** data, DWORD* maxSize, DWORD* curSize) void saveSharedSaveFile(Unit* ptChar, BYTE** data, DWORD* maxSize, DWORD* curSize)
{ {
*(DWORD *)(*data + *curSize) = FILE_SHAREDSTASH; *(DWORD *)(*data + *curSize) = FILE_SHAREDSTASH;

13
PlugY/SkillPerLevelUp.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Change Skill win per level up. Change Skill win per level up.
@ -12,6 +13,13 @@
bool active_SkillPerLevelUpChange=0; bool active_SkillPerLevelUpChange=0;
DWORD skillPerLevelUp=1; DWORD skillPerLevelUp=1;
FCT_ASM ( caller_changeSkillPerLevelUp_114 )
MOV EAX,skillPerLevelUp
IMUL EAX,EDI
MOV DWORD PTR SS:[ESP+0xC], EAX
JMP V2AddPlayerStat
}}
FCT_ASM ( caller_changeSkillPerLevelUp_111 ) FCT_ASM ( caller_changeSkillPerLevelUp_111 )
MOV EAX,skillPerLevelUp MOV EAX,skillPerLevelUp
@ -35,14 +43,15 @@ void Install_SkillPerLevelUp()
log_msg("Patch D2Game for change Skill points win per level up. (SkillPerLevelUp)\n"); log_msg("Patch D2Game for change Skill points win per level up. (SkillPerLevelUp)\n");
mem_seek R7(D2Game, 42261, 42651, 4ED60, D7AE5, 79695, AA455, EB1E5, EDCA5); mem_seek R8(D2Game, 42261, 42651, 4ED60, D7AE5, 79695, AA455, EB1E5, EDCA5, 1709D1);
MEMJ_REF4( V2AddPlayerStat, version_D2Game >= V111 ? caller_changeSkillPerLevelUp_111 : caller_changeSkillPerLevelUp); MEMJ_REF4( V2AddPlayerStat, version_D2Game >= V114d ? caller_changeSkillPerLevelUp_114 : version_D2Game >= V111 ? caller_changeSkillPerLevelUp_111 : caller_changeSkillPerLevelUp);
//6FC7ED5F |. E8 56CB0900 CALL <JMP.&D2Common.#10518> //6FC7ED5F |. E8 56CB0900 CALL <JMP.&D2Common.#10518>
//02057AE4 |. E8 9F28F3FF CALL <JMP.&D2Common.#10109> //02057AE4 |. E8 9F28F3FF CALL <JMP.&D2Common.#10109>
//01FE9694 |. E8 1B0DF9FF CALL <JMP.&D2Common.#10627> //01FE9694 |. E8 1B0DF9FF CALL <JMP.&D2Common.#10627>
//6FCCA454 |. E8 5F01F6FF CALL <JMP.&D2Common.#10762> //6FCCA454 |. E8 5F01F6FF CALL <JMP.&D2Common.#10762>
//6FD0B1E4 |. E8 E9F2F1FF CALL <JMP.&D2Common.#10551> //6FD0B1E4 |. E8 E9F2F1FF CALL <JMP.&D2Common.#10551>
//6FD0DCA4 |. E8 FDC6F1FF CALL <JMP.&D2Common.#10645> //6FD0DCA4 |. E8 FDC6F1FF CALL <JMP.&D2Common.#10645>
//005709D0 |. E8 DB680B00 CALL Game.006272B0 ; \Game.006272B0
log_msg("\n"); log_msg("\n");

6
PlugY/SkillsPoints.cpp
View File

@ -10,7 +10,7 @@
#include "common.h" #include "common.h"
bool active_SkillsPoints=0; bool active_SkillsPoints=0;
bool unassignSkillsPointsOneByOne=0; bool unassignSkillsPointsOneForOne=0;
int (*getskPoint)(SkillData* ptSkill); int (*getskPoint)(SkillData* ptSkill);
int (*getCharClass)(SkillData* ptSkill); int (*getCharClass)(SkillData* ptSkill);
@ -40,8 +40,10 @@ void UnassignAllSkillsPoints(Unit* ptChar)
DWORD skillID, keepBonus, maxSkillLevel; DWORD skillID, keepBonus, maxSkillLevel;
int skpoints; int skpoints;
DWORD nbPoints = 0; DWORD nbPoints = 0;
void* ptClient = D2GetClient(ptChar,__FILE__,__LINE__); void* ptClient = D2GetClient(ptChar,__FILE__,__LINE__);
SkillData* ptSkill = PCSkills->ptFirstSkill; SkillData* ptSkill = PCSkills->ptFirstSkill;
while (ptSkill) while (ptSkill)
{ {
if (getCharClass(ptSkill) == ptChar->nPlayerClass)//ptSkill->ptSkillBin->charclass if (getCharClass(ptSkill) == ptChar->nPlayerClass)//ptSkill->ptSkillBin->charclass
@ -51,7 +53,7 @@ void UnassignAllSkillsPoints(Unit* ptChar)
keepBonus = !getSingleSkillValue(ptChar, STATS_ITEM_SINGLESKILL, skillID); keepBonus = !getSingleSkillValue(ptChar, STATS_ITEM_SINGLESKILL, skillID);
maxSkillLevel = D2GetSkillLevel(ptChar, ptSkill, 0); maxSkillLevel = D2GetSkillLevel(ptChar, ptSkill, 0);
skpoints = getskPoint(ptSkill); skpoints = getskPoint(ptSkill);
if (skpoints == -1 || unassignSkillsPointsOneByOne) if (skpoints == -1 || unassignSkillsPointsOneForOne)
{ {
D2SetSkillBaseLevel(ptChar, skillID, 0, keepBonus, __FILE__, __LINE__); D2SetSkillBaseLevel(ptChar, skillID, 0, keepBonus, __FILE__, __LINE__);
nbPoints += maxSkillLevel; nbPoints += maxSkillLevel;

13
PlugY/StatPerLevelUp.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Change Stat win per level up. Change Stat win per level up.
@ -12,6 +13,13 @@
bool active_StatPerLevelUpChange=0; bool active_StatPerLevelUpChange=0;
DWORD statPerLevelUp=5; DWORD statPerLevelUp=5;
FCT_ASM ( caller_changeStatPerLevelUp_114 )
MOV EAX,statPerLevelUp
IMUL EAX,EDI
MOV DWORD PTR SS:[ESP+0xC], EAX
JMP V2AddPlayerStat
}}
FCT_ASM ( caller_changeStatPerLevelUp_111 ) FCT_ASM ( caller_changeStatPerLevelUp_111 )
MOV EAX,statPerLevelUp MOV EAX,statPerLevelUp
IMUL EAX,EBX IMUL EAX,EBX
@ -33,14 +41,15 @@ void Install_StatPerLevelUp()
log_msg("Patch D2Game for change Stat points win per level up. (StatPerLevelUp)\n"); log_msg("Patch D2Game for change Stat points win per level up. (StatPerLevelUp)\n");
mem_seek R7(D2Game, 42258, 42648, 4ED55, D7ADA, 7968A, AA44A, EB1DA, EDC9A); mem_seek R8(D2Game, 42258, 42648, 4ED55, D7ADA, 7968A, AA44A, EB1DA, EDC9A, 1709C6);
MEMJ_REF4( V2AddPlayerStat, version_D2Game >= V111 ? caller_changeStatPerLevelUp_111 : caller_changeStatPerLevelUp); MEMJ_REF4( V2AddPlayerStat, version_D2Game >= V114d ? caller_changeStatPerLevelUp_114 : version_D2Game >= V111 ? caller_changeStatPerLevelUp_111 : caller_changeStatPerLevelUp);
//6FC7ED54 |. E8 61CB0900 CALL <JMP.&D2Common.#10518> //6FC7ED54 |. E8 61CB0900 CALL <JMP.&D2Common.#10518>
//02057AD9 |. E8 AA28F3FF CALL <JMP.&D2Common.#10109> //02057AD9 |. E8 AA28F3FF CALL <JMP.&D2Common.#10109>
//01FE9689 |. E8 260DF9FF CALL <JMP.&D2Common.#10627> //01FE9689 |. E8 260DF9FF CALL <JMP.&D2Common.#10627>
//6FCCA449 |. E8 6A01F6FF CALL <JMP.&D2Common.#10762> //6FCCA449 |. E8 6A01F6FF CALL <JMP.&D2Common.#10762>
//6FD0B1D9 |. E8 F4F2F1FF CALL <JMP.&D2Common.#10551> //6FD0B1D9 |. E8 F4F2F1FF CALL <JMP.&D2Common.#10551>
//6FD0DC99 |. E8 08C7F1FF CALL <JMP.&D2Common.#10645> //6FD0DC99 |. E8 08C7F1FF CALL <JMP.&D2Common.#10645>
//005709C5 |. E8 E6680B00 CALL Game.006272B0 ; \Game.006272B0
log_msg("\n"); log_msg("\n");

89
PlugY/StatsPoints.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Unassign Stats Point for futher re-assignment. Unassign Stats Point for futher re-assignment.
@ -9,6 +10,7 @@
#include "plugYFiles.h" // Install_PlugYImagesFiles() #include "plugYFiles.h" // Install_PlugYImagesFiles()
#include "interface_Stats.h" // Install_InterfaceStats() #include "interface_Stats.h" // Install_InterfaceStats()
#include "updateServer.h" #include "updateServer.h"
#include "extraOptions.h"
#include "common.h" #include "common.h"
#include <stdio.h> #include <stdio.h>
@ -162,9 +164,12 @@ void STDCALL printDisabledStatsBtn(WORD statID, sDrawImageInfo* data, DWORD x, D
_snwprintf(text, sizeof(text) - 1, getLocalString(STR_STATS_UNASSIGN_WITH_LIMIT), limitValueToShiftClick); _snwprintf(text, sizeof(text) - 1, getLocalString(STR_STATS_UNASSIGN_WITH_LIMIT), limitValueToShiftClick);
else else
_snwprintf(text, sizeof(text) - 1, getLocalString(STR_STATS_UNASSIGN_WITHOUT_LIMIT)); _snwprintf(text, sizeof(text) - 1, getLocalString(STR_STATS_UNASSIGN_WITHOUT_LIMIT));
if (active_DisplayBaseStatsValue)
{
wcscat(text,L"\n"); wcscat(text,L"\n");
int len = wcslen(text); int len = wcslen(text);
_snwprintf(text + len, sizeof(text) - len, getLocalString(STR_STATS_BASE_MIN), statValue, minValue); _snwprintf(text + len, sizeof(text) - len, getLocalString(STR_STATS_BASE_MIN), statValue, minValue);
}
D2SetFont(1); D2SetFont(1);
D2PrintPopup(text, x+18, y-32, WHITE, 1); D2PrintPopup(text, x+18, y-32, WHITE, 1);
} }
@ -249,6 +254,13 @@ END_UNASSGNSTATS:
RETN RETN
}} }}
FCT_ASM ( caller_setValue_114 )
MOV CL,0x3A
OR DX,WORD PTR DS:[ESI]
ADD DL, currentMsgID
MOV CH, DL
RETN
}}
FCT_ASM ( caller_setValue_111 ) FCT_ASM ( caller_setValue_111 )
ADD CL,currentMsgID ADD CL,currentMsgID
@ -288,6 +300,21 @@ DWORD STDCALL pushDown (DWORD num)
return 0; return 0;
} }
FCT_ASM( caller_pushDown_114 )
PUSH EDX
PUSH DWORD PTR SS:[EBP+0x8]
CALL pushDown
POP EDX
TEST EAX, EAX
JNZ end_pushDown
SUB DWORD PTR SS:[ESP],0x22
RETN
end_pushDown :
MOV EAX, DWORD PTR SS:[EBP+8]
LEA ECX, DWORD PTR DS:[EAX*8]
RETN
}}
FCT_ASM ( caller_pushDown_111 ) FCT_ASM ( caller_pushDown_111 )
PUSH EDX PUSH EDX
PUSH EDX PUSH EDX
@ -329,42 +356,57 @@ void Install_StatsPoints()
log_msg("Patch D2Client for unassign stat points when specified key is press. (StatsPoints)\n"); log_msg("Patch D2Client for unassign stat points when specified key is press. (StatsPoints)\n");
// Always print stat button images. // Always print stat button images.
mem_seek R7(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5, BF955); mem_seek R8(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5, BF955, A7FFB);
memt_byte( 0x8B, 0xEB ); // JMP SHORT D2Client.6FAD0088 memt_byte( 0x8B, 0xEB ); // JMP SHORT D2Client.6FAD0088
memt_byte( 0x4C, V7(D2Client, 12, 12, 13, 13, 13, 13, 13, 13) ); memt_byte( version_D2Client == V114d ? 0x4D : 0x4C, V8(D2Client, 12, 12, 13, 13, 13, 13, 13, 13, 12) );
memt_byte( 0x24, 0x90 ); // NOP memt_byte( version_D2Client == V114d ? 0xF8 : 0x24, 0x90 ); // NOP
memt_byte( V7(D2Client, 20, 20, 14, 1C, 1C, 1C, 1C, 1C), 0x90 ); // NOP (V109d:0x20 , V110:0x14 if (version_D2Client < V114a) memt_byte( V8(D2Client, 20, 20, 14, 1C, 1C, 1C, 1C, 1C, 53), 0x90 ); // NOP (V109d:0x20 , V110:0x14
//6FAD0073 8B4C24 14 MOV ECX,DWORD PTR SS:[ESP+14] //6FAD0073 8B4C24 14 MOV ECX,DWORD PTR SS:[ESP+14]
//6FB32BBA > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C] //6FB32BBA > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB3963A > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C] //6FB3963A > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB1B59A > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C] //6FB1B59A > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB6D1B5 |> 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C] //6FB6D1B5 |> 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//6FB6F955 > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C] //6FB6F955 > 8B4C24 1C MOV ECX,DWORD PTR SS:[ESP+1C]
//004A7FFB > 8B4D F8 MOV ECX,DWORD PTR SS:[EBP-8]
//004A7FFE . 53 PUSH EBX ; /Arg3
//print our buttons //print our buttons
mem_seek R7(D2Client, 29B9D, 29B8D, 300FD, 82C54, 896D4, 6B637, BD23E, BF9DE); mem_seek R8(D2Client, 29B9D, 29B8D, 300FD, 82C54, 896D4, 6B637, BD23E, BF9DE, A808C);
MEMJ_REF4( D2PrintImage, caller_printUnassignStatsBtn); MEMJ_REF4( D2PrintImage, caller_printUnassignStatsBtn);
//6FB32C53 . E8 82A3F8FF CALL <JMP.&D2gfx.#10047> //6FB32C53 . E8 82A3F8FF CALL <JMP.&D2gfx.#10047>
//6FB396D3 . E8 D238F8FF CALL <JMP.&D2gfx.#10044> //6FB396D3 . E8 D238F8FF CALL <JMP.&D2gfx.#10044>
//6FB1B636 . E8 431AFAFF CALL <JMP.&D2gfx.#10024> //6FB1B636 . E8 431AFAFF CALL <JMP.&D2gfx.#10024>
//6FB6D23D . E8 54FEF4FF CALL <JMP.&D2gfx.#10041> //6FB6D23D . E8 54FEF4FF CALL <JMP.&D2gfx.#10041>
//6FB6F9DD . E8 ECD5F4FF CALL <JMP.&D2gfx.#10042> //6FB6F9DD . E8 ECD5F4FF CALL <JMP.&D2gfx.#10042>
//004A808B . E8 F0E30400 CALL Game.004F6480 ; \Game.004F6480
// Always manage push down. // Always manage push down.
mem_seek R7(D2Client, 2AA7B, 2AA6B, 3134D, 827D9, 89259, 6B1B9, BCDD9, BF579); mem_seek R8(D2Client, 2AA7B, 2AA6B, 3134D, 827D9, 89259, 6B1B9, BCDD9, BF579, A77E4);
memt_byte( 0x74, 0x90 ); // NOP memt_byte( 0x74, 0x90 ); // NOP
memt_byte( 0x4E, 0x90 ); // NOP memt_byte( version_D2Client == V114d ? 0x62 : 0x4E, 0x90 ); // NOP
//6FAD134D 74 4E JE SHORT D2Client.6FAD139D //6FAD134D 74 4E JE SHORT D2Client.6FAD139D
//6FB327D9 . 74 4E JE SHORT D2Client.6FB32829 //6FB327D9 . 74 4E JE SHORT D2Client.6FB32829
//6FB39259 . 74 4E JE SHORT D2Client.6FB392A9 //6FB39259 . 74 4E JE SHORT D2Client.6FB392A9
//6FB1B1B9 74 4E JE SHORT D2Client.6FB1B209 //6FB1B1B9 74 4E JE SHORT D2Client.6FB1B209
//6FB6CDD9 . 74 4E JE SHORT D2Client.6FB6CE29 //6FB6CDD9 . 74 4E JE SHORT D2Client.6FB6CE29
//6FB6F579 . 74 4E JE SHORT D2Client.6FB6F5C9 //6FB6F579 . 74 4E JE SHORT D2Client.6FB6F5C9
//004A77E4 . 74 62 JE SHORT Game.004A7848
if ( version_D2Client >= V111 ) if ( version_D2Client >= V114d )
{ {
// On Push down. // On Push down.
mem_seek R7(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 6B224, BCE44, BF5E4); mem_seek R8(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 6B224, BCE44, BF5E4, A7863);
memt_byte(0x8B, 0xE8);
MEMT_REF4(0x0C8D0845, caller_pushDown_114);
memt_byte(0xC5, 0x90);
memt_dword(0x00000000, 0x90909090);
//004A7863 > 8B45 08 MOV EAX,DWORD PTR SS:[EBP+8]
//004A7866 . 8D0CC5 0000000>LEA ECX,DWORD PTR DS:[EAX*8]
}
else if ( version_D2Client >= V111 )
{
// On Push down.
mem_seek R8(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 6B224, BCE44, BF5E4, A7863);
memt_byte( 0x6B, 0xE8 ); memt_byte( 0x6B, 0xE8 );
MEMT_REF4( 0x01BF0ED2, caller_pushDown_111); MEMT_REF4( 0x01BF0ED2, caller_pushDown_111);
memt_byte( 0x00, 0x6B ); // IMUL EDX,EDX,0E memt_byte( 0x00, 0x6B ); // IMUL EDX,EDX,0E
@ -383,7 +425,7 @@ void Install_StatsPoints()
} else { } else {
// On Push down. // On Push down.
mem_seek R7(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 0000, 0000, 0000); mem_seek R8(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 0000, 0000, 0000, 0000);
memt_byte( 0x8D, 0xE8 ); // CALL memt_byte( 0x8D, 0xE8 ); // CALL
MEMT_REF4( 0x0000D504, caller_pushDown); MEMT_REF4( 0x0000D504, caller_pushDown);
memt_byte( 0x00, 0x90 ); // NOP memt_byte( 0x00, 0x90 ); // NOP
@ -395,18 +437,20 @@ void Install_StatsPoints()
if ( version_D2Client >= V110 ) if ( version_D2Client >= V110 )
{ {
// Always manage push up. // Always manage push up.
mem_seek R7(D2Client, 0000, 0000, 3152E, 83869, 8A2E9, 6C249, BDE49, C05E9); mem_seek R8(D2Client, 0000, 0000, 3152E, 83869, 8A2E9, 6C249, BDE49, C05E9, A7976);
memt_byte( 0x74, 0x90 ); // NOP memt_byte( version_D2Client == V114d ? 0x0F : 0x74, 0x90 ); // NOP
memt_byte( version_D2Client >= V111 ? 0x65 : 0x68, 0x90 ); // NOP memt_byte( version_D2Client == V114d ? 0x84 : version_D2Client >= V111 ? 0x65 : 0x68, 0x90 ); // NOP
if (version_D2Client == V114d) memt_dword(0x000000BB, 0x90909090);
//6FAD152E 74 68 JE SHORT D2Client.6FAD1598 //6FAD152E 74 68 JE SHORT D2Client.6FAD1598
//6FB33869 . 74 65 JE SHORT D2Client.6FB338D0 //6FB33869 . 74 65 JE SHORT D2Client.6FB338D0
//6FB3A2E9 . 74 65 JE SHORT D2Client.6FB3A350 //6FB3A2E9 . 74 65 JE SHORT D2Client.6FB3A350
//6FB1C249 74 65 JE SHORT D2Client.6FB1C2B0 //6FB1C249 74 65 JE SHORT D2Client.6FB1C2B0
//6FB6DE49 . 74 65 JE SHORT D2Client.6FB6DEB0 //6FB6DE49 . 74 65 JE SHORT D2Client.6FB6DEB0
//6FB705E9 . 74 65 JE SHORT D2Client.6FB70650 //6FB705E9 . 74 65 JE SHORT D2Client.6FB70650
//004A7976 |. 0F84 BB000000 JE Game.004A7A37
// Unassign stats point when ctrl is push. // Unassign stats point when ctrl is push.
mem_seek R7(D2Client, 0000, 0000, 315D3, 8391B, 8A39B, 6C2FB, BDEFB, C069B); mem_seek R8(D2Client, 0000, 0000, 315D3, 8391B, 8A39B, 6C2FB, BDEFB, C069B, A79F2);
memt_byte( 0x66, 0xE8 ); // CALL memt_byte( 0x66, 0xE8 ); // CALL
MEMT_REF4( 0x077CC085, caller_UnassignStats); MEMT_REF4( 0x077CC085, caller_UnassignStats);
//6FAD15D3 . 66:85C0 TEST AX,AX //6FAD15D3 . 66:85C0 TEST AX,AX
@ -421,31 +465,35 @@ void Install_StatsPoints()
//6FB6DEFE . 7C 07 JL SHORT D2Client.6FB6DF07 //6FB6DEFE . 7C 07 JL SHORT D2Client.6FB6DF07
//6FB7069B . 66:85C0 TEST AX,AX //6FB7069B . 66:85C0 TEST AX,AX
//6FB7069E . 7C 07 JL SHORT D2Client.6FB706A7 //6FB7069E . 7C 07 JL SHORT D2Client.6FB706A7
//004A79F2 |. 66:85C0 TEST AX,AX
//004A79F5 |. 7C 07 JL SHORT Game.004A79FE
} else { } else {
// Always manage push up. // Always manage push up.
mem_seek R7(D2Client, 2AC55, 2AC45, 0000, 0000, 0000, 0000, 0000, 0000); mem_seek R8(D2Client, 2AC55, 2AC45, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0x0F, 0x90 ); // NOP memt_byte( 0x0F, 0x90 ); // NOP
memt_byte( 0x84, 0x90 ); // NOP memt_byte( 0x84, 0x90 ); // NOP
memt_dword( 0x000000AE, 0x90909090 ); // NOP NOP NOP NOP memt_dword( 0x000000AE, 0x90909090 ); // NOP NOP NOP NOP
//6FACAC45 . 0F84 AE000000 JE D2Client.6FACACF9 //6FACAC45 . 0F84 AE000000 JE D2Client.6FACACF9
// Unassign stats point when ctrl is push. // Unassign stats point when ctrl is push.
mem_seek R7(D2Client, 2ACD9, 2ACC9, 0000, 0000, 0000, 0000, 0000, 0000); mem_seek R8(D2Client, 2ACD9, 2ACC9, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
memt_byte( 0xB8, 0xE8 ); // CALL memt_byte( 0xB8, 0xE8 ); // CALL
MEMT_REF4( 0x00000001, caller_UnassignStats_9); MEMT_REF4( 0x00000001, caller_UnassignStats_9);
//6FACACC9 . B8 01000000 MOV EAX,1 //6FACACC9 . B8 01000000 MOV EAX,1
} }
// Set the id for the calling function. // Set the id for the calling function.
mem_seek R7(D2Client, 2AD02, 2ACF2, 31611, 8395E, 8A3DE, 6C33E, BDF3E, C06DE); mem_seek R8(D2Client, 2AD02, 2ACF2, 31611, 8395E, 8A3DE, 6C33E, BDF3E, C06DE, A7A29);
if ( version_D2Client >= V111 ) { if ( version_D2Client >= V111 ) {
memt_byte( 0x66, 0xE8 ); // CALL memt_byte( version_D2Client == V114d ? 0xB1 : 0x66, 0xE8 ); // CALL
MEMT_REF4( 0x15244C89, caller_setValue_111); MEMT_REF4( version_D2Client == V114d ? 0x160B663A : 0x15244C89, version_D2Client == V114d ? caller_setValue_114 : caller_setValue_111);
//6FB3395E . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX //6FB3395E . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX
//6FB3A3DE . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX //6FB3A3DE . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX
//6FB1C33E . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX ; | //6FB1C33E . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX ; |
//6FB6DF3E . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX ; | //6FB6DF3E . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX ; |
//6FB706DE . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX ; | //6FB706DE . 66:894C24 15 MOV WORD PTR SS:[ESP+15],CX ; |
//004A7A29 |. B1 3A |MOV CL,3A
//004A7A2B |. 66:0B16 |OR DX,WORD PTR DS:[ESI]
} else { } else {
MEMC_REF4( D2SendToServer3, caller_setValue); MEMC_REF4( D2SendToServer3, caller_setValue);
//6FAD1610 . E8 7BC3FDFF CALL D2Client.6FAAD990 //6FAD1610 . E8 7BC3FDFF CALL D2Client.6FAAD990
@ -482,7 +530,7 @@ void Install_StatsLimitShiftClick()
log_msg("Patch D2Client for limit the assigment of stat points when shift is used. (LimitShift)\n"); log_msg("Patch D2Client for limit the assigment of stat points when shift is used. (LimitShift)\n");
// Limit the assigment of stat points. // Limit the assigment of stat points.
mem_seek R7(D2Client, 2ACD0, 2ACC0, 315CD, 83915, 8A395, 6C2F5, BDEF5, C0695); mem_seek R8(D2Client, 2ACD0, 2ACC0, 315CD, 83915, 8A395, 6C2F5, BDEF5, C0695, A79EC);
memt_byte( 0xFF, 0x90 ); // NOP memt_byte( 0xFF, 0x90 ); // NOP
memt_byte( 0x15, 0xE8 ); // CALL memt_byte( 0x15, 0xE8 ); // CALL
MEMD_REF4( GetKeyState, version_D2Client >= V111 ? caller_LimitShift_111 : caller_LimitShift); MEMD_REF4( GetKeyState, version_D2Client >= V111 ? caller_LimitShift_111 : caller_LimitShift);
@ -492,6 +540,7 @@ void Install_StatsLimitShiftClick()
//6FB1C2F5 . FF15 10F1B76F CALL DWORD PTR DS:[<&USER32.GetKeyState>>; \GetKeyState //6FB1C2F5 . FF15 10F1B76F CALL DWORD PTR DS:[<&USER32.GetKeyState>>; \GetKeyState
//6FB6DEF5 . FF15 04F1B76F CALL DWORD PTR DS:[<&USER32.GetKeyState>>; \GetKeyState //6FB6DEF5 . FF15 04F1B76F CALL DWORD PTR DS:[<&USER32.GetKeyState>>; \GetKeyState
//6FB70695 . FF15 2001B86F CALL DWORD PTR DS:[<&USER32.GetKeyState>>; \GetKeyState //6FB70695 . FF15 2001B86F CALL DWORD PTR DS:[<&USER32.GetKeyState>>; \GetKeyState
//004A79EC |. FF15 5CC46C00 CALL DWORD PTR DS:[<&USER32.GetKeyState>>; \GetKeyState
log_msg("\n"); log_msg("\n");

510
PlugY/UberQuest.cpp
View File

@ -1,49 +1,16 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Uber Quest Management. Uber Quest Management.
=================================================================*/ =================================================================*/
#include <math.h>
#include "uberQuest.h" #include "uberQuest.h"
#include "common.h" #include "common.h"
bool active_UberQuest=0;
/*
void* ptQuest = D2GetPlayerData(ptChar)->ptQuest[ptGame->difficultyLevel];
if (D2CheckQuestState(ptGame->game10F4[0xC],4,0xB) ||
D2CheckQuestState(ptQuest,4,0xA) ||
ptGame->ptIsLodGame && !D2CheckQuestState(ptQuest,0x28,0)
// !ptGame->ptIsLodGame && D2CheckQuestState(ptQuest,0x1A,0)TODO for !ptGame->ptIsLodGame...
{
// d2_assert(!ptChar,"openPandPortal : ptChar==NULL",__FILE__,__LINE__);
// ptChar->v6E = 0x14;
// ptChar->v70 = ptChar;
// D2Common10148(ptChar);
// ptChar->flag400 = 1;
// return 0;
}
Room* = ptRoom = D2GetRoom(ptChar);
if (D2GetLevelID(ptRoom) != 1) return 0;
Position pos1;
D2GetPosition(ptChar, &pos1);
void* ptPortal = NULL;
D2Game02059FE0(ptRoom,&pos1,3,0x400,&ptPortal,0x64);
if (!ptPortal) return 0;
Position pos2;
pos2.x = pos1.x;
pos2.y = pos1.y;
testing crash useless...
D2GetDropRoom(ptRoom, &pos2, &pos2,3,0x3E01,0xC01,0);
*/
/*
void* FASTCALL D2Game01F81090(Room* ptRoom, DWORD x, DWORD y);//0x1090
*/
#define OBJECT_PERMANENT_PORTAL 0x3C #define OBJECT_PERMANENT_PORTAL 0x3C
#define LEVEL_ACT5TOWN 109 #define LEVEL_ACT5TOWN 109
#define LEVEL_ACT5_PANDEMONIUM1 133 #define LEVEL_ACT5_PANDEMONIUM1 133
@ -51,6 +18,53 @@ void* FASTCALL D2Game01F81090(Room* ptRoom, DWORD x, DWORD y);//0x1090
#define LEVEL_ACT5_PANDEMONIUM3 135 #define LEVEL_ACT5_PANDEMONIUM3 135
#define LEVEL_ACT5_PANDEMONIUM_FINAL 136 #define LEVEL_ACT5_PANDEMONIUM_FINAL 136
#define UBER_IZUAL_ID 706
#define UBER_ANDARIEL_ID 707
#define UBER_DURIEL_ID 708
#define UBER_MEPHISTO_ID 704
#define UBER_DIABLO_ID 705
#define UBER_BAAL_ID 709
#define UBER_MEPHISTO_SQUELETON 725
#define UBER_MEPHISTO_ARCHER 726
#define UBER_MEPHISTO_FIRE 727
#define UBER_MEPHISTO_LIGHTNING 728
#define UBER_MEPHISTO_COLD 729
#define UBER_MEPHISTO_POISON 730
#define UBER_BAAL_DARK_LORD 731
#define UBER_BAAL_SPECTER 732
#define UBER_DIABLO_PIT_LORD 711
bool active_UberQuest = false;
DWORD UberMephistoX = 25130;
DWORD UberMephistoY = 5143;
DWORD UberDiabloX = 25139;
DWORD UberDiabloY = 5139;
DWORD UberBaalX = 25139;
DWORD UberBaalY = 5135;
bool active_UberMinions = true;
DWORD UberMephistoNbMinions = 6;
DWORD UberMephistoMinions[] = {UBER_MEPHISTO_SQUELETON, UBER_MEPHISTO_ARCHER, UBER_MEPHISTO_FIRE, UBER_MEPHISTO_LIGHTNING, UBER_MEPHISTO_COLD, UBER_MEPHISTO_POISON};
int UberMephistoSpawnPercent = 80;
DWORD UberMephistoSpawnRadius = 30;
DWORD UberBaalNbMinions = 2;
DWORD UberBaalMinions[] = {UBER_BAAL_DARK_LORD, UBER_BAAL_SPECTER};
int UberBaalSpawnPercent = 30;
DWORD UberBaalSpawnRadius = 30;
DWORD UberDiabloNbMinions = 1;
DWORD UberDiabloMinions[] = {UBER_DIABLO_PIT_LORD};
int UberDiabloSpawnPercent = 30;
DWORD UberDiabloSpawnRadius = 30;
bool active_UberDiabloRushTweekAI = false;
bool active_UberBaalTeleportTweekAI = false;
bool active_UberBaalChillingArmorTweekAI = false;
int uberBaalChillingArmorTimer = 6000;
int uberBaalChillingArmorLastFrame = 0;
static struct static struct
{ {
union{ union{
@ -71,39 +85,48 @@ static struct
int count1; int count1;
int count2; int count2;
int count3; int count3;
int count4;
int count5;
int count6;
Room* room1;
Room* room2;
Room* room3;
Room* room4;
Room* room5;
Room* room6;
} questState; } questState;
int GetNbMonsters(Level* level, Position position, int radius);
int GetNbMonsters(Level* level);
bool IsInRoom(Room* ptRoom, DWORD x, DWORD y)
{
DWORD startX = version_D2Game > V112 ? ptRoom->startX : *((DWORD*)ptRoom + 6);
DWORD startY = version_D2Game > V112 ? ptRoom->startY : *((DWORD*)ptRoom + 7);
DWORD sizeX = version_D2Game > V112 ? ptRoom->sizeX : *((DWORD*)ptRoom + 8);
DWORD sizeY = version_D2Game > V112 ? ptRoom->sizeY : *((DWORD*)ptRoom + 9);
return x >= startX && x <= startX + sizeX &&
y >= startY && y <= startY + sizeY;
}
double Distance(Position p1, Position p2)
{
return sqrt((double)(p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
}
void resetQuestState() void resetQuestState()
{ {
ZeroMemory(&questState,sizeof(questState)); ZeroMemory(&questState,sizeof(questState));
questState.count1 = 10 + RANDOM(10); questState.count1 = 10 + RANDOM(10);
questState.count2 = 20 + RANDOM(40); questState.count2 = 20 + RANDOM(40);
questState.count3 = 10 + RANDOM(20); questState.count3 = 10 + RANDOM(20);
int value = 5 + RANDOM(10); uberBaalChillingArmorLastFrame = 0;
questState.count4 = value + RANDOM(4); log_msg("Uber Quest State : %d %d %d\n",questState.count1, questState.count2, questState.count3);
questState.count5 = value + RANDOM(4);
questState.count6 = value + RANDOM(4);
log_msg("Uber Quest State : %d %d %d %d %d %d\n",questState.count1, questState.count2, questState.count3, questState.count4, questState.count5, questState.count6);
} }
DWORD openPortalOnLevel(Game* ptGame, Unit* ptChar, DWORD levelID) DWORD openPortalOnLevel(Game* ptGame, Unit* ptChar, DWORD levelID)
{ {
log_msg("openning portal to level %d\n",levelID); log_msg("Open portal to level %d\n", levelID);
Room* ptRoom = D2GetRoom(ptChar); Room* ptRoom = D2GetRoom(ptChar);
if ( D2GetLevelID(ptRoom) != LEVEL_ACT5TOWN ) return 0; if ( D2GetLevelID(ptRoom) != LEVEL_ACT5TOWN ) return 0;
//Get position in the room //Get position in the room
Position pos; Position pos;
D2GetPosition(ptChar, &pos); D2GetPosition(ptChar, &pos);
log_msg("ptChar pos : %d %d\n", pos.x, pos.y);
if (!D2GetDropRoom(ptRoom, &pos, &pos, 3, 0x3E01, 0xC01, 0)) return 0; if (!D2GetDropRoom(ptRoom, &pos, &pos, 3, 0x3E01, 0xC01, 0)) return 0;
ptRoom = D2TestPositionInRoom(ptRoom, pos.x, pos.y); ptRoom = D2TestPositionInRoom(ptRoom, pos.x, pos.y);
if (!ptRoom) return 0; if (!ptRoom) return 0;
@ -123,11 +146,10 @@ DWORD openPortalOnLevel(Game* ptGame, Unit* ptChar, DWORD levelID)
DWORD FASTCALL openPandPortal(Game* ptGame, Unit* ptChar) DWORD FASTCALL openPandPortal(Game* ptGame, Unit* ptChar)
{ {
log_msg("openPandPortal\n"); log_msg("openPandPortal\n");
Position pos;
D2GetPosition(ptChar, &pos);
log_msg("ptChar pos : %d %d\n",pos.x,pos.y);
if (ptGame->difficultyLevel != D2DM_HELL) return 0; if (ptGame->difficultyLevel != D2DM_HELL)
return 0;
int available[3]; int available[3];
int nbAvailable=0; int nbAvailable=0;
if (!questState.portal1Opened) available[nbAvailable++]=LEVEL_ACT5_PANDEMONIUM1; if (!questState.portal1Opened) available[nbAvailable++]=LEVEL_ACT5_PANDEMONIUM1;
@ -140,45 +162,30 @@ DWORD FASTCALL openPandPortal(Game* ptGame, Unit* ptChar)
int ret = openPortalOnLevel(ptGame, ptChar, selectedTargetLevel); int ret = openPortalOnLevel(ptGame, ptChar, selectedTargetLevel);
if (ret) if (ret)
{ {
if (selectedTargetLevel == LEVEL_ACT5_PANDEMONIUM1) questState.portal1Opened = 1; if (selectedTargetLevel == LEVEL_ACT5_PANDEMONIUM1) questState.portal1Opened = 1;
else if (selectedTargetLevel == LEVEL_ACT5_PANDEMONIUM2) questState.portal2Opened = 1; else if (selectedTargetLevel == LEVEL_ACT5_PANDEMONIUM2) questState.portal2Opened = 1;
else if (selectedTargetLevel == LEVEL_ACT5_PANDEMONIUM3) questState.portal3Opened = 1; else if (selectedTargetLevel == LEVEL_ACT5_PANDEMONIUM3) questState.portal3Opened = 1;
} }
log_msg("openPandPortal ending\n\n");
return ret;//normally return ret; return ret;
} }
DWORD FASTCALL openPandFinalPortal(Game* ptGame, Unit* ptChar) DWORD FASTCALL openPandFinalPortal(Game* ptGame, Unit* ptChar)
{ {
log_msg("openPandFinalPortal\n"); log_msg("openPandFinalPortal\n");
Position pos;
D2GetPosition(ptChar, &pos);
log_msg("ptChar pos : %d %d",pos.x,pos.y);
int ret = openPortalOnLevel(ptGame, ptChar, LEVEL_ACT5_PANDEMONIUM_FINAL);
log_msg("openPandFinalPortal ending\n");
return ret;//normally return ret;
}
Room* selectRoom(Game* ptGame, Room* ptCurrentRoom, DWORD level) if (ptGame->difficultyLevel != D2DM_HELL)
{ return 0;
/* Room* tab[200];
nbRoom=0; return openPortalOnLevel(ptGame, ptChar, LEVEL_ACT5_PANDEMONIUM_FINAL);
Room* ptRoom = ptGame->mapAct[5]->ptFirstRoom;
while (ptRoom);
if(!ptCurrentRoom->nbNearRooms) return ptCurrentRoom;
int targetRoomNum = RANDOM(ptCurrentRoom->nbNearRooms);
Room* ptRoom = ptCurrentRoom->ptNearRooms;
while (targetRoomNum--)
ptRoom = ptRoom->ptNextRoom;*/
return ptCurrentRoom;
} }
void STDCALL spawnUber(Game* ptGame, Room* ptRoom) void STDCALL spawnUber(Game* ptGame, Room* ptRoom)
{ {
log_msg("Uber Quest State : %d %d %d %d %d %d\n",questState.count1, questState.count2, questState.count3, questState.count4, questState.count5, questState.count6); log_msg("Uber Quest State : %d %d %d\n",questState.count1, questState.count2, questState.count3);
log_msg("Uber Quest questState spawn : %d %d %d %d %d %d\n",questState.uber1Spawned, questState.uber2Spawned, questState.uber3Spawned, questState.uber4Spawned, questState.uber5Spawned, questState.uber6Spawned);
switch(D2GetLevelID(ptRoom)) switch(D2GetLevelID(ptRoom))
{ {
case LEVEL_ACT5_PANDEMONIUM1: case LEVEL_ACT5_PANDEMONIUM1:
@ -186,8 +193,7 @@ void STDCALL spawnUber(Game* ptGame, Room* ptRoom)
{ {
if (questState.count1) questState.count1--; if (questState.count1) questState.count1--;
else { else {
Room* ptTargetRoom = selectRoom(ptGame, ptRoom, LEVEL_ACT5_PANDEMONIUM1); if (D2SpawnSuperUnique(ptGame, ptRoom, 0, 0, 0, -1, UBER_ANDARIEL_ID, 0))
if (D2SpawnMonster(ptGame, ptTargetRoom, 0, 0, 0, -1, 707, 0))
questState.uber1Spawned = 1; questState.uber1Spawned = 1;
} }
} }
@ -197,8 +203,7 @@ void STDCALL spawnUber(Game* ptGame, Room* ptRoom)
{ {
if (questState.count2) questState.count2--; if (questState.count2) questState.count2--;
else { else {
Room* ptTargetRoom = selectRoom(ptGame, ptRoom, LEVEL_ACT5_PANDEMONIUM1); if (D2SpawnSuperUnique(ptGame, ptRoom, 0, 0, 0, -1, UBER_DURIEL_ID, 0))
if (D2SpawnMonster(ptGame, ptTargetRoom, 0, 0, 0, -1, 708, 0))
questState.uber2Spawned = 1; questState.uber2Spawned = 1;
} }
} }
@ -208,8 +213,7 @@ void STDCALL spawnUber(Game* ptGame, Room* ptRoom)
{ {
if (questState.count3) questState.count3--; if (questState.count3) questState.count3--;
else { else {
Room* ptTargetRoom = selectRoom(ptGame, ptRoom, LEVEL_ACT5_PANDEMONIUM1); if (D2SpawnSuperUnique(ptGame, ptRoom, 0, 0, 0, -1, UBER_IZUAL_ID, 0))
if (D2SpawnMonster(ptGame, ptTargetRoom, 0, 0, 0, -1, 706, 0))
questState.uber3Spawned = 1; questState.uber3Spawned = 1;
} }
} }
@ -217,103 +221,241 @@ void STDCALL spawnUber(Game* ptGame, Room* ptRoom)
case LEVEL_ACT5_PANDEMONIUM_FINAL: case LEVEL_ACT5_PANDEMONIUM_FINAL:
if (!questState.uber4Spawned) if (!questState.uber4Spawned)
{ {
if (questState.count4) questState.count4--; log_msg("Spawn Mephisto ptRoom: startX:%d - startY:%d / x:%d y:%d\n", ptRoom->startX, ptRoom->startY, ptRoom->sizeX, ptRoom->sizeY);
else { if (IsInRoom(ptRoom, UberMephistoX, UberMephistoY))
Room* ptTargetRoom = selectRoom(ptGame, ptRoom, LEVEL_ACT5_PANDEMONIUM1); {
if (D2SpawnMonster(ptGame, ptTargetRoom, 0, 0, 0, -1, 704, 0)) log_msg("Spawn Mephisto ptRoom: startX:%d - startY:%d / x:%d y:%d\n", ptRoom->startX, ptRoom->startY, ptRoom->sizeX, ptRoom->sizeY);
if (D2SpawnSuperUnique(ptGame, ptRoom, 0, UberMephistoX, UberMephistoY, -1, UBER_MEPHISTO_ID, 0))
questState.uber4Spawned = 1; questState.uber4Spawned = 1;
} }
} }
if (!questState.uber5Spawned) if (!questState.uber5Spawned)
{ {
if (questState.count5) questState.count5--; if (IsInRoom(ptRoom, UberDiabloX, UberDiabloY))
else { {
Room* ptTargetRoom = selectRoom(ptGame, ptRoom, LEVEL_ACT5_PANDEMONIUM1); log_msg("Spawn Diablo ptRoom: startX:%d - startY:%d / x:%d y:%d\n", ptRoom->startX, ptRoom->startY, ptRoom->sizeX, ptRoom->sizeY);
if (D2SpawnMonster(ptGame, ptTargetRoom, 0, 0, 0, -1, 705, 0)) if (D2SpawnSuperUnique(ptGame, ptRoom, 0, UberDiabloX, UberDiabloY, -1, UBER_DIABLO_ID, 0))
questState.uber5Spawned = 1; questState.uber4Spawned = 1;
} }
} }
if (!questState.uber6Spawned) if (!questState.uber6Spawned)
{ {
if (questState.count6) questState.count6--; if (IsInRoom(ptRoom, UberBaalX, UberBaalY))
else { {
Room* ptTargetRoom = selectRoom(ptGame, ptRoom, LEVEL_ACT5_PANDEMONIUM1); log_msg("Spawn Baal ptRoom: startX:%d - startY:%d / x:%d y:%d\n", ptRoom->startX, ptRoom->startY, ptRoom->sizeX, ptRoom->sizeY);
if (D2SpawnMonster(ptGame, ptTargetRoom, 0, 0, 0, -1, 709, 0)) if (D2SpawnSuperUnique(ptGame, ptRoom, 0, UberBaalX, UberBaalY, -1, UBER_BAAL_ID, 0))
questState.uber6Spawned = 1; questState.uber4Spawned = 1;
} }
} }
// D2SpawnMonster(PCGame, ptRoom, 0, 25113, 5138, -1, 704, 0);
// D2SpawnMonster(PCGame, ptRoom, 0, 25125, 5150, -1, 705, 0);
// D2SpawnMonster(PCGame, ptRoom, 0, 25135, 5140, -1, 709, 0);
} }
D2Game235C0(ptGame, ptRoom); D2Game235C0(ptGame, ptRoom);
} }
/*DWORD STDCALL spawnUber(Path* ptPath, Unit* ptChar, Room* ptRoom, DWORD x, DWORD y) //////////////////////////////////////////////////////////////////////////////
{
if (!D2WarpPlayer(ptPath, ptChar, ptRoom, x, y)) return 0;
switch(D2GetLevelID(ptRoom)) int GetNbMonsters(Level* level)
{
case LEVEL_ACT5_PANDEMONIUM1:
if (!questState.uber1Spawned)
{
Room* ptTargetRoom = selectRoom(PCGame, ptRoom, LEVEL_ACT5_PANDEMONIUM1);
D2SpawnMonster(PCGame, ptTargetRoom, 0, 0, 0, -1, 707, 0);
questState.uber1Spawned = 1;
}
break;
case LEVEL_ACT5_PANDEMONIUM2:
if (!questState.uber2Spawned)
{
Room* ptTargetRoom = selectRoom(PCGame, ptRoom, LEVEL_ACT5_PANDEMONIUM1);
D2SpawnMonster(PCGame, ptTargetRoom, 0, 0, 0, -1, 708, 0);
questState.uber2Spawned = 1;
}
break;
case LEVEL_ACT5_PANDEMONIUM3:
if (!questState.uber3Spawned)
{
Room* ptTargetRoom = selectRoom(PCGame, ptRoom, LEVEL_ACT5_PANDEMONIUM1);
D2SpawnMonster(PCGame, ptTargetRoom, 0, 0, 0, -1, 706, 0);
questState.uber3Spawned = 1;
}
break;
case LEVEL_ACT5_PANDEMONIUM_FINAL:
if (!questState.uber4Spawned)
{
Room* ptTargetRoom = selectRoom(PCGame, ptRoom, LEVEL_ACT5_PANDEMONIUM1);
D2SpawnMonster(PCGame, ptTargetRoom, 0, 0, 0, -1, 704, 0);
ptTargetRoom = selectRoom(PCGame, ptRoom, LEVEL_ACT5_PANDEMONIUM1);
D2SpawnMonster(PCGame, ptTargetRoom, 0, 0, 0, -1, 705, 0);
ptTargetRoom = selectRoom(PCGame, ptRoom, LEVEL_ACT5_PANDEMONIUM1);
D2SpawnMonster(PCGame, ptTargetRoom, 0, 0, 0, -1, 709, 0);
// D2SpawnMonster(PCGame, ptRoom, 0, 25113, 5138, -1, 704, 0);
// D2SpawnMonster(PCGame, ptRoom, 0, 25125, 5150, -1, 705, 0);
// D2SpawnMonster(PCGame, ptRoom, 0, 25135, 5140, -1, 709, 0);
questState.uber4Spawned = 1;
}
}
return 1;
}
*/
void FASTCALL uberMephIA(Game* ptGame, Unit* ptMonster, DWORD* ptData)
{ {
D2MephIA(ptGame, ptMonster, ptData); int nbMonsters = 0;
for (RoomEx* roomEx = level->ptFirstRoomEx; roomEx; roomEx = roomEx->ptNextRoomEx)
{
if (roomEx->ptRoom)
{
for (Unit* unit = roomEx->ptRoom->ptFirstUnit; unit; unit = unit->ptNextUnitInRoom)
{
if (unit->nUnitType == UNIT_MONSTER && unit->mode != UNIT_MODE_KICK && unit->nTxtFileNo != 711)
{
//log_msg("GetNbMonsters ++ / type:%d - id:%d - mode:%d\n", unit->nUnitType, unit->nTxtFileNo, unit->mode);
nbMonsters++;
}
//else log_msg("GetNbMonsters no / type:%d - id:%d - mode:%d\n", unit->nUnitType, unit->nTxtFileNo, unit->mode);
}
}
}
return nbMonsters;
} }
void FASTCALL uberDiabloIA(Game* ptGame, Unit* ptMonster, DWORD* ptData) int GetNbMonsters(Level* level, Position position, int radius)
{ {
D2DiabloIA(ptGame, ptMonster, ptData); int nbMonsters = 0;
for (RoomEx* roomEx = level->ptFirstRoomEx; roomEx; roomEx = roomEx->ptNextRoomEx)
{
if (roomEx->ptRoom)
{
for (Unit* unit = roomEx->ptRoom->ptFirstUnit; unit; unit = unit->ptNextUnitInRoom)
{
if (unit->nUnitType == UNIT_MONSTER && unit->mode != UNIT_MODE_KICK && unit->nTxtFileNo != 711)
{
Position p;
D2GetPosition(unit, &p);
if (Distance(position, p) <= radius)
nbMonsters++;
}
}
}
}
return nbMonsters;
} }
bool CastSummonMonster(Game* ptGame, Unit* ptMonster, DWORD x, DWORD y, DWORD* minions, int minionsSize, int mode)
void FASTCALL uberBaalIA(Game* ptGame, Unit* ptMonster, DWORD* ptData)
{ {
D2BaalIA(ptGame, ptMonster, ptData); DWORD minionId = minions[RANDOM(minionsSize)];
log_msg("CastSummonMonster: id:%d x:%d y:%d mode:%d\n", minionId, x, y, mode);
Room* ptRoom = D2GetRoom(ptMonster);
// Check nb of monsters
Level* ptLevel = ptRoom->ptRoomEx->ptLevel;
int monstersInLevel = GetNbMonsters(ptLevel);
Position position;
D2GetPosition(ptMonster, &position);
int monstersNearby = GetNbMonsters(ptLevel, position, 25);
log_msg("CastSummonMonster nbMonsters: %d - %d\n", monstersNearby, monstersInLevel);
if (monstersNearby > 16 || monstersInLevel > 100)
return false;
// Spawn Monster
log_msg("CastSummonMonster D2SpawnMonster(%d, %d, %08X, %08X, %d, %d, %d, %d)\n", minionId, mode, ptGame, ptRoom, x, y, 1, 0);
Unit* monster = D2SpawnMonster(minionId, mode, ptGame, ptRoom, x, y, 1, 0);
log_msg("CastSummonMonster D2SpawnMonster end\n");
if (monster)
return true;
// Try in near rooms
log_msg("CastSummonMonster Try in near rooms: %d - %d\n", ptRoom->startX, ptRoom->startY);
for(int i = 0; i < ptRoom->nbNearRooms; i++)
{
Room* ptRoom2 = ptRoom->ptNearRooms[i];
if (IsInRoom(ptRoom2, x, y))
{
log_msg("CastSummonMonster D2SpawnMonster(%d, %d, %08X, %08X, %d, %d, %d, %d)\n", minionId, mode, ptGame, ptRoom2, x, y, 1, 0);
monster = D2SpawnMonster(minionId, mode, ptGame, ptRoom2, x, y, 1, 0);
log_msg("CastSummonMonster D2SpawnMonster end\n");
if (monster)
return true;
}
}
log_msg("CastSummonMonster end: %d - %d\n", ptRoom->startX, ptRoom->startY);
return false;
} }
void RandInCircle(Position* position, DWORD radius)
{
double theta = RANDOMF() * 6.283185;
double r = sqrt(RANDOMF()) * radius;
position->x += (DWORD)(r * cos(theta));
position->y += (DWORD)(r * sin(theta));
}
void FASTCALL uberMephAI(Game* ptGame, Unit* ptMonster, AIParam* ptAIArgs)
{
log_msg("UberMephAI called.\n");
// Spawn Minions
if (active_UberMinions && RANDOM(100) < UberMephistoSpawnPercent && ptAIArgs->distanceToTarget < UberMephistoSpawnRadius)
{
Position pos;
D2GetPosition(ptAIArgs->target, &pos);
CastSummonMonster(ptGame, ptMonster, pos.x, pos.y, UberMephistoMinions, UberMephistoNbMinions, 8);
}
log_msg("Uber Mephisto AI activated.\n");
D2MephAI(ptGame, ptMonster, ptAIArgs);
}
void FASTCALL uberDiabloAI(Game* ptGame, Unit* ptMonster, AIParam* ptAIArgs)
{
log_msg("UberDiabloAI called.\n");
// Spawn Minions
if (active_UberMinions && RANDOM(100) < UberDiabloSpawnPercent && ptAIArgs->distanceToTarget < UberDiabloSpawnRadius)
{
Position pos;
D2GetPosition(ptAIArgs->target, &pos);
RandInCircle(&pos, 3);
CastSummonMonster(ptGame, ptMonster, pos.x, pos.y, UberDiabloMinions, UberDiabloNbMinions, 1);
}
// Tweek Diablo AI Rush
if (active_UberDiabloRushTweekAI && RANDOM(100) < (int)ptAIArgs->distanceToTarget - 10)
{
if (RANDOM(3) > 0)//67% to Rush
{
log_msg("Uber Diablo Run activated.\n");
int diabloRunSkillId = 4;
D2MonsterUseSkill(ptGame, ptMonster, ptAIArgs->ptMonStatsBIN->skillArg[diabloRunSkillId], ptAIArgs->ptMonStatsBIN->skill[diabloRunSkillId], ptAIArgs->target, 0, 0);
}
else
{
log_msg("Uber Diablo Move activated.\n");
Position pos;
D2GetPosition(ptAIArgs->target, &pos);
D2MonsterMove(ptGame, ptMonster, NULL, 2, pos.x, pos.y, 1, 0);
}
return;
}
log_msg("Uber Diablo AI activated.\n");
D2DiabloAI(ptGame, ptMonster, ptAIArgs);
}
void FASTCALL uberBaalAI(Game* ptGame, Unit* ptMonster, AIParam* ptAIArgs)
{
log_msg("UberBaalAI called.\n");
if (active_UberMinions && RANDOM(100) < UberBaalSpawnPercent && ptAIArgs->distanceToTarget < UberBaalSpawnRadius)
{
Position pos;
D2GetPosition(ptAIArgs->target, &pos);
RandInCircle(&pos, 3);
CastSummonMonster(ptGame, ptMonster, pos.x, pos.y, UberBaalMinions, UberBaalNbMinions, 1);
}
// Tweek Baal AI Chilling Armor
if (active_UberBaalChillingArmorTweekAI)
{
if (uberBaalChillingArmorLastFrame == 0 || ((int)ptGame->gameFrame - uberBaalChillingArmorLastFrame > uberBaalChillingArmorTimer))
{
log_msg("Uber Baal Chilling Armor activated.\n");
uberBaalChillingArmorLastFrame = ptGame->gameFrame;
const int baalChillingArmorSkillId = 7;
D2MonsterUseSkill(ptGame, ptMonster, ptAIArgs->ptMonStatsBIN->skillArg[baalChillingArmorSkillId], ptAIArgs->ptMonStatsBIN->skill[baalChillingArmorSkillId], NULL, 0, 0);
return;
}
}
// Tweek Baal AI Teleport
if (active_UberBaalTeleportTweekAI && RANDOM(100) < (int)ptAIArgs->distanceToTarget - 10)
{
if (RANDOM(3) > 0)//67% to teleport
{
log_msg("Uber Baal Teleport activated.\n");
const int baalTeleportSkillId = 4;
Position pos;
D2GetPosition(ptAIArgs->target, &pos);
D2MonsterUseSkill(ptGame, ptMonster, ptAIArgs->ptMonStatsBIN->skillArg[baalTeleportSkillId], ptAIArgs->ptMonStatsBIN->skill[baalTeleportSkillId], NULL/*ptAIArgs->target*/, pos.x, pos.y);
}
else
{
log_msg("Uber Baal Move activated.\n");
Position pos;
D2GetPosition(ptAIArgs->target, &pos);
D2MonsterMove(ptGame, ptMonster, NULL, 2, pos.x, pos.y, 1, 0);
}
return;
}
log_msg("Uber Baal AI activated.\n");
D2BaalAI(ptGame, ptMonster, ptAIArgs);
}
FCT_ASM ( caller_spawnUber )
PUSH EDX
PUSH ECX
CALL spawnUber
RETN
}}
void Install_UberQuest() void Install_UberQuest()
{ {
static int isInstalled = false; static int isInstalled = false;
@ -327,8 +469,8 @@ void Install_UberQuest()
DWORD oldProtection; DWORD oldProtection;
// open Red Portal // open Red Portal
VirtualProtect((LPVOID)R7(D2Game,0,0,0,FA480,FA7B8, FA228, FA5F0, FA2C4), 8, PAGE_EXECUTE_READWRITE, &oldProtection); VirtualProtect((LPVOID)R8(D2Game,0,0,0,FA480,FA7B8, FA228, FA5F0, FA2C4, 2E11D0), 8, PAGE_EXECUTE_READWRITE, &oldProtection);
mem_seek R7(D2Game, 0000, 0000, 0000, FA480, FA7B8, FA228, FA5F0, FA2C4); mem_seek R8(D2Game, 0000, 0000, 0000, FA480, FA7B8, FA228, FA5F0, FA2C4, 2E11D0);
MEMT_DWORD( D2OpenPandPortal , openPandPortal); MEMT_DWORD( D2OpenPandPortal , openPandPortal);
MEMT_DWORD( D2OpenPandFinalPortal , openPandFinalPortal); MEMT_DWORD( D2OpenPandFinalPortal , openPandFinalPortal);
//0201E357 |. FFD0 |CALL EAX //0201E357 |. FFD0 |CALL EAX
@ -336,69 +478,43 @@ void Install_UberQuest()
//6FCF3CC7 |. FFD0 |CALL EAX //6FCF3CC7 |. FFD0 |CALL EAX
//6FC92437 |. FFD0 |CALL EAX //6FC92437 |. FFD0 |CALL EAX
//6FCB7127 |. FFD0 |CALL EAX //6FCB7127 |. FFD0 |CALL EAX
VirtualProtect((LPVOID)R7(D2Game,0,0,0,FA480,FA7B8, FA228, FA5F0, FA2C4), 8, oldProtection, &oldProtection); //00565D45 . FFD0 CALL EAX
VirtualProtect((LPVOID)R8(D2Game,0,0,0,FA480,FA7B8, FA228, FA5F0, FA2C4, 2E11D0), 8, oldProtection, &oldProtection);
// manage uberIA (fct table at 0209E7E8) // manage uberIA (fct table at 0209E7E8)
VirtualProtect((LPVOID)(R7(D2Game,0,0,0,10E7E8,10ECD0,10EF58,10E788, 10ED00) + 145*0x10), 0x30, PAGE_EXECUTE_READWRITE, &oldProtection); VirtualProtect((LPVOID)(R8(D2Game,0,0,0,10E7E8,10ECD0,10EF58,10E788, 10ED00, 33CA18) + 145*0x10), 0x30, PAGE_EXECUTE_READWRITE, &oldProtection);
mem_seek R7(D2Game, 0000, 0000, 0000, 10F100, 10F5E8, 10F870, 10F0A0, 10F618); mem_seek R8(D2Game, 0000, 0000, 0000, 10F100, 10F5E8, 10F870, 10F0A0, 10F618, 33D330);
MEMT_DWORD( D2UberBaalIA , uberBaalIA); MEMT_DWORD( D2UberBaalAI , uberBaalAI);
mem_seek R7(D2Game, 0000, 0000, 0000, 10F110, 10F5F8, 10F880, 10F0B0, 10F628); mem_seek R8(D2Game, 0000, 0000, 0000, 10F110, 10F5F8, 10F880, 10F0B0, 10F628, 33D340);
MEMT_DWORD( D2UberMephIA , uberMephIA); MEMT_DWORD( D2UberMephAI , uberMephAI);
mem_seek R7(D2Game, 0000, 0000, 0000, 10F120, 10F608, 10F890, 10F0C0, 10F638); mem_seek R8(D2Game, 0000, 0000, 0000, 10F120, 10F608, 10F890, 10F0C0, 10F638, 33D350);
MEMT_DWORD( D2UberDiabloIA , uberDiabloIA); MEMT_DWORD( D2UberDiabloAI , uberDiabloAI);
VirtualProtect((LPVOID)(R7(D2Game,0,0,0,10E7E8,10ECD0,10EF58,10E788, 10ED00) + 145*0x10), 0x30, oldProtection, &oldProtection); VirtualProtect((LPVOID)(R8(D2Game,0,0,0,10E7E8,10ECD0,10EF58,10E788, 10ED00, 33CA18) + 145*0x10), 0x30, oldProtection, &oldProtection);
//0202ADA7 |> B8 E8E70902 MOV EAX,D2Game.0209E7E8 //0202ADA7 |> B8 E8E70902 MOV EAX,D2Game.0209E7E8
//01FD2BE7 |> B8 D0EC0702 MOV EAX,D2Game.0207ECD0 //01FD2BE7 |> B8 D0EC0702 MOV EAX,D2Game.0207ECD0
//6FC3B597 |> B8 58EFD26F MOV EAX,D2Game.6FD2EF58 //6FC3B597 |> B8 58EFD26F MOV EAX,D2Game.6FD2EF58
//6FCBD157 |> B8 88E7D26F MOV EAX,D2Game.6FD2E788 //6FCBD157 |> B8 88E7D26F MOV EAX,D2Game.6FD2E788
//6FC5C617 |> B8 00EDD26F MOV EAX,D2Game.6FD2ED00 //6FC5C617 |> B8 00EDD26F MOV EAX,D2Game.6FD2ED00
//005B163D |. B8 18CA7300 MOV EAX,Game.0073CA18
// spawn Uber // spawn Uber
// mem_seek R7(D2Game, 0000, 0000, 0000, 98DAD, 0000, 0000, 0000); // mem_seek R7(D2Game, 0000, 0000, 0000, 98DAD, 0000, 0000, 0000);
// MEMJ_REF4( D2WarpPlayer , spawnUber); // MEMJ_REF4( D2WarpPlayer , spawnUber);
//02028DAC |. E8 491CF7FF CALL <JMP.&D2Common.#10872> //02028DAC |. E8 491CF7FF CALL <JMP.&D2Common.#10872>
mem_seek R7(D2Game, 0000, 0000, 0000, E26E2, E6B52, A850B, 2CCAB, BE9AB); mem_seek R8(D2Game, 0000, 0000, 0000, E26E2, E6B52, A850B, 2CCAB, BE9AB, 12D1DC);
MEMC_REF4( D2Game235C0 , spawnUber); MEMC_REF4( V2Game235C0 , version_D2Game >= V114d ? (DWORD)caller_spawnUber : (DWORD)spawnUber);
//020726E1 |. E8 2A46FFFF ||CALL D2Game.02066D10 //020726E1 |. E8 2A46FFFF ||CALL D2Game.02066D10
//02056B51 |. E8 6ACAF3FF ||CALL D2Game.01F935C0 //02056B51 |. E8 6ACAF3FF ||CALL D2Game.01F935C0
//6FCC850A |. E8 014FF6FF ||CALL D2Game.6FC2D410 //6FCC850A |. E8 014FF6FF ||CALL D2Game.6FC2D410
//6FC4CCAA |. E8 3134FFFF ||CALL D2Game.6FC400E0 //6FC4CCAA |. E8 3134FFFF ||CALL D2Game.6FC400E0
//6FCDE9AA |. E8 D1AFF9FF ||CALL D2Game.6FC79980 //6FCDE9AA |. E8 D1AFF9FF ||CALL D2Game.6FC79980
//0052D1DB |. E8 60590100 ||CALL Game.00542B40
log_msg("\n"); log_msg("\n");
isInstalled = true; isInstalled = true;
} }
/*
call fct to manage TP :
0201E33E |. 8B048D 78A4070>|MOV EAX,DWORD PTR DS:[ECX*4+207A478] ; D2Game.0201B480
0201E345 |. 85C0 |TEST EAX,EAX
0201E347 |. 74 14 |JE SHORT D2Game.0201E35D
0201E349 |. 8B9424 2C01000>|MOV EDX,DWORD PTR SS:[ESP+12C]
0201E350 |. 8B8C24 2801000>|MOV ECX,DWORD PTR SS:[ESP+128]
0201E357 |. FFD0 |CALL EAX
0201E359 |. 894424 38 |MOV DWORD PTR SS:[ESP+38],EAX
DWORD FASTCALL openPortal (Unit* ptGame, Unit* ptChar)
0201C6D0 : CowPortal
0201B480 : Pand. Portal return 0 !!
0201B470 : Pand. FInal Portal
manage IA
0202AD8B |> 66:8B46 1E MOV AX,WORD PTR DS:[ESI+1E]
0202AD8F |. 66:85C0 TEST AX,AX
0202AD92 |. 7C 13 JL SHORT D2Game.0202ADA7
0202AD94 |. 66:3D 9400 CMP AX,94
0202AD98 |. 73 0D JNB SHORT D2Game.0202ADA7
0202AD9A |. 0FBFC0 MOVSX EAX,AX
0202AD9D |. C1E0 04 SHL EAX,4
0202ADA0 |. 05 E8E70902 ADD EAX,D2Game.0209E7E8
0202ADA5 |. 5E POP ESI
0202ADA6 |. C3 RETN
0202ADA7 |> B8 E8E70902 MOV EAX,D2Game.0209E7E8
0202ADAC |. 5E POP ESI
0202ADAD \. C3 RETN
*/
/*================================= END OF FILE =================================*/ /*================================= END OF FILE =================================*/

27
PlugY/UpdateClient.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Updating client. Updating client.
@ -43,10 +44,10 @@ void updateClient(Unit* ptChar, DWORD mFunc, char* msg)
packet.mFunc = (BYTE)mFunc; packet.mFunc = (BYTE)mFunc;
packet.mSize = sizeof(DataPacket); packet.mSize = sizeof(DataPacket);
packet.mPlayerID = ptChar->nUnitId; packet.mPlayerID = ptChar->nUnitId;
if (msg != NULL && strlen(msg) >= 20) if (msg != NULL && strlen(msg) > 20)
return; return;
if (msg != NULL) if (msg != NULL)
strcpy((char*)&packet.mItemID, msg); strncpy((char*)&packet.mItemID, msg, 20);
ptNetClient = D2GetClient(ptChar, __FILE__, __LINE__); ptNetClient = D2GetClient(ptChar, __FILE__, __LINE__);
@ -59,13 +60,26 @@ 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); log_msg("[CLIENT] Received custom message: %d with param: %08X , %08X , %08X\n",packet->mFunc,packet->mParam1,packet->mParam2,packet->mParam3);
switch (packet->mFunc) switch (packet->mFunc)
{ {
case UC_SELECT_STASH: setSelectedStashClient(packet->mParam1, packet->mParam2, packet->mParam3, (packet->mParam2 & 4) == 4); return 1; case UC_SELECT_STASH: setSelectedStashClient(packet->mParam1, packet->mParam2, packet->mParam3, (packet->mParam2 & 8) == 8); return 1;
case UC_SHARED_GOLD : updateSharedGold(packet->mParam1); return 1; case UC_SHARED_GOLD : updateSharedGold(packet->mParam1); return 1;
case UC_PAGE_NAME: renameCurrentStash(D2GetClientPlayer(), (char*)&packet->mItemID); return 1; case UC_PAGE_NAME:
{
char pageName[21];
strncpy(pageName, (char*)&packet->mItemID, 20);
pageName[20] = NULL;
renameCurrentStash(D2GetClientPlayer(), pageName); return 1;
}
default : return 0; default : return 0;
} }
} }
FCT_ASM ( caller_handleClientUpdate_114 )
LEA ECX,DWORD PTR SS:[ESP]
CALL handleClientUpdate
MOV ESP,EBP
POP EBP
RETN
}}
FCT_ASM ( caller_handleClientUpdate_111 ) FCT_ASM ( caller_handleClientUpdate_111 )
LEA ECX,DWORD PTR SS:[ESP+8] LEA ECX,DWORD PTR SS:[ESP+8]
@ -93,14 +107,15 @@ void Install_UpdateClient()
log_msg("Patch D2Client for received Item packet. (UpdateClient)\n"); log_msg("Patch D2Client for received Item packet. (UpdateClient)\n");
// execute if it's our packet else continue // execute if it's our packet else continue
mem_seek R7(D2Client, 14236, 14226, 145B6, 9C6B6, BFE86, 66E06, AE896, 84D96); mem_seek R8(D2Client, 14236, 14226, 145B6, 9C6B6, BFE86, 66E06, AE896, 84D96, 5EC99);
MEMT_REF4( version_D2Client >= V111 ? 0x000000CF : 0x000000D6, version_D2Client >= V111 ? caller_handleClientUpdate_111 : caller_handleClientUpdate); MEMT_REF4( version_D2Client >= V114d ? 0x000000CE : version_D2Client >= V111 ? 0x000000CF : 0x000000D6, version_D2Client >= V114d ? caller_handleClientUpdate_114 : version_D2Client >= V111 ? caller_handleClientUpdate_111 : caller_handleClientUpdate);
//6FAB45B4 |. 0F87 D6000000 JA D2Client.6FAB4690 //6FAB45B4 |. 0F87 D6000000 JA D2Client.6FAB4690
//6FB4C6B4 |. 0F87 CF000000 JA D2Client.6FB4C789 //6FB4C6B4 |. 0F87 CF000000 JA D2Client.6FB4C789
//6FB6FE84 |. 0F87 CF000000 JA D2Client.6FB6FF59 //6FB6FE84 |. 0F87 CF000000 JA D2Client.6FB6FF59
//6FB16E04 |. 0F87 CF000000 JA D2Client.6FB16ED9 //6FB16E04 |. 0F87 CF000000 JA D2Client.6FB16ED9
//6FB5E894 |. 0F87 CF000000 JA D2Client.6FB5E969 //6FB5E894 |. 0F87 CF000000 JA D2Client.6FB5E969
//6FB34D94 |. 0F87 CF000000 JA D2Client.6FB34E69 //6FB34D94 |. 0F87 CF000000 JA D2Client.6FB34E69
//0045EC97 |. 0F87 CE000000 JA Game.0045ED6B
log_msg("\n"); log_msg("\n");

67
PlugY/UpdateServer.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
Updating server. Updating server.
@ -13,8 +14,16 @@
#include "commands.h" #include "commands.h"
#include "common.h" #include "common.h"
void updateServer(WORD p)
{
if (!onRealm)
D2SendToServer3(0x3A, p);
}
int renameIndex = 0; int renameIndex = 0;
char renameString[16]; char renameString[21];
DWORD PageSwap; DWORD PageSwap;
int STDCALL handleServerUpdate(Unit* ptChar, WORD param) int STDCALL handleServerUpdate(Unit* ptChar, WORD param)
@ -34,8 +43,9 @@ int STDCALL handleServerUpdate(Unit* ptChar, WORD param)
case US_UNASSIGN_VIT_POINTS : UnassignVitPoints( ptChar ); return 1; case US_UNASSIGN_VIT_POINTS : UnassignVitPoints( ptChar ); return 1;
case US_UNASSIGN_SKILLS : UnassignAllSkillsPoints( ptChar ); return 1; case US_UNASSIGN_SKILLS : UnassignAllSkillsPoints( ptChar ); return 1;
case US_SET_INDEX: setCurrentStashIndex(ptChar, true); return 1; case US_SET_INDEX: setCurrentStashIndex(ptChar, 1); return 1;
case US_RESET_INDEX: setCurrentStashIndex(ptChar, false); return 1; case US_SET_MAIN_INDEX: setCurrentStashIndex(ptChar, 2); return 1;
case US_RESET_INDEX: setCurrentStashIndex(ptChar, 0); return 1;
case US_SELECT_PREVIOUS : selectPreviousStash( ptChar ); return 1; case US_SELECT_PREVIOUS : selectPreviousStash( ptChar ); return 1;
case US_SELECT_NEXT : selectNextStash( 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_SELF : if (active_sharedStash) toggleToSelfStash( ptChar ); return 1;
@ -46,8 +56,8 @@ int STDCALL handleServerUpdate(Unit* ptChar, WORD param)
case US_SELECT_NEXT2 : selectNext2Stash( ptChar ); return 1; case US_SELECT_NEXT2 : selectNext2Stash( ptChar ); return 1;
case US_SELECT_PREVIOUS_INDEX2: selectPreviousIndex2Stash( ptChar ); return 1; case US_SELECT_PREVIOUS_INDEX2: selectPreviousIndex2Stash( ptChar ); return 1;
case US_SELECT_NEXT_INDEX2 : selectNextIndex2Stash( ptChar ); return 1; case US_SELECT_NEXT_INDEX2 : selectNextIndex2Stash( ptChar ); return 1;
case US_INSERT_PAGE: insertStash(ptChar); return 1; case US_INSERT_PAGE: insertStash(ptChar); selectNextStash(ptChar); return 1;
case US_DELETE_PAGE: deleteStash(ptChar); return 1; case US_DELETE_PAGE: deleteStash(ptChar, false); return 1;
case US_SAVE : savePlayers( ptChar ); return 1; case US_SAVE : savePlayers( ptChar ); return 1;
@ -61,24 +71,26 @@ int STDCALL handleServerUpdate(Unit* ptChar, WORD param)
case US_SWAP0_TOGGLE : swapStash(ptChar, PageSwap | arg, true); PageSwap = 0; return 1; case US_SWAP0_TOGGLE : swapStash(ptChar, PageSwap | arg, true); PageSwap = 0; return 1;
case US_RENAME : case US_RENAME :
if (renameIndex == 0) if (renameIndex == 0)
for (int i = 0; i < 16; i++) ZeroMemory(renameString, sizeof(renameString));
renameString[i] = 0; if (arg != NULL && renameIndex < 15)
renameString[renameIndex++] = (char)arg; renameString[renameIndex++] = (char)arg;
if (arg == 0) if (arg == NULL)
{ {
renameString[renameIndex] = NULL;
renameIndex = 0; renameIndex = 0;
log_msg("Rename on Server : %s -> %s\n", ptChar->ptPlayerData->name, renameString); log_msg("Rename on Server : %s -> %s\n", PCPlayerData->name, renameString);
strcpy(ptChar->ptPlayerData->name, renameString); strcpy(PCPlayerData->name, renameString);
strcpy(ptChar->ptPlayerData->ptNetClient->name, renameString); strcpy(PCPlayerData->ptNetClient->name, renameString);
} }
return 1; return 1;
case US_PAGENAME: case US_PAGENAME:
if (renameIndex == 0) if (renameIndex == 0)
for (int i = 0; i < 16; i++) ZeroMemory(renameString, sizeof(renameString));
renameString[i] = 0; if (arg != NULL && renameIndex < 20)
renameString[renameIndex++] = (char)arg; renameString[renameIndex++] = (char)arg;
if (arg == 0) if (arg == NULL)
{ {
renameString[renameIndex] = NULL;
renameIndex = 0; renameIndex = 0;
log_msg("Rename current page on Server : %s -> %s\n", PCPY->currentStash->name, renameString); log_msg("Rename current page on Server : %s -> %s\n", PCPY->currentStash->name, renameString);
renameCurrentStash(ptChar, renameString); renameCurrentStash(ptChar, renameString);
@ -89,6 +101,26 @@ int STDCALL handleServerUpdate(Unit* ptChar, WORD param)
} }
} }
FCT_ASM( caller_handleServerUpdate_114)
PUSH ESI
PUSH EBX
CALL handleServerUpdate
TEST EAX,EAX
JNZ END_RCM
MOV EAX,ESI
AND EAX,0xFF
SHR ESI,8
MOV EDI,EAX
RETN
END_RCM:
ADD ESP,8
POP EDI
POP ESI
XOR EAX,EAX
POP EBX
RETN 8
}}
FCT_ASM( caller_handleServerUpdate) FCT_ASM( caller_handleServerUpdate)
PUSH ESI PUSH ESI
PUSH EBX PUSH EBX
@ -138,11 +170,11 @@ void Install_UpdateServer()
log_msg("Patch D2Game for received button click message. (UpdateServer)\n"); log_msg("Patch D2Game for received button click message. (UpdateServer)\n");
// manage button click message from Client. // manage button click message from Client.
mem_seek R7(D2Game, 4A702, 4AAC2, 56EA2, 54AE3, 2C773, 975C3, CC983, 676C3); mem_seek R8(D2Game, 4A702, 4AAC2, 56EA2, 54AE3, 2C773, 975C3, CC983, 676C3, 14BD38);
if (version_D2Game >= V111) { if (version_D2Game >= V111) {
memt_byte( 0xC1, 0x57 ); // PUSH EDI memt_byte( 0xC1, 0x57 ); // PUSH EDI
memt_byte( 0xEE, 0xE8 ); // CALL caller_handleServerUpdate memt_byte( 0xEE, 0xE8 ); // CALL caller_handleServerUpdate
MEMT_REF4( 0xF88B5708, caller_handleServerUpdate); MEMT_REF4( 0xF88B5708, version_D2Game == V114d ? caller_handleServerUpdate_114 : caller_handleServerUpdate);
//01FD4AE3 . C1EE 08 SHR ESI,8 //01FD4AE3 . C1EE 08 SHR ESI,8
//01FD4AE6 . 57 PUSH EDI //01FD4AE6 . 57 PUSH EDI
//01FD4AE7 . 8BF8 MOV EDI,EAX //01FD4AE7 . 8BF8 MOV EDI,EAX
@ -158,6 +190,9 @@ void Install_UpdateServer()
//066A76C3 |. C1EE 08 SHR ESI,8 //066A76C3 |. C1EE 08 SHR ESI,8
//066A76C6 |. 57 PUSH EDI //066A76C6 |. 57 PUSH EDI
//066A76C7 |. 8BF8 MOV EDI,EAX //066A76C7 |. 8BF8 MOV EDI,EAX
//0054BD38 |. C1EE 08 SHR ESI,8
//0054BD3B |. 57 PUSH EDI
//0054BD3C |. 8BF8 MOV EDI,EAX
} else if (version_D2Game == V110) { } else if (version_D2Game == V110) {
memt_byte( 0xC1, 0xE8 ); // CALL caller_handleServerUpdate memt_byte( 0xC1, 0xE8 ); // CALL caller_handleServerUpdate
MEMT_REF4( 0xF88B08EE, caller_handleServerUpdate); MEMT_REF4( 0xF88B08EE, caller_handleServerUpdate);

18
PlugY/Windowed.cpp
View File

@ -8,17 +8,17 @@
#include "windowed.h" #include "windowed.h"
#include "common.h" #include "common.h"
int active_Windowed = true; int active_Windowed = false;
int setWindowedOptionsDone = false; int setWindowedOptionsDone = false;
int active_RemoveBorder = true; int active_RemoveBorder = false;
int active_WindowOnTop = true; int active_WindowOnTop = false;
int active_Maximized = true; int active_Maximized = false;
int active_SetWindowPos = true; int active_SetWindowPos = false;
int windowedX = 240; int windowedX = 0;
int windowedY = 0; int windowedY = 0;
int windowedWidth = 1440; int windowedWidth = 800;
int windowedHeight = 1080; int windowedHeight = 600;
int active_LockMouseOnStartup = true; int active_LockMouseOnStartup = false;
void unlockMouseCursor() void unlockMouseCursor()
{ {

75
PlugY/WorldEvent.cpp
View File

@ -1,6 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
World Event Management. World Event Management.
@ -27,7 +28,7 @@ DWORD WEactive = 0;
DWORD DCloneSpawned = 0; DWORD DCloneSpawned = 0;
DWORD nbSOJSold = 0; DWORD nbSOJSold = 0;
DWORD nbNeedSOJSold = 100; DWORD nbNeedSOJSold = 0;
DWORD nbManagedSOJSold = 0; DWORD nbManagedSOJSold = 0;
DWORD nbTicksForNextSOJSold = 0; DWORD nbTicksForNextSOJSold = 0;
@ -79,21 +80,26 @@ Game* STDCALL WEManagement(DWORD clientID)
if (!ptGame) return ptGame; if (!ptGame) return ptGame;
if (active_AutomaticSell) if (active_AutomaticSell)
{
while (GetTickCount() - prevTicks >= nbTicksForNextSOJSold) while (GetTickCount() - prevTicks >= nbTicksForNextSOJSold)
{ {
nbSOJSold++; nbSOJSold++;
prevTicks = prevTicks + nbTicksForNextSOJSold; prevTicks = prevTicks + nbTicksForNextSOJSold;
nbTicksForNextSOJSold = getTicksForNextSOJSold(); nbTicksForNextSOJSold = getTicksForNextSOJSold();
} }
}
if (nbSOJSold == nbManagedSOJSold) return ptGame; if (nbSOJSold == nbManagedSOJSold)
return ptGame;
DWORD newWE; DWORD newWE;
if (!WEactive && (ptGame->difficultyLevel == D2DM_HELL) && (nbSOJSold >= nbNeedSOJSold)) if (!WEactive && (ptGame->difficultyLevel == D2DM_HELL) && (nbSOJSold >= nbNeedSOJSold))
{ {
newWE = 1; newWE = 1;
WEactive = 1; WEactive = 1;
} else newWE = 0; }
else
newWE = 0;
if ( showSOJSoldCounterInAllDiff || (ptGame->difficultyLevel == D2DM_HELL)) if ( showSOJSoldCounterInAllDiff || (ptGame->difficultyLevel == D2DM_HELL))
worldEventBroadcast(ptGame, newWE, nbSOJSold); worldEventBroadcast(ptGame, newWE, nbSOJSold);
@ -108,10 +114,11 @@ DWORD FASTCALL spawnDClone(Game* ptGame, Room* ptRoom, DWORD p3, DWORD p4, DWORD
if (WEactive && (ptGame->difficultyLevel == D2DM_HELL) && !DCloneSpawned) if (WEactive && (ptGame->difficultyLevel == D2DM_HELL) && !DCloneSpawned)
{ {
DCloneSpawned=1; DCloneSpawned=1;
D2SpawnMonster(ptGame,ptRoom,p3,p4,p5,p6,worldEventmonsterID,p8); D2SpawnSuperUnique(ptGame,ptRoom,p3,p4,p5,p6,worldEventmonsterID,p8);
return 0;//no minions return 0;//no minions
} }
else return D2SpawnMonster(ptGame,ptRoom,p3,p4,p5,p6,monsterID,p8); else
return D2SpawnSuperUnique(ptGame,ptRoom,p3,p4,p5,p6,monsterID,p8);
} }
DWORD STDCALL verifIfWEItem (Unit* ptItem, DWORD flags, DWORD line, const char* filename) DWORD STDCALL verifIfWEItem (Unit* ptItem, DWORD flags, DWORD line, const char* filename)
@ -133,8 +140,8 @@ DWORD STDCALL verifIfWEItem (Unit* ptItem, DWORD flags, DWORD line, const char*
if(!(itemNeeded.isSpecificItem && (D2GetUniqueID(ptItem) != itemNeeded.specificID-1)) if(!(itemNeeded.isSpecificItem && (D2GetUniqueID(ptItem) != itemNeeded.specificID-1))
&& !(itemNeeded.haveNoSocket && (D2GetPlayerStat(ptItem, STATS_ITEM_NUMSOCKETS, 0) > 0)) && !(itemNeeded.haveNoSocket && (D2GetPlayerStat(ptItem, STATS_ITEM_NUMSOCKETS, 0) > 0))
&& !(itemNeeded.haveSockets && (D2GetPlayerStat(ptItem, STATS_ITEM_NUMSOCKETS, 0) == 0)) && !(itemNeeded.haveSockets && (D2GetPlayerStat(ptItem, STATS_ITEM_NUMSOCKETS, 0) == 0))
&& !(itemNeeded.isNotEthereal && D2isEtheral(ptItem)) && !(itemNeeded.isNotEthereal && ptItem->ptItemData->isEtheral)
&& !(itemNeeded.isEthereal && !D2isEtheral(ptItem)) && !(itemNeeded.isEthereal && !ptItem->ptItemData->isEtheral)
&& !(itemNeeded.isBasic && (ptItemStats->ItemCode != ptWantedItemStats->NormCode)) && !(itemNeeded.isBasic && (ptItemStats->ItemCode != ptWantedItemStats->NormCode))
&& !(itemNeeded.isExceptional && (ptItemStats->ItemCode != ptWantedItemStats->UberCode)) && !(itemNeeded.isExceptional && (ptItemStats->ItemCode != ptWantedItemStats->UberCode))
&& !(itemNeeded.isElite && (ptItemStats->ItemCode != ptWantedItemStats->HellCode)) && !(itemNeeded.isElite && (ptItemStats->ItemCode != ptWantedItemStats->HellCode))
@ -160,9 +167,16 @@ void initWorldEventVariables()
WEactive = 0; WEactive = 0;
while (nbSOJSold >= nbNeedSOJSold) while (nbSOJSold >= nbNeedSOJSold)
nbNeedSOJSold += (DWORD)(rand()/(RAND_MAX+1.0)*triggerAtSolJSoldDelta+triggerAtSolJSoldMin); nbNeedSOJSold += (DWORD)(rand()/(RAND_MAX+1.0)*triggerAtSolJSoldDelta + triggerAtSolJSoldMin);
log_msg("initWorldEventVariables - nbSOJSold = %d, nbNeedSOJSold = %d\n", nbSOJSold, nbNeedSOJSold);
} }
FCT_ASM ( caller_WEManagement_114 )
PUSH ECX
CALL WEManagement
RETN
}}
FCT_ASM ( caller_WEManagement_1XX ) FCT_ASM ( caller_WEManagement_1XX )
POP EAX POP EAX
@ -197,6 +211,30 @@ FCT_ASM ( caller_spawnDClone_111b )
RETN 0x14 RETN 0x14
}} }}
FCT_ASM( caller_spawnDClone_114 )
PUSH EBX
PUSH ECX
PUSH EDX
PUSH EDI
PUSH ESI
PUSH 0
PUSH EBX
PUSH 0xFFFFFFFF
PUSH DWORD PTR SS : [ESP + 0x30]
PUSH DWORD PTR SS : [ESP + 0x30]
PUSH DWORD PTR SS : [ESP + 0x30]
MOV ECX, EDI
MOV EDX, EAX
CALL spawnDClone
POP ESI
POP EDI
POP EDX
POP ECX
POP EBX
RETN 0x18
}}
FCT_ASM( caller_addClientForWE_111 ) FCT_ASM( caller_addClientForWE_111 )
PUSH EAX PUSH EAX
CALL initWorldEventVariables CALL initWorldEventVariables
@ -221,7 +259,7 @@ void Install_WorldEvent()
if ( version_D2Game < V110 ) if ( version_D2Game < V110 )
return; return;
nbSOJSold = (DWORD)(rand()/(RAND_MAX+1.0)*valueInitSOJSoldDelta+valueInitSOJSoldMin); nbSOJSold = (DWORD)(rand()/(RAND_MAX+1.0)*valueInitSOJSoldDelta + valueInitSOJSoldMin);
if (active_AutomaticSell) if (active_AutomaticSell)
{ {
prevTicks = GetTickCount(); prevTicks = GetTickCount();
@ -231,17 +269,18 @@ void Install_WorldEvent()
log_msg("Patch D2Game for active World Event. (WorldEvent)\n"); log_msg("Patch D2Game for active World Event. (WorldEvent)\n");
// spawn DClone // spawn DClone
mem_seek R7(D2Game, 0000, 0000, 3F720, 4BCB1, ECF10, 41570, 25280, CFBD0); mem_seek R8(D2Game, 0000, 0000, 3F720, 4BCB1, ECF10, 41570, 25280, CFBD0, 1A4A4F);
MEMC_REF4( V2SpawnMonster , version_D2Game >= V111b ? (DWORD)caller_spawnDClone_111b : version_D2Game == V111 ? (DWORD)caller_spawnDClone_111 : (DWORD)spawnDClone); MEMC_REF4( V2SpawnSuperUnique , version_D2Game >= V114a ? (DWORD)caller_spawnDClone_114 : version_D2Game >= V111b ? (DWORD)caller_spawnDClone_111b : version_D2Game == V111 ? (DWORD)caller_spawnDClone_111 : (DWORD)spawnDClone);
//6FC6F71F |. E8 FCFAFFFF CALL D2Game.6FC6F220 //6FC6F71F |. E8 FCFAFFFF CALL D2Game.6FC6F220
//01FCBCB0 |. E8 2BEFFFFF CALL D2Game.01FCABE0 ; \D2Game.01FCABE0 //01FCBCB0 |. E8 2BEFFFFF CALL D2Game.01FCABE0 ; \D2Game.01FCABE0
//0205CF0F |. E8 CCF8FFFF CALL D2Game.0205C7E0 ; \D2Game.0205C7E0 //0205CF0F |. E8 CCF8FFFF CALL D2Game.0205C7E0 ; \D2Game.0205C7E0
//6FC6156F |. E8 1CF6FFFF CALL D2Game.6FC60B90 ; \D2Game.6FC60B90 //6FC6156F |. E8 1CF6FFFF CALL D2Game.6FC60B90 ; \D2Game.6FC60B90
//6FC4527F |. E8 CCF6FFFF CALL D2Game.6FC44950 ; \D2Game.6FC44950 //6FC4527F |. E8 CCF6FFFF CALL D2Game.6FC44950 ; \D2Game.6FC44950
//6FCEFBCF |. E8 4CE2FFFF CALL D2Game.6FCEDE20 ; \D2Game.6FCEDE20 //6FCEFBCF |. E8 4CE2FFFF CALL D2Game.6FCEDE20 ; \D2Game.6FCEDE20
//005A4A4E |. E8 8DBFFFFF CALL Game.005A09E0 ; \Game.005A09E0
// verify if the item sold is a trigger of WE // verify if the item sold is a trigger of WE
mem_seek R7(D2Game, 0000, 0000, 977D0, 8E799, 92859, 84499, BFB29, 72BE9); mem_seek R8(D2Game, 0000, 0000, 977D0, 8E799, 92859, 84499, BFB29, 72BE9, 179667);
MEMJ_REF4( D2TestFlags , verifIfWEItem); MEMJ_REF4( D2TestFlags , verifIfWEItem);
//6FCC77CF |. E8 32400500 CALL <JMP.&D2Common.#10707> //6FCC77CF |. E8 32400500 CALL <JMP.&D2Common.#10707>
//0200E798 |. E8 E9BDF7FF CALL <JMP.&D2Common.#10911> //0200E798 |. E8 E9BDF7FF CALL <JMP.&D2Common.#10911>
@ -249,26 +288,30 @@ void Install_WorldEvent()
//6FCA4498 |. E8 3B62F8FF CALL <JMP.&D2Common.#10989> //6FCA4498 |. E8 3B62F8FF CALL <JMP.&D2Common.#10989>
//6FCDFB28 |. E8 77ADF4FF CALL <JMP.&D2Common.#10202> //6FCDFB28 |. E8 77ADF4FF CALL <JMP.&D2Common.#10202>
//6FC92BE8 |. E8 DD7AF9FF CALL <JMP.&D2Common.#10458> //6FC92BE8 |. E8 DD7AF9FF CALL <JMP.&D2Common.#10458>
//00579666 |. E8 35EA0A00 CALL Game.006280A0 ; \Game.006280A0
// management of the WorldEvent // management of the WorldEvent
mem_seek R7(D2Game, 0000, 0000, 3CE0, 51F01, C5681, EBF41, 4A791, E5F51); mem_seek R8(D2Game, 0000, 0000, 3CE0, 51F01, C5681, EBF41, 4A791, E5F51, 12FEED);
MEMC_REF4( V2GetGameByClientID , version_D2Game >= V111 ? (DWORD)WEManagement : (DWORD)caller_WEManagement_1XX); MEMC_REF4( V2GetGameByClientID , version_D2Game >= V114a ? (DWORD)caller_WEManagement_114 : version_D2Game >= V111 ? (DWORD)WEManagement : (DWORD)caller_WEManagement_1XX);
//6FC33CDF . E8 FC570000 CALL D2Game.6FC394E0 //6FC33CDF . E8 FC570000 CALL D2Game.6FC394E0
//01FD1F00 |. E8 1BE60800 CALL D2Game.02060520 //01FD1F00 |. E8 1BE60800 CALL D2Game.02060520
//02035680 |. E8 1BF30100 CALL D2Game.020549A0 //02035680 |. E8 1BF30100 CALL D2Game.020549A0
//6FD0BF40 |. E8 1BA4FBFF CALL D2Game.6FCC6360 //6FD0BF40 |. E8 1BA4FBFF CALL D2Game.6FCC6360
//6FC6A790 |. E8 4B03FEFF CALL D2Game.6FC4AAE0 //6FC6A790 |. E8 4B03FEFF CALL D2Game.6FC4AAE0
//6FD05F50 |. E8 AB67FDFF CALL D2Game.6FCDC700 //6FD05F50 |. E8 AB67FDFF CALL D2Game.6FCDC700
//0052FEEC |. E8 6FE9FFFF CALL Game.0052E860
//to check : 005389B0 |. E8 2B75FFFF CALL Game.0052FEE0
// add client for the WorldEvent // add client for the WorldEvent
mem_seek R7(D2Game, 0000, 0000, 1AEF, 3786A, 7055A, 6265F, CB0BF, D556F); mem_seek R8(D2Game, 0000, 0000, 1AEF, 3786A, 7055A, 6265F, CB0BF, D556F, 13F2D2);
MEMC_REF4( D2AddClient , version_D2Game >= V111 ? caller_addClientForWE_111 : caller_addClientForWE); MEMC_REF4( D2AddClient , version_D2Game >= V111 && version_D2Game <= V113d ? caller_addClientForWE_111 : caller_addClientForWE);
//6FC31AEE |. E8 6D510000 CALL D2Game.6FC36C60 //6FC31AEE |. E8 6D510000 CALL D2Game.6FC36C60
//01FB7869 |. E8 32C50A00 CALL D2Game.02063DA0 //01FB7869 |. E8 32C50A00 CALL D2Game.02063DA0
//01FE0559 |. E8 B27C0700 CALL D2Game.02058210 //01FE0559 |. E8 B27C0700 CALL D2Game.02058210
//6FC8265E |. E8 FD890800 CALL D2Game.6FD0B060 //6FC8265E |. E8 FD890800 CALL D2Game.6FD0B060
//6FCEB0BE |. E8 6DE8F7FF CALL D2Game.6FC69930 //6FCEB0BE |. E8 6DE8F7FF CALL D2Game.6FC69930
//6FCF556E |. E8 FDFA0000 CALL D2Game.6FD05070 //6FCF556E |. E8 FDFA0000 CALL D2Game.6FD05070
//0053F2D1 |. E8 7AD2FEFF CALL Game.0052C550
log_msg("\n"); log_msg("\n");

3
PlugY/common.h
View File

@ -2,9 +2,6 @@
File created by Yohann NICOLAS. 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.
/*============================================*/ /*============================================*/
#pragma once #pragma once

28
PlugY/d2functions.h
View File

@ -1,6 +1,7 @@
/*================================================ /*================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
Add support 1.14d by haxifix.
This file implements some common and useful This file implements some common and useful
function related to some Diablo II mechanisms. function related to some Diablo II mechanisms.
@ -29,6 +30,7 @@ extern s_shifting shifting;
#define STDCALL __stdcall #define STDCALL __stdcall
#define FCT_ASM(N) __declspec(naked) void N() {__asm{ #define FCT_ASM(N) __declspec(naked) void N() {__asm{
#define RANDOM(V) ((int)(rand()/(RAND_MAX+1.0)*(V))) #define RANDOM(V) ((int)(rand()/(RAND_MAX+1.0)*(V)))
#define RANDOMF() ((double)rand() / (double)RAND_MAX)
//#define RANDOM(V) (rand()%(V)) //#define RANDOM(V) (rand()%(V))
//#define PY(C) (*(PYPlayerData**)((BYTE*)(ptChar)+shifting.ptPYPlayerData)) //#define PY(C) (*(PYPlayerData**)((BYTE*)(ptChar)+shifting.ptPYPlayerData))
@ -41,8 +43,8 @@ extern s_shifting shifting;
#define PCPY ((PYPlayerData*)((DWORD)PCPlayerData+shifting.ptPYPlayerData)) //->ptPYPlayerData #define PCPY ((PYPlayerData*)((DWORD)PCPlayerData+shifting.ptPYPlayerData)) //->ptPYPlayerData
#define PCSkills (*(Skills**)((DWORD)(ptChar)+shifting.ptSkills)) //->ptSkills #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 R8(Z,A,B,C,D,E,F,G,H,I) (offset_##Z + (version_##Z == V114d? 0x##I : (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 V8(Z,A,B,C,D,E,F,G,H,I) (version_##Z == V114d? 0x##I : (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 RX(v) (WindowStartX+(v))
#define RY(v) (ResolutionY+NegWindowStartY-(v)) #define RY(v) (ResolutionY+NegWindowStartY-(v))
@ -54,9 +56,9 @@ extern s_shifting shifting;
#define E2S(F, A, R, N, P) typedef R (STDCALL *T##N) P; extern T##N N; #define E2S(F, A, R, N, P) typedef R (STDCALL *T##N) P; extern T##N N;
#define E2F(F, A, R, N, P) typedef R (FASTCALL *T##N) P; extern T##N N; #define E2F(F, A, R, N, P) typedef R (FASTCALL *T##N) P; extern T##N N;
#define E2C(F, A, T, N) extern T* pt##N; #define E2C(F, A, T, N) extern T* pt##N;
#define F7(X, Z, A,B,C,D,E,F,G,H, R, N, P) typedef R (X##CALL *T##N) P; extern T##N N; #define F8(X, Z, A,B,C,D,E,F,G,H,I, R, N, P) typedef R (X##CALL *T##N) P; extern T##N N;
#define A7(X, Z, A,B,C,D,E,F,G,H, R, N, P) typedef R (X##CALL *T##N) P; extern T##N N; #define A8(X, Z, A,B,C,D,E,F,G,H,I, R, N, P) typedef R (X##CALL *T##N) P; extern T##N N;
#define C7(Z, A,B,C,D,E,F,G,H, T, N) extern T* pt##N; #define C8(Z, A,B,C,D,E,F,G,H,I, T, N) extern T* pt##N;
#include "../Commons/D2Funcs.h" #include "../Commons/D2Funcs.h"
extern DataTables* SgptDataTables; extern DataTables* SgptDataTables;
@ -75,9 +77,9 @@ extern DataTables* SgptDataTables;
//E2F(D2Client,0, void, D2CleanStatMouseUp, ()); //E2F(D2Client,0, void, D2CleanStatMouseUp, ());
#undef F7 #undef F8
#undef A7 #undef A8
#undef C7 #undef C8
#undef D2S #undef D2S
#undef D2F #undef D2F
#undef E2S #undef E2S
@ -86,7 +88,10 @@ extern DataTables* SgptDataTables;
extern TD2AddPlayerStat V2AddPlayerStat; extern TD2AddPlayerStat V2AddPlayerStat;
extern TD2GetGameByClientID V2GetGameByClientID; extern TD2GetGameByClientID V2GetGameByClientID;
extern TD2SpawnSuperUnique V2SpawnSuperUnique;
extern TD2SpawnMonster V2SpawnMonster; extern TD2SpawnMonster V2SpawnMonster;
extern TD2Game235C0 V2Game235C0;
extern TD2ReadFile V2ReadFile;
//extern TD2SetColorPopup V2SetColorPopup; //extern TD2SetColorPopup V2SetColorPopup;
extern WORD (*getDescStrPos) (DWORD statID); extern WORD (*getDescStrPos) (DWORD statID);
extern void* (STDCALL *compileTxtFile)(DWORD unused, const char* filename, BINField* ptFields, DWORD* ptRecordCount, DWORD recordLength); extern void* (STDCALL *compileTxtFile)(DWORD unused, const char* filename, BINField* ptFields, DWORD* ptRecordCount, DWORD recordLength);
@ -101,14 +106,15 @@ void __inline fillRect(DWORD x, DWORD y, DWORD Width, DWORD Height, DWORD color,
#define WindowStartX (*ptWindowStartX) #define WindowStartX (*ptWindowStartX)
#define GameTypeMode (*ptGameTypeMode) #define GameTypeMode (*ptGameTypeMode)
#define ClientTable (*ptClientTable) #define ClientTable (*ptClientTable)
//#define CurrentNPCNum (*ptCurrentNPCNum)
#define IsLodGame (*ptIsLodGame) #define IsLodGame (*ptIsLodGame)
#define DifficultyLevel (*ptDifficultyLevel) #define DifficultyLevel (*ptDifficultyLevel)
#define MouseY (*ptMouseY) #define MouseY (*ptMouseY)
#define MouseX (*ptMouseX) #define MouseX (*ptMouseX)
#define ptClientChar (*ptptClientChar) #define ptClientChar (*ptptClientChar)
//#define CurrentNPCNum (*ptCurrentNPCNum) #define InputCommandLen (*ptInputCommandLen)
#define InputCommand (*ptInputCommand)
bool initD2functions(); void initD2functions();
/*================================= END OF FILE =================================*/ /*================================= END OF FILE =================================*/

77
PlugY/d2wrapper.h
View File

@ -1,55 +1,58 @@
/****************************************************************************** /******************************************************************************
File modified by Yohann NICOLAS. File created by Yohann NICOLAS.
NAME Main Diablo II extra DLL handler.
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 #pragma once
#include <windows.h> extern int version_Game;
//extern int version_binkw32;
extern int version_SmackW32; //extern int version_Bnclient;
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_D2Client;
extern int version_D2Net;
extern int version_D2Lang;
extern int version_D2Game;
extern int version_D2CMP; extern int version_D2CMP;
extern int version_Bnclient; extern int version_D2Common;
//extern int version_D2DDraw;
//extern int version_D2Direct3D;
extern int version_D2Game;
//extern int version_D2Gdi;
extern int version_D2gfx;
//extern int version_D2Glide;
extern int version_D2Lang;
extern int version_D2Launch;
//extern int version_D2MCPClient;
//extern int version_D2Multi;
extern int version_D2Net;
//extern int version_D2sound;
extern int version_D2Win;
extern int version_Fog; extern int version_Fog;
//extern int version_ijl11;
//extern int version_SmackW32;
extern int version_Storm; extern int version_Storm;
// Address in memory of external DLL // Address in memory of external DLL
extern DWORD offset_SmackW32; extern DWORD offset_Game;
extern DWORD offset_D2Common; //extern DWORD offset_binkw32;
extern DWORD offset_ijl11; //extern DWORD offset_Bnclient;
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_D2Client;
extern DWORD offset_D2Net;
extern DWORD offset_D2Lang;
extern DWORD offset_D2Game;
extern DWORD offset_D2CMP; extern DWORD offset_D2CMP;
extern DWORD offset_Bnclient; extern DWORD offset_D2Common;
//extern DWORD offset_D2DDraw;
//extern DWORD offset_D2Direct3D;
extern DWORD offset_D2Game;
//extern DWORD offset_D2Gdi;
extern DWORD offset_D2gfx;
//extern DWORD offset_D2Glide;
extern DWORD offset_D2Lang;
extern DWORD offset_D2Launch;
//extern DWORD offset_D2MCPClient;
//extern DWORD offset_D2Multi;
extern DWORD offset_D2Net;
//extern DWORD offset_D2sound;
extern DWORD offset_D2Win;
extern DWORD offset_Fog; extern DWORD offset_Fog;
//extern DWORD offset_ijl11;
//extern DWORD offset_SmackW32;
extern DWORD offset_Storm; extern DWORD offset_Storm;
/*================================= END OF FILE =================================*/ /*================================= END OF FILE =================================*/

3
PlugY/error.h
View File

@ -12,9 +12,10 @@
#include <windows.h> #include <windows.h>
extern DWORD active_logFile; extern int active_logFile;
void log_initfile(); void log_initfile();
void log_close();
void log_box( const char* pFormat, ... ); void log_box( const char* pFormat, ... );
void log_msg( const char* pFormat, ... ); void log_msg( const char* pFormat, ... );
void d2_assert( bool pCondition, char* pLocation, char* pMessage, int pLineNbr ); void d2_assert( bool pCondition, char* pLocation, char* pMessage, int pLineNbr );

22
PlugY/extraOptions.h
View File

@ -1,5 +1,6 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add DoNotCloseNihlathakPortal by haxifix.
More little options. More little options.
@ -8,15 +9,19 @@
#include "common.h" #include "common.h"
extern int active_DisplayItemLevel; extern bool active_DisplayItemLevel;
extern DWORD nbPlayersCommandByDefault; extern DWORD nbPlayersCommandByDefault;
extern int active_alwaysRegenMapInSP; extern DWORD nbPlayersCommand;
extern int active_RunLODs; extern bool active_alwaysRegenMapInSP;
extern bool active_RunLODs;
extern int active_AlwaysDisplayLifeMana; extern int active_AlwaysDisplayLifeMana;
extern int active_EnabledTXTFilesWithMSExcel; extern bool active_EnabledTXTFilesWithMSExcel;
extern int active_DisplayBaseStatsValue; extern bool active_DisplayBaseStatsValue;
extern int active_LadderRunewords; extern bool active_LadderRunewords;
extern int active_EnabledCowPortalWhenCowKingWasKill; extern bool active_EnabledCowPortalWhenCowKingWasKill;
extern bool active_DoNotCloseNihlathakPortal;
extern bool active_MoveCainNearHarrogathWaypoint;
extern bool active_RemoveExperienceDiminushingReturn;
void Install_DisplayItemLevel(); void Install_DisplayItemLevel();
void Install_SendPlayersCommand(); void Install_SendPlayersCommand();
@ -27,5 +32,8 @@ void Install_EnabledTXTFilesWithMSExcel();
void Install_DisplayBaseStatsValue(); void Install_DisplayBaseStatsValue();
void Install_LadderRunewords(); void Install_LadderRunewords();
void Install_EnabledCowPortalWhenCowKingWasKill(); void Install_EnabledCowPortalWhenCowKingWasKill();
void Install_DoNotCloseNihlathakPortal();
void Install_MoveCainNearHarrogathWaypoint();
void Install_RemoveExperienceDiminushingReturn();
/*================================= END OF FILE =================================*/ /*================================= END OF FILE =================================*/

59
PlugY/infinityStash.h
View File

@ -13,17 +13,62 @@ extern DWORD maxSharedPages;
extern DWORD nbPagesPerIndex; extern DWORD nbPagesPerIndex;
extern DWORD nbPagesPerIndex2; extern DWORD nbPagesPerIndex2;
extern bool active_multiPageStash; extern bool active_multiPageStash;
extern int active_SharedStashInMultiPlayer;
extern bool active_sharedStash; extern bool active_sharedStash;
extern bool active_sharedGold; extern bool active_sharedGold;
extern bool separateHardSoftStash; extern bool separateHardSoftStash;
extern char* sharedStashFilename; extern char* sharedStashFilename;
extern DWORD saveFileStackSize;
extern bool displaySharedSetItemNameInGreen; extern bool displaySharedSetItemNameInGreen;
extern int posXPreviousBtn,posYPreviousBtn,posXNextBtn,posYNextBtn,posXSharedBtn,posYSharedBtn,posXPreviousIndexBtn,posYPreviousIndexBtn,posXNextIndexBtn,posYNextIndexBtn,posXPutGoldBtn,posYPutGoldBtn,posXTakeGoldBtn,posYTakeGoldBtn; extern int posXPreviousBtn;
extern int posYPreviousBtn;
extern int posWPreviousBtn;
extern int posHPreviousBtn;
extern int posXNextBtn;
extern int posYNextBtn;
extern int posWNextBtn;
extern int posHNextBtn;
extern int posXSharedBtn;
extern int posYSharedBtn;
extern int posWSharedBtn;
extern int posHSharedBtn;
extern int posXPreviousIndexBtn;
extern int posYPreviousIndexBtn;
extern int posWPreviousIndexBtn;
extern int posHPreviousIndexBtn;
extern int posXNextIndexBtn;
extern int posYNextIndexBtn;
extern int posWNextIndexBtn;
extern int posHNextIndexBtn;
extern int posXPutGoldBtn;
extern int posYPutGoldBtn;
extern int posWPutGoldBtn;
extern int posHPutGoldBtn;
extern int posXTakeGoldBtn;
extern int posYTakeGoldBtn;
extern int posWTakeGoldBtn;
extern int posHTakeGoldBtn;
extern int posXStashNameField;
extern int posYStashNameField;
extern int posWStashNameField;
extern int posHStashNameField;
extern int posXStashGoldField;
extern int posYStashGoldField;
extern int posWStashGoldField;
extern int posHStashGoldField;
extern bool autoRenameStashPage;
extern DWORD PersonalNormalPageColor;
extern DWORD PersonalIndexPageColor;
extern DWORD PersonalMainIndexPageColor;
extern DWORD SharedNormalPageColor;
extern DWORD SharedIndexPageColor;
extern DWORD SharedMainIndexPageColor;
void toggleToSharedStash(Unit* ptChar); void toggleToSharedStash(Unit* ptChar);
void toggleToSelfStash(Unit* ptChar); void toggleToSelfStash(Unit* ptChar);
void setCurrentStashIndex(Unit* ptChar, bool isIndex); void setCurrentStashIndex(Unit* ptChar, int index);
void selectPreviousStash(Unit* ptChar); void selectPreviousStash(Unit* ptChar);
void selectNextStash(Unit* ptChar); void selectNextStash(Unit* ptChar);
void selectPreviousIndexStash(Unit* ptChar); void selectPreviousIndexStash(Unit* ptChar);
@ -35,15 +80,19 @@ void selectNextIndex2Stash(Unit* ptChar);
void swapStash(Unit* ptChar, DWORD page, bool toggle); void swapStash(Unit* ptChar, DWORD page, bool toggle);
void renameCurrentStash(Unit* ptChar, char* name); void renameCurrentStash(Unit* ptChar, char* name);
void insertStash(Unit* ptChar); void insertStash(Unit* ptChar);
bool deleteStash(Unit* ptChar); bool deleteStash(Unit* ptChar, bool isClient);
void selectStash(Unit* ptChar, Stash* newStash); void updateSelectedStashClient(Unit* ptChar);
void selectStash(Unit* ptChar, Stash* newStash, bool forceUpdate = false);
void setSelectedStashClient(DWORD stashId, DWORD stashFlags, DWORD flags, bool bOnlyItems); void setSelectedStashClient(DWORD stashId, DWORD stashFlags, DWORD flags, bool bOnlyItems);
Stash* addStash(Unit* ptChar, bool isShared); Stash* addStash(Unit* ptChar, bool isShared, bool autoSetIndex, Stash* ptStash = NULL);
DWORD loadStashList(Unit* ptChar, BYTE* data, DWORD maxSize, DWORD* curSize, bool isShared); DWORD loadStashList(Unit* ptChar, BYTE* data, DWORD maxSize, DWORD* curSize, bool isShared);
void saveStashList(Unit* ptChar, Stash* ptStash, BYTE** data, DWORD* maxSize, DWORD* curSize); void saveStashList(Unit* ptChar, Stash* ptStash, BYTE** data, DWORD* maxSize, DWORD* curSize);
void getCurrentStashName(WCHAR* buffer, DWORD maxSize, Unit* ptChar);
WCHAR* getDefaultStashName(Unit* ptChar);
void Install_MultiPageStash(); void Install_MultiPageStash();
/*================================= END OF FILE =================================*/ /*================================= END OF FILE =================================*/

2
PlugY/mainScreen.h
View File

@ -1,7 +1,7 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add "plugY v1.00" on screen. Print PlugY version on screen.
=================================================================*/ =================================================================*/
#pragma once #pragma once

2
PlugY/modifMemory.h
View File

@ -20,7 +20,7 @@ void memt_dword(DWORD old, DWORD val);
void memt_ref4(DWORD old, DWORD ref); void memt_ref4(DWORD old, DWORD ref);
//CALL <JMP.&D2gfx.#10047> //CALL <JMP.&D2gfx.#10047>
#define MEMJ_REF4(O, R) memj_ref4((DWORD)(O), (DWORD)(R)) #define MEMJ_REF4(O, R) if (version_Game < V114a) memj_ref4((DWORD)(O), (DWORD)(R)); else memc_ref4((DWORD)(O), (DWORD)(R))
void memj_ref4(DWORD old, DWORD ref); void memj_ref4(DWORD old, DWORD ref);
//CALL D2Common.6FD5F500 //CALL D2Common.6FD5F500

77
PlugY/newInterfaces.h
View File

@ -9,19 +9,94 @@
#include "common.h" #include "common.h"
#define MILIEU(X,L,N) (X + ((N<L)? (L-N)/2 : 0)) #define MILIEU(X,L,N) (X + ((N<L)? (L-N)/2 : 0))
#define isOnStatsPage(x,y) ((x<400) && (y<553)) #define isOnStatsPage(x,y) (x<RX(512))
extern DWORD bDontPrintBorder; extern DWORD bDontPrintBorder;
extern int selectedPage;
extern int extraHiddenPage;
extern int curRunesPage;
extern int maxRunesPage;
void GoNextStatPage(); void GoNextStatPage();
void GoPreviousStatPage(); void GoPreviousStatPage();
void GoStatPage(int page); void GoStatPage(int page);
int GetCurrentPage(); int GetCurrentPage();
struct BtnState
{
union{
DWORD all;
struct{
DWORD AssSTR:1;
DWORD AssDEX:1;
DWORD AssVIT:1;
DWORD AssENE:1;
DWORD UnaSTR:1;
DWORD UnaDEX:1;
DWORD UnaVIT:1;
DWORD UnaENE:1;
DWORD close:1;
DWORD previousPage:1;
DWORD nextPage:1;
DWORD prevRunes:1;
DWORD nextRunes:1;
};
};
};
extern BtnState isDownBtn;
extern bool active_newInterfaces; extern bool active_newInterfaces;
extern bool selectMainPageOnOpenning; extern bool selectMainPageOnOpenning;
extern bool printBackgroundOnMainPage; extern bool printBackgroundOnMainPage;
extern int posXNextPageBtn;
extern int posYNextPageBtn;
extern int posXPrevPageBtn;
extern int posYPrevPageBtn;
extern int posXClosePageBtn;
extern int posYClosePageBtn;
extern int posXNextRuneBtn;
extern int posYNextRuneBtn;
extern int posXPrevRuneBtn;
extern int posYPrevRuneBtn;
extern int posXRunesList;
extern int posYRunesList;
extern int runesPerPage;
DWORD getXNextPageBtn();
DWORD getYNextPageBtn();
DWORD getXPreviousPageBtn();
DWORD getYPreviousPageBtn();
DWORD getXCloseBtn();
DWORD getYCloseBtn();
DWORD getXNextRunesBtn();
DWORD getYNextRunesBtn();
DWORD getXPrevRunesBtn();
DWORD getYPrevRunesBtn();
#define getLCloseBtn() 32
#define getHCloseBtn() 32
#define isOnCloseBtn(x,y) isOnRect(x, y, getXCloseBtn(), getYCloseBtn(), getLCloseBtn(), getHCloseBtn())
#define getLPreviousPageBtn() 32
#define getHPreviousPageBtn() 32
#define isOnPreviousPageBtn(x,y) isOnRect(x, y, getXPreviousPageBtn(), getYPreviousPageBtn(), getLPreviousPageBtn(), getHPreviousPageBtn())
#define getLNextPageBtn() 32
#define getHNextPageBtn() 32
#define isOnNextPageBtn(x,y) isOnRect(x, y, getXNextPageBtn(), getYNextPageBtn(), getLNextPageBtn(), getHNextPageBtn())
#define getLPrevRunesBtn() 32
#define getHPrevRunesBtn() 32
#define isOnPrevRunesBtn(x,y) isOnRect(x, y, getXPrevRunesBtn(), getYPrevRunesBtn(), getLPrevRunesBtn(), getHPrevRunesBtn())
#define getLNextRunesBtn() 32
#define getHNextRunesBtn() 32
#define isOnNextRunesBtn(x,y) isOnRect(x, y, getXNextRunesBtn(), getYNextRunesBtn(), getLNextRunesBtn(), getHNextRunesBtn())
DWORD STDCALL statsLeftDown(sWinMessage* msg);
DWORD STDCALL statsLeftUp(sWinMessage* msg);
void Install_NewInterfaces(); void Install_NewInterfaces();
/*================================= END OF FILE =================================*/ /*================================= END OF FILE =================================*/

4
PlugY/parameters.h
View File

@ -6,9 +6,7 @@
=================================================================*/ =================================================================*/
#pragma once #pragma once
#define PLUGY_VERSION "11.01" #define PLUGY_VERSION "14.03 HD"
#define LOG_FILE "PlugY.log"
enum TargetMod enum TargetMod
{ {

1
PlugY/playerCustomData.h
View File

@ -21,6 +21,7 @@ struct Stash
struct { struct {
DWORD isShared:1; // DWORD isShared:1; //
DWORD isIndex:1; // DWORD isIndex:1; //
DWORD isMainIndex:1; //
DWORD isReserved:1; // For swap items comand DWORD isReserved:1; // For swap items comand
}; };
}; };

4
PlugY/savePlayerData.h
View File

@ -8,6 +8,10 @@
#include "common.h" #include "common.h"
extern bool active_AutoBackup;
extern int maxBackupPerCharacter;
void backupSaveFiles(char* name, int isHardCoreGame);
void Install_SavePlayerData(); void Install_SavePlayerData();
/*================================= END OF FILE =================================*/ /*================================= END OF FILE =================================*/

2
PlugY/skillsPoints.h
View File

@ -9,7 +9,7 @@
#include "common.h" #include "common.h"
extern bool active_SkillsPoints; extern bool active_SkillsPoints;
extern bool unassignSkillsPointsOneByOne; extern bool unassignSkillsPointsOneForOne;
extern int posXUnassignSkillBtn, posYUnassignSkillBtn; extern int posXUnassignSkillBtn, posYUnassignSkillBtn;
void UnassignAllSkillsPoints(Unit* ptChar); void UnassignAllSkillsPoints(Unit* ptChar);

27
PlugY/uberQuest.h
View File

@ -9,6 +9,33 @@
#include "common.h" #include "common.h"
extern bool active_UberQuest; extern bool active_UberQuest;
extern DWORD UberMephistoX;
extern DWORD UberMephistoY;
extern DWORD UberDiabloX;
extern DWORD UberDiabloY;
extern DWORD UberBaalX;
extern DWORD UberBaalY;
extern bool active_UberMinions;
//extern DWORD UberMephistoNbMinions;
//extern DWORD UberMephistoMinions[];
extern int UberMephistoSpawnPercent;
extern DWORD UberMephistoSpawnRadius;
//extern DWORD UberBaalNbMinions;
//extern DWORD UberBaalMinions[];
extern int UberBaalSpawnPercent;
extern DWORD UberBaalSpawnRadius;
//extern DWORD UberDiabloNbMinions;
//extern DWORD UberDiabloMinions[];
extern int UberDiabloSpawnPercent;
extern DWORD UberDiabloSpawnRadius;
extern bool active_UberDiabloRushTweekAI;
extern bool active_UberBaalTeleportTweekAI;
extern bool active_UberBaalChillingArmorTweekAI;
extern int uberBaalChillingArmorTimer;
void Install_UberQuest(); void Install_UberQuest();
void resetQuestState(); void resetQuestState();

3
PlugY/updateServer.h
View File

@ -8,7 +8,8 @@
#include "common.h" #include "common.h"
__inline void updateServer(WORD p) {if (!onRealm) D2SendToServer3(0x3A, p);}; void updateServer(WORD p);
void Install_UpdateServer(); void Install_UpdateServer();
/*================================= END OF FILE =================================*/ /*================================= END OF FILE =================================*/

668
PlugYInstall/PlugYInstall.cpp
View File

@ -1,4 +1,3 @@
/*================================================================= /*=================================================================
File created by Yohann NICOLAS. File created by Yohann NICOLAS.
Add support 1.13d by L'Autour. Add support 1.13d by L'Autour.
@ -9,50 +8,21 @@
#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup") #pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
#include "../Commons/VersionInfo.h" #include "../Commons/VersionInfo.h"
#include <windows.h>
#include <stdio.h> #include <stdio.h>
const char* boxNameInstall = "Installation of PlugY, The Survival Kit Installation"; DWORD loadCallerAddr;
const char* boxNameUnInstall = "Uninstall PlugY, The Survival Kit "; DWORD loadCallerLen;
BYTE loadCallerNew[6] = { 0x90,0xE8,0x00,0x00,0x00,0x00 }; // Call load PlugY library
BYTE loadCallerOld[6] = { 0xFF,0x15,0x00,0x00,0x00,0x00 }; // CALL DWORD PTR DS:[<&KERNEL32.LoadLibrary>]
int CALL_LOAD[8] = { 0x389B,0x389B,0x3870,0x8B23,0xB423,0x8F63,0xB423,0xAA03 }; DWORD freeCallerAddr;
BYTE callNewLoad[8][6] = { { 0xE8,0x60,0x85,0x00,0x00,0x90 },// JMP 6FA7BE00-6FA738A0 ;install loadlibrary DWORD freeCallerLen;
{ 0xE8,0x60,0x85,0x00,0x00,0x90 },// JMP 6FA7BE00-6FA738A0 ;install loadlibrary BYTE freeCallerNew[6] = { 0x90,0xE8,0x00,0x00,0x00,0x00 }; // Call free PlugY library
{ 0xE8,0x8B,0x85,0x00,0x00,0x90 },// JMP 6FA7BE00-6FA73875 ;install loadlibrary BYTE freeCallerOld[6] = { 0xFF,0x15,0x00,0x00,0x00,0x00 }; // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{ 0xE8,0xD8,0x42,0x00,0x00,0x90 },// JMP 6FA8CE00-6FA88B28 ;install loadlibrary
{ 0xE8,0xD8,0x19,0x00,0x00,0x90 },// JMP 6FA8CE00-6FA8B428 ;install loadlibrary
{ 0xE8,0x98,0x3E,0x00,0x00,0x90 },// JMP 6FA8CE00-6FA88F68 ;install loadlibrary
{ 0xE8,0xD8,0x19,0x00,0x00,0x90 },// JMP 6FA8CE00-6FA8B428 ;install loadlibrary
{ 0xE8,0xF8,0x23,0x00,0x00,0x90 }};// JMP 6FA8CE00-6FA8B428 ;install loadlibrary
BYTE callOldLoad[8][6] = { { 0xFF,0x15,0x3C,0xC0,0xA7,0x6F },
{ 0xFF,0x15,0x3C,0xC0,0xA7,0x6F },
{ 0xFF,0x15,0x40,0xC0,0xA7,0x6F },
{ 0xFF,0x15,0x1C,0xD1,0xA8,0x6F },
{ 0xFF,0x15,0x1C,0xD1,0xA8,0x6F },
{ 0xFF,0x15,0x1C,0xD1,0xA8,0x6F },
{ 0xFF,0x15,0x1C,0xD1,0xA8,0x6F },
{ 0xFF,0x15,0x1C,0xD1,0xA8,0x6F }};
int CALL_FREE[8] = { 0x3A8C,0x3A8C,0x3A6D,0x8ACA,0xB3CA,0x8F0A,0xB3CA,0xA9AA }; DWORD loadDllAddr;
BYTE callNewFree[8][6] = { { 0xE8,0xAF,0x83,0x00,0x00,0x90 }, // JMP 6FA7BE40-6FA73A91 ;install freelibrary DWORD loadDllLen;
{ 0xE8,0xAF,0x83,0x00,0x00,0x90 }, // JMP 6FA7BE40-6FA73A91 ;install freelibrary BYTE loadDll[] = {
{ 0xE8,0xD2,0x83,0x00,0x00,0x90 }, // JMP 6FA7BE44-6FA73A72 ;install freelibrary
{ 0xE8,0x75,0x43,0x00,0x00,0x90 }, // JMP 6FA8CE44-6FA88ACF ;install freelibrary
{ 0xE8,0x75,0x1A,0x00,0x00,0x90 }, // JMP 6FA8CE44-6FA8B3CF ;install freelibrary
{ 0xE8,0x35,0x3F,0x00,0x00,0x90 }, // JMP 6FA8CE44-6FA88F0F ;install freelibrary
{ 0xE8,0x75,0x1A,0x00,0x00,0x90 },// JMP 6FA8CE44-6FA8B3CF ;install freelibrary
{ 0xE8,0x95,0x24,0x00,0x00,0x90 }};// JMP 6FA8CE44-6FA8B3CF ;install freelibrary
BYTE callOldFree[8][6] = { { 0xFF,0x15,0x44,0xC0,0xA7,0x6F }, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{ 0xFF,0x15,0x44,0xC0,0xA7,0x6F }, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{ 0xFF,0x15,0x48,0xC0,0xA7,0x6F }, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{ 0xFF,0x15,0x2C,0xD1,0xA8,0x6F }, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{ 0xFF,0x15,0x2C,0xD1,0xA8,0x6F }, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{ 0xFF,0x15,0x2C,0xD1,0xA8,0x6F }, // CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{ 0xFF,0x15,0x2C,0xD1,0xA8,0x6F },// CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
{ 0xFF,0x15,0x24,0xD1,0xA8,0x6F }};// CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>]
int CALLER_LOADPLUGY = 0xBE00;//6FA7BE00-6FA70000
BYTE caller_LoadPlugY[] = {
0xFF,0x74,0x24,0x04, //PUSH DWORD PTR SS:[ESP+4] 0xFF,0x74,0x24,0x04, //PUSH DWORD PTR SS:[ESP+4]
0xFF,0x15,0x40,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.LoadLibraryA>] ; kernel32.LoadLibraryA 0xFF,0x15,0x40,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.LoadLibraryA>] ; kernel32.LoadLibraryA
0x50, //PUSH EAX 0x50, //PUSH EAX
@ -60,35 +30,45 @@ BYTE caller_LoadPlugY[] = {
0xFF,0x15,0x40,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.LoadLibraryA>] ; kernel32.LoadLibraryA 0xFF,0x15,0x40,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.LoadLibraryA>] ; kernel32.LoadLibraryA
0xA3,0xFC,0xEF,0xA8,0x6F, //MOV DWORD PTR DS:[6FA8EFFC],EAX 0xA3,0xFC,0xEF,0xA8,0x6F, //MOV DWORD PTR DS:[6FA8EFFC],EAX
0x85,0xC0, //TEST EAX,EAX 0x85,0xC0, //TEST EAX,EAX
0x74,0x18, //JE SHORT d2gfx.6FA7BE37 0x74,0x2B, //JE SHORT d2gfx.6FA7BE33
0x68,0x90,0xBE,0xA7,0x6F, //PUSH d2gfx.6FA7BE10 ;Init ID 0x50, //PUSH EAX
0x68,0x90,0xBE,0xA7,0x6F, //PUSH d2gfx.6FA7BE10 ;Init String
0x50, //PUSH EAX 0x50, //PUSH EAX
0xFF,0x15,0x3C,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.GetProcAddress>] ; kernel32.GetProcAddress 0xFF,0x15,0x3C,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.GetProcAddress>] ; kernel32.GetProcAddress
0x85,0xC0, //TEST EAX,EAX 0x85,0xC0, //TEST EAX,EAX
0x74,0x04, //JE SHORT d2gfx.6FA7BDC1 0x74,0x04, //JE SHORT d2gfx.6FA7BDC1
0x6A,0x00, //PUSH 0 0x6A,0x00, //PUSH 0
0xEB,0x13, //JMP SHORT d2gfx.6FA7BDC1
0x68,0x10,0x27,0x00,0x00, //PUSH 2710 ;Init Ordinal(10000)
0xFF,0x74,0x24,0x04, //PUSH DWORD PTR SS:[ESP+4]
0xFF,0x15,0x3C,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.GetProcAddress>] ; kernel32.GetProcAddress
0x85,0xC0, //TEST EAX,EAX
0x74,0x02, //JE SHORT d2gfx.6FA7BDC1
0xFF,0xD0, //CALL EAX 0xFF,0xD0, //CALL EAX
0x58, //POP EAX 0x58, //POP EAX
0x58, //POP EAX
0xC2,0x04,0x00, //RETN 4 0xC2,0x04,0x00, //RETN 4
0x59, //POP ECX 0x00,0x00,0x00,0x00 }; //HANDLE var;
0xB9,0x80,0xBE,0xA7,0x6F, //MOV ECX,d2gfx.6FA7BE80 ; ASCII "PlugY.dll"
0x83,0x04,0x24,0x11, //ADD DWORD PTR SS:[ESP],11
0xC2,0x04,0x00 }; //RETN 4
DWORD freeDllAddr;
int CALLER_FREEPLUGY = 0xBE44;//6FA7BE44-6FA70000 DWORD freeDllLen;
BYTE caller_FreePlugY[] = { BYTE freeDll[] = {
0xFF,0x74,0x24,0x04, //PUSH DWORD PTR SS:[ESP+4] 0xFF,0x74,0x24,0x04, //PUSH DWORD PTR SS:[ESP+4]
0xFF,0x15,0x48,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>] ; kernel32.FreeLibrary 0xFF,0x15,0x48,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>] ; kernel32.FreeLibrary
0x50, //PUSH EAX 0x50, //PUSH EAX
0xA1,0xFC,0xEF,0xA8,0x6F, //MOV EAX,DWORD PTR DS:[6FA8EFFC] 0xA1,0xFC,0xEF,0xA8,0x6F, //MOV EAX,DWORD PTR DS:[6FA8EFFC]
0x85,0xC0, //TEST EAX,EAX 0x85,0xC0, //TEST EAX,EAX
0x74,0x20, //JE SHORT d2gfx.6FA7BE74 0x74,0x2D, //JE SHORT d2gfx.6FA7BE74
0x50, //PUSH EAX 0x50, //PUSH EAX
0x68,0xA0,0xBE,0xA7,0x6F, //PUSH d2gfx.6FA7BE20 ;release 0x68,0xA0,0xBE,0xA7,0x6F, //PUSH d2gfx.6FA7BE20 ;Release String
0x50, //PUSH EAX 0x50, //PUSH EAX
0x33,0xC0, //XOR EAX,EAX //0x33,0xC0, //XOR EAX,EAX
0xA3,0xFC,0xEF,0xA8,0x6F, //MOV DWORD PTR DS:[6FA8EFFC],EAX //0xA3,0xFC,0xEF,0xA8,0x6F, //MOV DWORD PTR DS:[6FA8EFFC],EAX
0xFF,0x15,0x3C,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.GetProcAdd>; kernel32.GetProcAddress
0x85,0xC0, //TEST EAX,EAX
0x75,0x13, //JNZ SHORT d2gfx.6FA7BDEF
0x68,0x11,0x27,0x00,0x00, //PUSH 2711 ;Release Ordinal(10001)
0xFF,0x74,0x24,0x04, //PUSH DWORD PTR SS:[ESP+4]
0xFF,0x15,0x3C,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.GetProcAdd>; kernel32.GetProcAddress 0xFF,0x15,0x3C,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.GetProcAdd>; kernel32.GetProcAddress
0x85,0xC0, //TEST EAX,EAX 0x85,0xC0, //TEST EAX,EAX
0x74,0x02, //JE SHORT d2gfx.6FA7BDEF 0x74,0x02, //JE SHORT d2gfx.6FA7BDEF
@ -97,328 +77,392 @@ BYTE caller_FreePlugY[] = {
0x58, //POP EAX 0x58, //POP EAX
0xC2,0x04,0x00 }; //RETN 4 0xC2,0x04,0x00 }; //RETN 4
DWORD libraryNameAddr;
DWORD libraryNameLen;
LPCSTR libraryName = "PlugY.dll";
int S_DLLNAME = 0xBE80;//6FA7BE30-6FA70000 DWORD initNameAddr;
BYTE sDllName[] = { 'P','l','u','g','Y','.','d','l','l',0 };// Dll filename to load. DWORD initNameLen;
LPCSTR initName = "_Init@4";
int S_INIT = 0xBE90;//6FA7BE10-6FA70000 DWORD releaseNameAddr;
BYTE sInit[] = { '_','I','n','i','t','@','4',0 }; DWORD releaseNameLen;
LPCSTR releaseName = "_Release@0";
int S_RELEASE = 0xBEA0;//6FA7BE20-6FA70000 int msgBox(LPCSTR boxName, UINT uType, LPCSTR pFormat, ...)
BYTE sRelease[] = { '_','R','e','l','e','a','s','e','@','0',0 };
void updateData(int version)
{ {
switch (version) char buffer[300];
{ va_list lArgs;
case V109b: va_start( lArgs, pFormat );
case V109d: vsprintf_s( buffer, sizeof(buffer), pFormat, lArgs );
caller_LoadPlugY[6] -= 4; va_end(lArgs);
caller_LoadPlugY[18] -= 4;
caller_LoadPlugY[39] -= 4; return MessageBox(NULL, buffer, boxName, uType);
caller_FreePlugY[6] -= 4;
caller_FreePlugY[36] -= 4;
caller_FreePlugY[48] -= 4;
break;
case V110:
break;
case V111:
case V111b:
case V112:
case V113c:
case V113d:
CALLER_LOADPLUGY += 0x1000;
CALLER_FREEPLUGY += 0x1000;
S_INIT += 0x1000;
S_RELEASE += 0x1000;
S_DLLNAME += 0x1000;
*(DWORD*)(&caller_LoadPlugY[6]) = 0x6FA8D11C;
*(DWORD*)(&caller_LoadPlugY[18]) = 0x6FA8D11C;
*(DWORD*)(&caller_LoadPlugY[39]) = 0x6FA8D120;
*(DWORD*)(&caller_FreePlugY[6]) = (version == V113d) ? 0x6FA8D124 : 0x6FA8D12C;
*(DWORD*)(&caller_FreePlugY[36]) = 0x6FA8D120;
*(DWORD*)(&caller_FreePlugY[48]) = (version == V113d) ? 0x6FA8D124 : 0x6FA8D12C;
caller_LoadPlugY[13] += 0x10;
caller_LoadPlugY[14]++;
caller_LoadPlugY[25]++;
caller_LoadPlugY[33] += 0x10;
caller_LoadPlugY[34]++;
caller_LoadPlugY[58] += 0x10;
caller_LoadPlugY[59]++;
caller_FreePlugY[23] += 0x10;
caller_FreePlugY[24]++;
caller_FreePlugY[14]++;
caller_FreePlugY[32]++;
break;
}
} }
int Align(int v)
{
return v % 16 ? v + 16 - v % 16 : v;
}
////////////////////////////// EXPORTED FUNCTIONS ////////////////////////////// ////////////////////////////// EXPORTED FUNCTIONS //////////////////////////////
void Patch() int Patch(FILE *targetFile)
{ {
if (MessageBox(0, "This programm will modify the D2gfx.dll file of the current directory.\n"
"Before continue, don't forgot to backup D2gfx.dll if you want\n"
"Do you want patch D2gfx.dll for the launch of PlugY ?",
boxNameInstall, MB_YESNO | MB_ICONQUESTION) == IDNO)
{
MessageBox(0, "D2gfx.dll isn't patched.\n",
boxNameInstall, MB_OK | MB_ICONASTERISK);
exit(0);
}
FILE *dll;
if (fopen_s(&dll, "d2gfx.dll", "rb+"))
{
MessageBox(0, "Can't open D2gfx.dll in read/write mode.\n"
"If Diablo II is running you can\'t install PlugY, The Survival Kit.\n"
"Quit Diablo II and try again.",
boxNameInstall, MB_OK | MB_ICONEXCLAMATION);
exit(0);
}
int version = GetD2Version("Game.exe");
if (version < V109 || version > V113d)
{
MessageBox(0, "Bad version of D2gfx.dll.\n"
"You can try to uninstall any previous version of PlugY, The Survival Kit then retry.\n"
"Or re-install a clean version (between 1.09 and 1.13d) of LOD.",
boxNameInstall, MB_OK | MB_ICONEXCLAMATION);
exit(0);
}
updateData(version);
bool error = false; bool error = false;
int ident = 0; int ident = 0;
BYTE buffer[100]; BYTE buffer[100];
BYTE zeros[100]; BYTE zeros[100];
memset(zeros, 0, sizeof(zeros)); memset(zeros, 0, sizeof(zeros));
version -= V109b; fseek(targetFile, loadCallerAddr, SEEK_SET);
fread(buffer, sizeof(loadCallerNew), 1, targetFile);
if (memcmp(buffer, loadCallerOld, sizeof(loadCallerNew)) != 0) error = true;
if (memcmp(buffer, loadCallerNew, sizeof(loadCallerNew)) == 0) ident++;
fseek(dll, CALL_LOAD[version], SEEK_SET); fseek(targetFile, freeCallerAddr, SEEK_SET);
fread(buffer, 6, 1, dll); fread(buffer, sizeof(freeCallerNew), 1, targetFile);
if (memcmp(buffer, callOldLoad[version], 6) != 0) error = true; if (memcmp(buffer, freeCallerOld, sizeof(freeCallerNew)) != 0) error = true;
if (memcmp(buffer, callNewLoad[version], 6) == 0) ident++; if (memcmp(buffer, freeCallerNew, sizeof(freeCallerNew)) == 0) ident++;
fseek(dll, CALL_FREE[version], SEEK_SET); fseek(targetFile, loadDllAddr, SEEK_SET);
fread(buffer, 6, 1, dll); fread(buffer, sizeof(loadDll), 1, targetFile);
if (memcmp(buffer, callOldFree[version], 6) != 0) error = true; if (memcmp(buffer, zeros, sizeof(loadDll)) != 0) error = true;
if (memcmp(buffer, callNewFree[version], 6) == 0) ident++; if (memcmp(buffer, loadDll, sizeof(loadDll)) == 0) ident++;
fseek(dll, CALLER_LOADPLUGY, SEEK_SET); fseek(targetFile, freeDllAddr, SEEK_SET);
fread(buffer, sizeof(caller_LoadPlugY), 1, dll); fread(buffer, sizeof(freeDll), 1, targetFile);
if (memcmp(buffer, zeros, sizeof(caller_LoadPlugY)) != 0) error = true; if (memcmp(buffer, zeros, sizeof(freeDll)) != 0) error = true;
if (memcmp(buffer, caller_LoadPlugY, sizeof(caller_LoadPlugY)) == 0) ident++; if (memcmp(buffer, freeDll, sizeof(freeDll)) == 0) ident++;
fseek(dll, CALLER_FREEPLUGY, SEEK_SET); fseek(targetFile, initNameAddr, SEEK_SET);
fread(buffer, sizeof(caller_FreePlugY), 1, dll); fread(buffer, initNameLen, 1, targetFile);
if (memcmp(buffer, zeros, sizeof(caller_FreePlugY)) != 0) error = true; if (memcmp(buffer, zeros, initNameLen) != 0) error = true;
if (memcmp(buffer, caller_FreePlugY, sizeof(caller_FreePlugY)) == 0) ident++; if (memcmp(buffer, initName, initNameLen) == 0) ident++;
fseek(dll, S_INIT, SEEK_SET); fseek(targetFile, releaseNameAddr, SEEK_SET);
fread(buffer, sizeof(sInit), 1, dll); fread(buffer, releaseNameLen, 1, targetFile);
if (memcmp(buffer, zeros, sizeof(sInit)) != 0) error = true; if (memcmp(buffer, zeros, releaseNameLen) != 0) error = true;
if (memcmp(buffer, sInit, sizeof(sInit)) == 0) ident++; if (memcmp(buffer, releaseName, releaseNameLen) == 0) ident++;
fseek(dll, S_RELEASE, SEEK_SET); fseek(targetFile, libraryNameAddr, SEEK_SET);
fread(buffer, sizeof(sRelease), 1, dll); fread(buffer, libraryNameLen, 1, targetFile);
if (memcmp(buffer, zeros, sizeof(sRelease)) != 0) error = true; if (memcmp(buffer, zeros, libraryNameLen) != 0) error = true;
if (memcmp(buffer, sRelease, sizeof(sRelease)) == 0) ident++; if (memcmp(buffer, libraryName, libraryNameLen) == 0) ident++;
fseek(dll, S_DLLNAME, SEEK_SET);
fread(buffer, sizeof(sDllName), 1, dll);
if (memcmp(buffer, zeros, sizeof(sDllName)) != 0) error = true;
if (memcmp(buffer, sDllName, sizeof(sDllName)) == 0) ident++;
if (error) if (error)
{ return ident == 7 ? 1 : 2;
if (ident == 7)
{
MessageBox(0, "PlugY, The Survival Kit already installed.",
boxNameInstall, MB_OK | MB_ICONASTERISK);
exit(0);
}
else
{
MessageBox(0, "Bad version of D2gfx.dll.\n"
"You can try to uninstall any previous version of PlugY, The Survival Kit then retry.\n"
"Or re-install a clean version (between 1.09 and 1.13d) of LOD.",
boxNameInstall, MB_OK | MB_ICONEXCLAMATION);
exit(0);
}
}
fseek(dll, CALL_LOAD[version], SEEK_SET); fseek(targetFile, loadCallerAddr, SEEK_SET);
fwrite(callNewLoad[version], 6, 1, dll); fwrite(loadCallerNew, 6, 1, targetFile);
fseek(dll, CALL_FREE[version], SEEK_SET); fseek(targetFile, freeCallerAddr, SEEK_SET);
fwrite(callNewFree[version], 6, 1, dll); fwrite(freeCallerNew, 6, 1, targetFile);
fseek(dll, CALLER_LOADPLUGY, SEEK_SET); fseek(targetFile, loadDllAddr, SEEK_SET);
fwrite(caller_LoadPlugY, sizeof(caller_LoadPlugY), 1, dll); fwrite(loadDll, sizeof(loadDll), 1, targetFile);
fseek(dll, CALLER_FREEPLUGY, SEEK_SET); fseek(targetFile, freeDllAddr, SEEK_SET);
fwrite(caller_FreePlugY, sizeof(caller_FreePlugY), 1, dll); fwrite(freeDll, sizeof(freeDll), 1, targetFile);
fseek(dll, S_INIT, SEEK_SET); fseek(targetFile, initNameAddr, SEEK_SET);
fwrite(sInit, sizeof(sInit), 1, dll); fwrite(initName, initNameLen, 1, targetFile);
fseek(dll, S_RELEASE, SEEK_SET); fseek(targetFile, releaseNameAddr, SEEK_SET);
fwrite(sRelease, sizeof(sRelease), 1, dll); fwrite(releaseName, releaseNameLen, 1, targetFile);
fseek(dll, S_DLLNAME, SEEK_SET); fseek(targetFile, libraryNameAddr, SEEK_SET);
fwrite(sDllName, sizeof(sDllName), 1, dll); fwrite(libraryName, libraryNameLen, 1, targetFile);
fclose(dll); return 0;
MessageBox(0, "D2gfx.dll patched successfully.\n"
"PlugY, The Survival Kit installed successfully.",
boxNameInstall, MB_OK | MB_ICONASTERISK);
exit(0);
} }
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
void Unpatch() int Unpatch(FILE *targetFile)
{ {
if (MessageBox(0, "This programm will modify the D2gfx.dll file of the current directory.\n"
"Before continue, don't forgot to backup D2gfx.dll if you want\n"
"Do you want patch D2gfx.dll for remove the launch of PlugY ?",
boxNameUnInstall, MB_YESNO | MB_ICONQUESTION) == IDNO)
{
MessageBox(0, "D2gfx.dll isn't patched.\n",
boxNameUnInstall, MB_OK | MB_ICONASTERISK);
exit(0);
}
FILE *dll;
if (fopen_s(&dll, "d2gfx.dll", "rb+"))
{
MessageBox(0, "Can't open D2gfx.dll in read/write mode.\n"
"If Diablo II is running you can\'t install PlugY, The Survival Kit.\n"
"Quit Diablo II and try again.",
boxNameUnInstall, MB_OK | MB_ICONEXCLAMATION);
exit(0);
}
int version = GetD2Version("Game.exe");
if (version < V109 || version > V113d)
{
MessageBox(0, "Bad version of D2gfx.dll.\n"
"You can try to uninstall any previous version of PlugY, The Survival Kit then retry.\n"
"Or re-install a clean version (between 1.09 and 1.13d) of LOD.",
boxNameUnInstall, MB_OK | MB_ICONEXCLAMATION);
exit(0);
}
updateData(version);
bool error = false; bool error = false;
int ident = 0; int ident = 0;
BYTE buffer[100]; BYTE buffer[100];
BYTE zeros[100]; BYTE zeros[100];
memset(zeros, 0, sizeof(zeros)); memset(zeros, 0, sizeof(zeros));
version -= V109b; fseek(targetFile, loadCallerAddr, SEEK_SET);
fread(buffer, 6, 1, targetFile);
if (memcmp(buffer, loadCallerNew, 6) != 0) error = true;
if (memcmp(buffer, loadCallerOld, 6) == 0) ident++;
fseek(dll, CALL_LOAD[version], SEEK_SET); fseek(targetFile, freeCallerAddr, SEEK_SET);
fread(buffer, 6, 1, dll); fread(buffer, 6, 1, targetFile);
if (memcmp(buffer, callNewLoad[version], 6) != 0) error = true; if (memcmp(buffer, freeCallerNew, 6) != 0) error = true;
if (memcmp(buffer, callOldLoad[version], 6) == 0) ident++; if (memcmp(buffer, freeCallerOld, 6) == 0) ident++;
fseek(dll, CALL_FREE[version], SEEK_SET); fseek(targetFile, loadDllAddr, SEEK_SET);
fread(buffer, 6, 1, dll); fread(buffer, sizeof(loadDll), 1, targetFile);
if (memcmp(buffer, callNewFree[version], 6) != 0) error = true; if (memcmp(buffer, loadDll, sizeof(loadDll)) != 0) error = true;
if (memcmp(buffer, callOldFree[version], 6) == 0) ident++; if (memcmp(buffer, zeros, sizeof(loadDll)) == 0) ident++;
fseek(dll, CALLER_LOADPLUGY, SEEK_SET); fseek(targetFile, freeDllAddr, SEEK_SET);
fread(buffer, sizeof(caller_LoadPlugY), 1, dll); fread(buffer, sizeof(freeDll), 1, targetFile);
if (memcmp(buffer, caller_LoadPlugY, sizeof(caller_LoadPlugY)) != 0) error = true; if (memcmp(buffer, freeDll, sizeof(freeDll)) != 0) error = true;
if (memcmp(buffer, zeros, sizeof(caller_LoadPlugY)) == 0) ident++; if (memcmp(buffer, zeros, sizeof(freeDll)) == 0) ident++;
fseek(dll, CALLER_FREEPLUGY, SEEK_SET); fseek(targetFile, initNameAddr, SEEK_SET);
fread(buffer, sizeof(caller_FreePlugY), 1, dll); fread(buffer, initNameLen, 1, targetFile);
if (memcmp(buffer, caller_FreePlugY, sizeof(caller_FreePlugY)) != 0) error = true; if (memcmp(buffer, initName, initNameLen) != 0) error = true;
if (memcmp(buffer, zeros, sizeof(caller_FreePlugY)) == 0) ident++; if (memcmp(buffer, zeros, initNameLen) == 0) ident++;
fseek(dll, S_INIT, SEEK_SET); fseek(targetFile, releaseNameAddr, SEEK_SET);
fread(buffer, sizeof(sInit), 1, dll); fread(buffer, releaseNameLen, 1, targetFile);
if (memcmp(buffer, sInit, sizeof(sInit)) != 0) error = true; if (memcmp(buffer, releaseName, releaseNameLen) != 0) error = true;
if (memcmp(buffer, zeros, sizeof(sInit)) == 0) ident++; if (memcmp(buffer, zeros, releaseNameLen) == 0) ident++;
fseek(dll, S_RELEASE, SEEK_SET); fseek(targetFile, libraryNameAddr, SEEK_SET);
fread(buffer, sizeof(sRelease), 1, dll); fread(buffer, libraryNameLen, 1, targetFile);
if (memcmp(buffer, sRelease, sizeof(sRelease)) != 0) error = true; if (memcmp(buffer, libraryName, libraryNameLen) != 0) error = true;
if (memcmp(buffer, zeros, sizeof(sRelease)) == 0) ident++; if (memcmp(buffer, zeros, libraryNameLen) == 0) ident++;
fseek(dll, S_DLLNAME, SEEK_SET);
fread(buffer, sizeof(sDllName), 1, dll);
if (memcmp(buffer, sDllName, sizeof(sDllName)) != 0) error = true;
if (memcmp(buffer, zeros, sizeof(sDllName)) == 0) ident++;
if (error) if (error)
{ return ident == 7 ? 1 : 2;
if (ident == 7)
{
MessageBox(0, "PlugY, The Survival Kit already uninstalled.",
boxNameUnInstall, MB_OK | MB_ICONASTERISK);
exit(0);
}
else
{
MessageBox(0, "Bad version of D2gfx.dll.\n"
"Unable to uninstall PlugY, The Survival Kit.",
boxNameUnInstall, MB_OK | MB_ICONEXCLAMATION);
exit(0);
}
}
fseek(dll, CALL_LOAD[version], SEEK_SET); fseek(targetFile, loadCallerAddr, SEEK_SET);
fwrite(callOldLoad[version], 6, 1, dll); fwrite(loadCallerOld, 6, 1, targetFile);
fseek(dll, CALL_FREE[version], SEEK_SET); fseek(targetFile, freeCallerAddr, SEEK_SET);
fwrite(callOldFree[version], 6, 1, dll); fwrite(freeCallerOld, 6, 1, targetFile);
fseek(dll, CALLER_LOADPLUGY, SEEK_SET); fseek(targetFile, loadDllAddr, SEEK_SET);
fwrite(zeros, sizeof(caller_LoadPlugY), 1, dll); fwrite(zeros, sizeof(loadDll), 1, targetFile);
fseek(dll, CALLER_FREEPLUGY, SEEK_SET); fseek(targetFile, freeDllAddr, SEEK_SET);
fwrite(zeros, sizeof(caller_FreePlugY), 1, dll); fwrite(zeros, sizeof(freeDll), 1, targetFile);
fseek(dll, S_INIT, SEEK_SET); fseek(targetFile, initNameAddr, SEEK_SET);
fwrite(zeros, sizeof(sInit), 1, dll); fwrite(zeros, initNameLen, 1, targetFile);
fseek(dll, S_RELEASE, SEEK_SET); fseek(targetFile, releaseNameAddr, SEEK_SET);
fwrite(zeros, sizeof(sRelease), 1, dll); fwrite(zeros, releaseNameLen, 1, targetFile);
fseek(dll, S_DLLNAME, SEEK_SET); fseek(targetFile, libraryNameAddr, SEEK_SET);
fwrite(zeros, sizeof(sDllName), 1, dll); fwrite(zeros, libraryNameLen, 1, targetFile);
fclose(dll); return 0;
MessageBox(0, "D2gfx.dll patched successfully.\n"
"PlugY, The Survival Kit uninstalled successfully.",
boxNameUnInstall, MB_OK | MB_ICONASTERISK);
exit(0);
} }
int main(int argc, char * argv[]) int main(int argc, char * argv[])
{ {
// if ((argc>1) && !strcmp(argv[1],"-u"))
#ifdef RESTORE #ifdef RESTORE
Unpatch(); bool unpatch = true;
#else #else
if ((argc>1) && !strcmp(argv[1], "-u")) bool unpatch = argc > 1 && strcmp(argv[1], "-u") == 0;
Unpatch();
else
Patch();
#endif #endif
int version = GetD2Version("Game.exe");
LPCSTR boxName = unpatch ? "Uninstall PlugY, The Survival Kit" : "Install PlugY, The Survival Kit";
LPCSTR targetFilename = version > V113d ? "Game.exe" : "D2gfx.dll";
if (version < V107 || version > V114d)
{
msgBox(boxName, MB_OK | MB_ICONEXCLAMATION,
"Current version of LoD (%s) isn't compatible with PlugY.\n\n"
"Please, install a patch between 1.09 and 1.13d or 1.14d.",
GetVersionString(version));
exit(0);
}
if (msgBox(boxName, MB_YESNO | MB_ICONQUESTION,
"This programm will modify %s file in current directory.\n"
"Before continue, you should backup it.\n\n"
"Do you want to modify %s to %s PlugY ?",
targetFilename, targetFilename, unpatch ? "remove": "install") == IDNO)
{
msgBox(boxName, MB_OK | MB_ICONASTERISK, "No changes made.");
exit(0);
}
FILE *targetFile;
if (fopen_s(&targetFile, targetFilename, "rb+"))
{
msgBox(boxName, MB_OK | MB_ICONEXCLAMATION,
"Can't open %s in read/write mode.\n"
"If Diablo II is running, can you close it and try again ?",
targetFilename, unpatch ? "remove": "install");
exit(0);
}
// Get size
loadCallerLen = sizeof(loadCallerNew);
freeCallerLen = sizeof(freeCallerNew);
loadDllLen = sizeof(loadDll);
freeDllLen = sizeof(freeDll);
libraryNameLen = strlen(libraryName) + 1;
initNameLen = strlen(initName) + 1;
releaseNameLen = strlen(releaseName) + 1;
// Get Addr
DWORD offsetPESignature;
fseek(targetFile, 0x3C, SEEK_SET);
fread(&offsetPESignature, sizeof(offsetPESignature), 1, targetFile);
DWORD sizeOfCode;
fseek(targetFile, offsetPESignature + 0x1C, SEEK_SET);
fread(&sizeOfCode, sizeof(sizeOfCode), 1, targetFile);
DWORD baseOfCode;
fseek(targetFile, offsetPESignature + 0x2C, SEEK_SET);
fread(&baseOfCode, sizeof(baseOfCode), 1, targetFile);
DWORD imageBase;
fseek(targetFile, offsetPESignature + 0x34, SEEK_SET);
fread(&imageBase, sizeof(imageBase), 1, targetFile);
DWORD sizeOfData;
fseek(targetFile, offsetPESignature + 0x150, SEEK_SET);
fread(&sizeOfData, sizeof(sizeOfData), 1, targetFile);
DWORD baseOfData;
fseek(targetFile, offsetPESignature + 0x154, SEEK_SET);
fread(&baseOfData, sizeof(baseOfData), 1, targetFile);
// Set Addr
DWORD loadLibraryAddr = imageBase;
DWORD freeLibraryAddr = imageBase;
DWORD getProcAddressAddr = imageBase;
DWORD handleAddr = imageBase + baseOfData + sizeOfData;
loadCallerAddr = 0;
freeCallerAddr = 0;
loadDllAddr = Align(baseOfCode + sizeOfCode - 0x100);
freeDllAddr = Align(loadDllAddr + sizeof(loadDll));
libraryNameAddr = Align(freeDllAddr + sizeof(freeDll));
initNameAddr = Align(libraryNameAddr + libraryNameLen);
releaseNameAddr = Align(initNameAddr + initNameLen);
switch (version)
{
case V107:
loadCallerAddr += 0x3882;
freeCallerAddr += 0x3A6C;
loadLibraryAddr += 0xC038;
freeLibraryAddr += 0xC040;
getProcAddressAddr += 0xC034;
break;
case V108:
case V109:
case V109b:
case V109d:
loadCallerAddr += 0x389B;
freeCallerAddr += 0x3A8C;
loadLibraryAddr += 0xC03C;
freeLibraryAddr += 0xC044;
getProcAddressAddr += 0xC038;
break;
case V110:
loadCallerAddr += 0x3870;
freeCallerAddr += 0x3A6D;
loadLibraryAddr += 0xC040;
freeLibraryAddr += 0xC048;
getProcAddressAddr += 0xC03C;
break;
case V111:
loadCallerAddr += 0x8B23;
freeCallerAddr += 0x8ACA;
loadLibraryAddr += 0xD11C;
freeLibraryAddr += 0xD12C;
getProcAddressAddr += 0xD120;
break;
case V111b:
loadCallerAddr += 0xB423;
freeCallerAddr += 0xB3CA;
loadLibraryAddr += 0xD11C;
freeLibraryAddr += 0xD12C;
getProcAddressAddr += 0xD120;
break;
case V112:
loadCallerAddr += 0x8F63;
freeCallerAddr += 0x8F0A;
loadLibraryAddr += 0xD11C;
freeLibraryAddr += 0xD12C;
getProcAddressAddr += 0xD120;
break;
case V113c:
loadCallerAddr += 0xB423;
freeCallerAddr += 0xB3CA;
loadLibraryAddr += 0xD11C;
freeLibraryAddr += 0xD12C;
getProcAddressAddr += 0xD120;
break;
case V113d:
loadCallerAddr += 0xAA03;
freeCallerAddr += 0xA9AA;
loadLibraryAddr += 0xD11C;
freeLibraryAddr += 0xD124;
getProcAddressAddr += 0xD120;
break;
case V114a:
loadCallerAddr += 0x1BCB;// Load advapi.dll
freeCallerAddr += 0xF375;// Free dbghelp.dll
loadLibraryAddr += 0x2CD118;
freeLibraryAddr += 0x2CD120;
getProcAddressAddr += 0x2CD11C;
break;
case V114b:
case V114c:
loadCallerAddr += 0x1BCB;// Load advapi.dll
freeCallerAddr += 0x6F75;// Free dbghelp.dll
loadLibraryAddr += 0x2CD11C;
freeLibraryAddr += 0x2CD124;
getProcAddressAddr += 0x2CD120;
break;
case V114d:
loadCallerAddr += 0x621C;// Load advapi.dll
freeCallerAddr += 0xB514;// Free dbghelp.dll
loadLibraryAddr += 0x2CC144;
freeLibraryAddr += 0x2CC14C;
getProcAddressAddr += 0x2CC148;
break;
default:
return false;
}
*(DWORD*)&loadCallerNew[2] = loadDllAddr - (loadCallerAddr + sizeof(loadCallerNew));
*(DWORD*)&loadCallerOld[2] = loadLibraryAddr;
*(DWORD*)&freeCallerNew[2] = freeDllAddr - (freeCallerAddr + sizeof(freeCallerNew));
*(DWORD*)&freeCallerOld[2] = freeLibraryAddr;
*(DWORD*)&loadDll[6] = loadLibraryAddr;
*(DWORD*)&loadDll[12] = imageBase + libraryNameAddr;
*(DWORD*)&loadDll[18] = loadLibraryAddr;
*(DWORD*)&loadDll[23] = handleAddr;
*(DWORD*)&loadDll[33] = imageBase + initNameAddr;
*(DWORD*)&loadDll[40] = getProcAddressAddr;
*(DWORD*)&loadDll[63] = getProcAddressAddr;
*(DWORD*)&freeDll[6] = freeLibraryAddr;
*(DWORD*)&freeDll[12] = handleAddr;
*(DWORD*)&freeDll[22] = imageBase + releaseNameAddr;
*(DWORD*)&freeDll[29] = getProcAddressAddr;
*(DWORD*)&freeDll[48] = getProcAddressAddr;
*(DWORD*)&freeDll[60] = freeLibraryAddr;
// Patch / Unpatch
int res;
if (unpatch)
res = Unpatch(targetFile);
else
res = Patch(targetFile);
fclose(targetFile);
if (res == 0)
msgBox(boxName, MB_OK | MB_ICONASTERISK,
"%s was modified.\n"
"PlugY, The Survival Kit %s.",
targetFilename, unpatch ? "is removed" : "is installed");
else if (res == 1)
msgBox(boxName, MB_OK | MB_ICONASTERISK,
"PlugY, The Survival Kit already %s.",
unpatch ? "uninstalled" : "installed");
else if (res == 2)
msgBox(boxName, MB_OK | MB_ICONASTERISK,
"File contents in %s isn't correct.\n"
"Unable to %s PlugY, The Survival Kit.",
targetFilename, unpatch ? "uninstall" : "install");
return 1; return 1;
} }
///////////////////////// END OF FILE ///////////////////////

10
PlugYInstall/PlugYInstall.rc
View File

@ -28,8 +28,8 @@ LANGUAGE LANG_FRENCH, SUBLANG_FRENCH
// //
VS_VERSION_INFO VERSIONINFO VS_VERSION_INFO VERSIONINFO
FILEVERSION 1,0,5,0 FILEVERSION 1,0,6,0
PRODUCTVERSION 1,0,5,0 PRODUCTVERSION 1,0,6,0
FILEFLAGSMASK 0x3fL FILEFLAGSMASK 0x3fL
#ifdef _DEBUG #ifdef _DEBUG
FILEFLAGS 0x1L FILEFLAGS 0x1L
@ -46,11 +46,11 @@ BEGIN
BEGIN BEGIN
VALUE "CompanyName", "Yohann Nicolas" VALUE "CompanyName", "Yohann Nicolas"
VALUE "FileDescription", "PlugY patcher" VALUE "FileDescription", "PlugY patcher"
VALUE "FileVersion", "1.0.5.0" VALUE "FileVersion", "1.0.6.0"
VALUE "LegalCopyright", "Copyright (C) 2017" VALUE "LegalCopyright", "Copyright (C) 2021"
VALUE "OriginalFilename", "PlugYInstall.exe" VALUE "OriginalFilename", "PlugYInstall.exe"
VALUE "ProductName", "PlugY, The Survival Kit" VALUE "ProductName", "PlugY, The Survival Kit"
VALUE "ProductVersion", "11.01" VALUE "ProductVersion", "14.03"
END END
END END
BLOCK "VarFileInfo" BLOCK "VarFileInfo"

BIN
PlugYInstall/PlugYInstall.suo
View File

Binary file not shown.

4
PlugYInstall/PlugYInstall.vcproj
View File

@ -159,7 +159,7 @@
/> />
<Tool <Tool
Name="VCPostBuildEventTool" Name="VCPostBuildEventTool"
CommandLine="copy &quot;$(TargetPath)&quot; &quot;..\PlugYInstaller\PatchD2gfxDll.exe&quot;" CommandLine="copy &quot;$(TargetPath)&quot; &quot;..\PlugYInstaller\PatchD2gfxDll.exe&quot;&#x0D;&#x0A;"
/> />
</Configuration> </Configuration>
<Configuration <Configuration
@ -235,7 +235,7 @@
/> />
<Tool <Tool
Name="VCPostBuildEventTool" Name="VCPostBuildEventTool"
CommandLine="copy &quot;$(TargetPath)&quot; &quot;..\PlugYInstaller\RestoreD2gfxDll.exe&quot;" CommandLine="copy &quot;$(TargetPath)&quot; &quot;..\PlugYInstaller\RestoreD2gfxDll.exe&quot;&#x0D;&#x0A;"
/> />
</Configuration> </Configuration>
</Configurations> </Configurations>

50
PlugYInstaller/PlugY.ini
View File

@ -5,7 +5,7 @@
; ; ; ;
; by Yohann Nicolas ; ; by Yohann Nicolas ;
; ; ; ;
; version 11.01 ; ; version 14.03 ;
; ; ; ;
;--------------------------------------------------------------------------------------; ;--------------------------------------------------------------------------------------;
@ -30,7 +30,7 @@ ActiveCheckMemory=1
[WINDOWED] [WINDOWED]
ActiveWindowed=0 ActiveWindowed=0
RemoveBorder=1 RemoveBorder=0
WindowOnTop=0 WindowOnTop=0
Maximized=0 Maximized=0
SetWindowPos=0 SetWindowPos=0
@ -38,7 +38,7 @@ X=0
Y=0 Y=0
Width=0 Width=0
Height=0 Height=0
LockMouseOnStartup=1 LockMouseOnStartup=0
[LANGUAGE] [LANGUAGE]
@ -49,7 +49,10 @@ SelectedLanguage=ENG
[SAVEPATH] [SAVEPATH]
ActiveSavePathChange=0 ActiveSavePathChange=0
SavePath=Save\Mod PlugY\ SavePath=Mod PlugY
ActiveAutoBackup=1
MaxBackupPerCharacter=20
[MAIN SCREEN] [MAIN SCREEN]
@ -68,11 +71,19 @@ ActiveMultiPageStash=1
NbPagesPerIndex=10 NbPagesPerIndex=10
NbPagesPerIndex2=100 NbPagesPerIndex2=100
MaxPersonnalPages=0 MaxPersonnalPages=0
AutoRenameStashPage=1
PersonalNormalPageColor=0
PersonalIndexPageColor=12
PersonalMainIndexPageColor=9
SharedNormalPageColor=4
SharedIndexPageColor=8
SharedMainIndexPageColor=1
ActiveSharedStash=1 ActiveSharedStash=1
ActiveSharedStashInMultiPlayer=0
SeparateHardcoreStash=1 SeparateHardcoreStash=1
OpenSharedStashOnLoading=0 OpenSharedStashOnLoading=0
displaySharedSetItemNameInGreen=1 DisplaySharedSetItemNameInGreen=1
MaxSharedPages=0 MaxSharedPages=0
ActiveSharedGold=1 ActiveSharedGold=1
@ -81,8 +92,8 @@ ActiveSharedGold=1
ActiveStatsUnassignment=1 ActiveStatsUnassignment=1
KeyUsed=18 KeyUsed=18
ActiveShiftClickLimit=0 ActiveShiftClickLimit=1
LimitValueToShiftClick=5 LimitValueToShiftClick=10
[SKILLS POINTS] [SKILLS POINTS]
@ -107,6 +118,24 @@ TimeBeforeAutoSellMax=1200
[UBER QUEST] [UBER QUEST]
ActiveUberQuest=1 ActiveUberQuest=1
UberMephistoX=25130
UberMephistoY=5143
UberDiabloX=25139
UberDiabloY=5139
UberBaalX=25139
UberBaalY=5135
ActiveUberMinions=1
UberMephistoSpawnPercent=80
UberMephistoSpawnRadius=30
UberBaalSpawnPercent=30
UberBaalSpawnRadius=30
UberDiabloSpawnPercent=30
UberDiabloSpawnRadius=30
ActiveUberDiabloRushTweekAI=1
ActiveUberBaalTeleportTweekAI=1
ActiveUberBaalChillingArmorTweekAI=1
UberBaalChillingArmorTimer=6000
[INTERFACE] [INTERFACE]
@ -117,15 +146,14 @@ SelectMainPageOnOpenning=1
[EXTRA] [EXTRA]
ActiveLaunchAnyNumberOfLOD=1 ActiveLaunchAnyNumberOfLOD=1
AlwaysRegenMapInSP=0 AlwaysRegenMapInSP=0
NBPlayersByDefault=0 NBPlayersByDefault=1
ActiveDisplayItemLevel=1 ActiveDisplayItemLevel=1
AlwaysDisplayLifeAndManaValues=0 AlwaysDisplayLifeAndManaValues=0
EnabledTXTFilesWhenMSExcelOpenIt=0 EnabledTXTFilesWhenMSExcelOpenIt=0
ActiveDisplayBaseStatsValue=1 ActiveDisplayBaseStatsValue=1
ActiveLadderRunewords=1 ActiveLadderRunewords=1
ActiveCowPortalWhenCowKingWasKilled=1 ActiveCowPortalWhenCowKingWasKilled=1
ActiveDoNotCloseNihlathakPortal=1
MoveCainNearHarrogathWaypoint=1
; More features later... :)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

138
PlugYInstaller/PlugY.nsi
View File

@ -1,8 +1,9 @@
; File created by Yohann NICOLAS. ; File created by Yohann NICOLAS.
; Modified by L'Autour. Unicode True
!include "MUI2.nsh" !include "MUI2.nsh"
!define VERSION "11.01" !define VERSION "v14.03"
!define D2FILES "." !define D2FILES "."
!define NAME "PlugY, The Survival Kit" !define NAME "PlugY, The Survival Kit"
!define MOD_DIR "Mod PlugY" !define MOD_DIR "Mod PlugY"
@ -10,6 +11,7 @@
!define UNINSTALL_FILE "PlugY Uninstaller.exe" !define UNINSTALL_FILE "PlugY Uninstaller.exe"
!define MUI_COMPONENTSPAGE_SMALLDESC !define MUI_COMPONENTSPAGE_SMALLDESC
!define MUI_ICON "..\PlugYRun\PlugY.ico"
!define MUI_HEADERIMAGE !define MUI_HEADERIMAGE
!define MUI_HEADERIMAGE_BITMAP "PlugYInstallerHeader.bmp" !define MUI_HEADERIMAGE_BITMAP "PlugYInstallerHeader.bmp"
!define MUI_LANGDLL_REGISTRY_ROOT HKLM !define MUI_LANGDLL_REGISTRY_ROOT HKLM
@ -25,8 +27,8 @@
!define MUI_ABORTWARNING !define MUI_ABORTWARNING
;!define MUI_UNABORTWARNING ;!define MUI_UNABORTWARNING
Name "${NAME} v${VERSION}" Name "${NAME} ${VERSION}"
OutFile "PlugY_The_Survival_Kit_v${VERSION}.exe" OutFile "PlugY_The_Survival_Kit_${VERSION}_Installer.exe"
InstallDirRegKey HKLM "${REGKEY}" "InstallPath" InstallDirRegKey HKLM "${REGKEY}" "InstallPath"
;-------------------------------- ;--------------------------------
@ -47,53 +49,79 @@ InstallDirRegKey HKLM "${REGKEY}" "InstallPath"
; Languages ; Languages
!insertmacro MUI_LANGUAGE "English" !insertmacro MUI_LANGUAGE "English"
!insertmacro MUI_LANGUAGE "French" !insertmacro MUI_LANGUAGE "French"
!insertmacro MUI_LANGUAGE "German"
!insertmacro MUI_LANGUAGE "Russian" !insertmacro MUI_LANGUAGE "Russian"
!insertmacro MUI_LANGUAGE "TradChinese"
LangString DESC_CORE ${LANG_ENGLISH} "Core files.$\nPlugY.dll will be installed in Diablo II directory." LangString DESC_CORE ${LANG_ENGLISH} "Core files.$\nPlugY.dll will be installed in Diablo II directory."
LangString DESC_CORE ${LANG_FRENCH} "Fichiers nécessaires.$\nPlugY.dll sera installé dans le répertoire de Diablo II." LangString DESC_CORE ${LANG_FRENCH} "Fichiers nécessaires.$\nPlugY.dll sera installé dans le répertoire de Diablo II."
LangString DESC_CORE ${LANG_RUSSIAN} "Îñíîâíûå ôàéëû.$\nPlugY.dll äîëæåí áûòü óñòàíîâëåí â êàòàëîã Diablo II." LangString DESC_CORE ${LANG_GERMAN} "Hauptdateien.$\nPlugY.dll wird in das Installationsverzeichnis von Diablo II installiert."
LangString DESC_CORE ${LANG_RUSSIAN} "Основные файлы.$\nPlugY.dll должен быть установлен в каталог Diablo II."
LangString DESC_CORE ${LANG_TRADCHINESE} "核心檔案。$\nPlugY.dll 將被安裝於 Diablo II 目錄。"
LangString DESC_DESKTOP_SHORTCUTS ${LANG_ENGLISH} "Add shortcut on Desktop to launch Diablo II with ${NAME}." LangString DESC_DESKTOP_SHORTCUTS ${LANG_ENGLISH} "Add shortcut on Desktop to launch Diablo II with ${NAME}."
LangString DESC_DESKTOP_SHORTCUTS ${LANG_FRENCH} "Ajoute un raccourci pour démarrer Diablo II avec ${NAME}." LangString DESC_DESKTOP_SHORTCUTS ${LANG_FRENCH} "Ajoute un raccourci pour démarrer Diablo II avec ${NAME}."
LangString DESC_DESKTOP_SHORTCUTS ${LANG_RUSSIAN} "Äîáàâèòü ÿðëûê íà ðàáî÷èé ñòîë äëÿ çàïóñêà Diablo II ñ ${NAME}." LangString DESC_DESKTOP_SHORTCUTS ${LANG_GERMAN} "Fügt eine Verknüpfung auf dem Desktop mit dem Namen ${NAME} hinzu mit der Diablo II gestartet werden kann."
LangString DESC_DESKTOP_SHORTCUTS ${LANG_RUSSIAN} "Добавить ярлык на рабочий стол для запуска Diablo II с ${NAME}."
LangString DESC_DESKTOP_SHORTCUTS ${LANG_TRADCHINESE} "在桌面新增捷徑以藉由 ${NAME} 執行 Diablo II。"
LangString DESC_MENU_SHORTCUTS ${LANG_ENGLISH} "Add shortcuts in start menu." LangString DESC_MENU_SHORTCUTS ${LANG_ENGLISH} "Add shortcuts in start menu."
LangString DESC_MENU_SHORTCUTS ${LANG_FRENCH} "Ajoute des raccourcis dans le menu démarrer." LangString DESC_MENU_SHORTCUTS ${LANG_FRENCH} "Ajoute des raccourcis dans le menu démarrer."
LangString DESC_MENU_SHORTCUTS ${LANG_RUSSIAN} "Äîáàâèòü ÿðëûêè â ãëàâíîå ìåíþ." LangString DESC_MENU_SHORTCUTS ${LANG_GERMAN} "Fügt Verknüpfungen im Startmenü hinzu."
LangString DESC_MENU_SHORTCUTS ${LANG_RUSSIAN} "Добавить ярлыки в главное меню."
LangString DESC_MENU_SHORTCUTS ${LANG_TRADCHINESE} "新增「開始」功能表捷徑"
LangString DESC_UNINSTALLER ${LANG_ENGLISH} "Create a Windows uninstall program.$\nAdding registry keys in Windows." LangString DESC_UNINSTALLER ${LANG_ENGLISH} "Create a Windows uninstall program.$\nAdding registry keys in Windows."
LangString DESC_UNINSTALLER ${LANG_FRENCH} "Crée un programme Windows de désinstallation.$\nAjoute des clés de registres dans Windows." LangString DESC_UNINSTALLER ${LANG_FRENCH} "Crée un programme Windows de désinstallation.$\nAjoute des clés de registres dans Windows."
LangString DESC_UNINSTALLER ${LANG_RUSSIAN} "Ñîçäàòü â Windows äåèíñòëëÿòîð ïðîãðàììû.$\nÄîáàâëÿåò êëþ÷è ðååñòðà â Windows." LangString DESC_UNINSTALLER ${LANG_GERMAN} "Erzeugt ein Deinstallationsprogramm.$\nWindows Registrierungseinträge werden erstellt."
LangString DESC_PATCH_D2GFX ${LANG_ENGLISH} "D2gfx.dll patcher to run PlugY without PlugY.exe. Before use it, you MUST read the readme." LangString DESC_UNINSTALLER ${LANG_RUSSIAN} "Создать в Windows деинстллятор программы.$\nДобавляет ключи реестра в Windows."
LangString DESC_PATCH_D2GFX ${LANG_FRENCH} "D2gfx.dll patcheur pour lancer PlugY sans PlugY.exe. Avant de l'utiliser, vous DEVEZ lire le LISEZ-MOI." LangString DESC_UNINSTALLER ${LANG_TRADCHINESE} "建立 Windows 解除安裝程式。$\n加入 Windows 登錄訊息。"
LangString DESC_PATCH_D2GFX ${LANG_RUSSIAN} "Ïðèìåíèòü ïàò÷ ê D2gfx.dll äëÿ çàïóñêà PlugY áåç PlugY.exe. Ïîäðîáíåå ñìîòðåòü â ôàéëå Readme." LangString DESC_PATCH_FILE ${LANG_ENGLISH} "Patcher to run PlugY without PlugY.exe. Before use it, you MUST read the readme."
LangString DESC_PATCH_FILE ${LANG_FRENCH} "Patcheur pour lancer PlugY sans PlugY.exe. Avant de l'utiliser, vous DEVEZ lire le LISEZ-MOI."
LangString DESC_PATCH_FILE ${LANG_GERMAN} "Patcher um PlugY ohne PlugY.exe zu starten.$\nDie LiesMich-Datei MUSS vor Benutzung gelesen werden."
LangString DESC_PATCH_FILE ${LANG_RUSSIAN} "Применить патч для запуска PlugY без PlugY.exe. Подробнее смотреть в файле Readme."
LangString DESC_PATCH_FILE ${LANG_TRADCHINESE} "更改遊戲檔案以不藉由 PlugY.exe 而執行 PlugY。使用前，您「必須」閱讀「讀我檔案」。"
LangString SECTION_NAME_CORE ${LANG_ENGLISH} "${NAME} (required)" LangString SECTION_NAME_CORE ${LANG_ENGLISH} "${NAME} (required)"
LangString SECTION_NAME_CORE ${LANG_FRENCH} "${NAME} (nécessaire)" LangString SECTION_NAME_CORE ${LANG_FRENCH} "${NAME} (nécessaire)"
LangString SECTION_NAME_CORE ${LANG_RUSSIAN} "${NAME} (òðåáóåòñÿ)" LangString SECTION_NAME_CORE ${LANG_GERMAN} "${NAME} (benötigt)"
LangString SECTION_NAME_CORE ${LANG_RUSSIAN} "${NAME} (требуется)"
LangString SECTION_NAME_CORE ${LANG_TRADCHINESE} "${NAME} (必要)"
LangString SECTION_NAME_DESKTOP_SHORTCUT ${LANG_ENGLISH} "Desktop Shortcut" LangString SECTION_NAME_DESKTOP_SHORTCUT ${LANG_ENGLISH} "Desktop Shortcut"
LangString SECTION_NAME_DESKTOP_SHORTCUT ${LANG_FRENCH} "Raccourci sur le bureau" LangString SECTION_NAME_DESKTOP_SHORTCUT ${LANG_FRENCH} "Raccourci sur le bureau"
LangString SECTION_NAME_DESKTOP_SHORTCUT ${LANG_RUSSIAN} "ßðëûê íà ðàáî÷åì ñòîëå" LangString SECTION_NAME_DESKTOP_SHORTCUT ${LANG_GERMAN} "Desktopverknüpfung"
LangString SECTION_NAME_DESKTOP_SHORTCUT ${LANG_RUSSIAN} "Ярлык на рабочем столе"
LangString SECTION_NAME_DESKTOP_SHORTCUT ${LANG_TRADCHINESE} "桌面捷徑"
LangString SECTION_NAME_STARTMENU_SHORTCUTS ${LANG_ENGLISH} "Start menu Shortcuts" LangString SECTION_NAME_STARTMENU_SHORTCUTS ${LANG_ENGLISH} "Start menu Shortcuts"
LangString SECTION_NAME_STARTMENU_SHORTCUTS ${LANG_FRENCH} "Raccourcis dans le Menu démarrer" LangString SECTION_NAME_STARTMENU_SHORTCUTS ${LANG_FRENCH} "Raccourcis dans le Menu démarrer"
LangString SECTION_NAME_STARTMENU_SHORTCUTS ${LANG_RUSSIAN} "ßðëûêè â â ãëàâíîì ìåíþ" LangString SECTION_NAME_STARTMENU_SHORTCUTS ${LANG_GERMAN} "Startmenüverknüpfungen"
LangString SECTION_NAME_STARTMENU_SHORTCUTS ${LANG_RUSSIAN} "Ярлыки в в главном меню"
LangString SECTION_NAME_STARTMENU_SHORTCUTS ${LANG_TRADCHINESE} "「開始」功能表捷徑"
LangString SECTION_NAME_UNINSTALLER ${LANG_ENGLISH} "Uninstaller (add keys registers)" LangString SECTION_NAME_UNINSTALLER ${LANG_ENGLISH} "Uninstaller (add keys registers)"
LangString SECTION_NAME_UNINSTALLER ${LANG_FRENCH} "Dé-installeur (ajoute clés de registre)" LangString SECTION_NAME_UNINSTALLER ${LANG_FRENCH} "Dé-installeur (ajoute clés de registre)"
LangString SECTION_NAME_UNINSTALLER ${LANG_RUSSIAN} "Äåèíñòàëëÿòîð (äîáàâëÿåò êëþ÷è ðååñòðà)" LangString SECTION_NAME_UNINSTALLER ${LANG_GERMAN} "Deinstallationsprogramm (Fügt Windows Registrierungseinträge hinzu)"
LangString SECTION_PATCH_D2GFX ${LANG_ENGLISH} "D2gfx.dll Patcher (advanced user only)" LangString SECTION_NAME_UNINSTALLER ${LANG_RUSSIAN} "Деинсталлятор (добавляет ключи реестра)"
LangString SECTION_PATCH_D2GFX ${LANG_FRENCH} "Patcheur de D2gfx.dll (utilisateur avancé uniquement)" LangString SECTION_NAME_UNINSTALLER ${LANG_TRADCHINESE} "移除工具 (加入登錄訊息)"
LangString SECTION_PATCH_D2GFX ${LANG_RUSSIAN} "Ïàò÷ äëÿ D2gfx.dll Patcher (äëÿ îïûòíûõ ïîëüçîâàòåëåé)" LangString SECTION_PATCH_FILE ${LANG_ENGLISH} "File Patcher (advanced user only)"
LangString SECTION_PATCH_FILE ${LANG_FRENCH} "Patcheur de fichier (utilisateur avancé uniquement)"
LangString SECTION_PATCH_FILE ${LANG_GERMAN} "Datei Patcher (Für erfahrene Nutzer)"
LangString SECTION_PATCH_FILE ${LANG_RUSSIAN} "Патч для Patcher (для опытных пользователей)"
LangString SECTION_PATCH_FILE ${LANG_TRADCHINESE} "檔案級補釘 (限高級用戶)"
LangString README_FILENAME ${LANG_ENGLISH} "PlugY_The_Survival_Kit_-_Readme.txt" LangString README_FILENAME ${LANG_ENGLISH} "PlugY_The_Survival_Kit_-_Readme.txt"
LangString README_FILENAME ${LANG_FRENCH} "PlugY_The_Survival_Kit_-_LisezMoi.txt" LangString README_FILENAME ${LANG_FRENCH} "PlugY_The_Survival_Kit_-_LisezMoi.txt"
LangString README_FILENAME ${LANG_GERMAN} "PlugY_The_Survival_Kit_-_Liesmich.txt"
LangString README_FILENAME ${LANG_RUSSIAN} "PlugY_The_Survival_Kit_-_Readme.txt" LangString README_FILENAME ${LANG_RUSSIAN} "PlugY_The_Survival_Kit_-_Readme.txt"
LangString README_FILENAME ${LANG_TRADCHINESE} "PlugY_The_Survival_Kit_-_讀我檔案"
LangString ERROR_NO_D2_DIRECTORY_FOUND ${LANG_ENGLISH} "Error : Diablo II install directory not found.$\nPlease re-install your copy of Diablo II - Lord of Destruction." LangString ERROR_NO_D2_DIRECTORY_FOUND ${LANG_ENGLISH} "Error : Diablo II install directory not found.$\nPlease re-install your copy of Diablo II - Lord of Destruction."
LangString ERROR_NO_D2_DIRECTORY_FOUND ${LANG_FRENCH} "Erreur : Le répertoire d'installation de Diablo II n'a pas été trouvé.$\nVeuillez ré-installer votre copie de Diablo II - Lord of Destruction." LangString ERROR_NO_D2_DIRECTORY_FOUND ${LANG_FRENCH} "Erreur : Le répertoire d'installation de Diablo II n'a pas été trouvé.$\nVeuillez ré-installer votre copie de Diablo II - Lord of Destruction."
LangString ERROR_NO_D2_DIRECTORY_FOUND ${LANG_RUSSIAN} "Îøèáêà : êàòàëîã ñ óñòàíîâëåííîé èãðîé Diablo II íå íàéäåí.$\nÏîæàëóéñòà ïåðåóñòàíîâèòå âàøó êîïèþ Diablo II - Lord of Destruction." LangString ERROR_NO_D2_DIRECTORY_FOUND ${LANG_GERMAN} "Fehler : Diablo II Installationsverzeichnis nicht gefunden.$\nBitte installiere Diablo II - Lord of Destruction neu."
LangString ERROR_NO_D2_DIRECTORY_FOUND ${LANG_RUSSIAN} "Ошибка : каталог с установленной игрой Diablo II не найден.$\nПожалуйста переустановите вашу копию Diablo II - Lord of Destruction."
LangString ERROR_NO_D2_DIRECTORY_FOUND ${LANG_TRADCHINESE} "錯誤: 找不到 Diablo II 安裝目錄$\n請重新安裝「暗黑破壞神II：毀滅之王」"
Var D2Path Var D2Path
;-------------------------------- ;--------------------------------
; Initialisation ; Initialisation
Function .onInit Function .onInit
!define MUI_LANGDLL_WINDOWTITLE "${NAME} v${VERSION}" !define MUI_LANGDLL_WINDOWTITLE "${NAME} ${VERSION}"
!define MUI_LANGDLL_INFO "Select your language:$\nChoisissez votre langue:" !define MUI_LANGDLL_INFO "Select your language:"
!insertmacro MUI_LANGDLL_DISPLAY !insertmacro MUI_LANGDLL_DISPLAY
!undef MUI_LANGDLL_WINDOWTITLE !undef MUI_LANGDLL_WINDOWTITLE
!undef MUI_LANGDLL_INFO !undef MUI_LANGDLL_INFO
@ -128,38 +156,6 @@ Function LaunchPlugY
ExecShell "" "$INSTDIR\PlugY.exe" ExecShell "" "$INSTDIR\PlugY.exe"
FunctionEnd FunctionEnd
;--------------------------------
; Custom Page
;Function OptionsPage
;StrCpy $INSTDIR "C:\temp\${NAME}"
; nsDialogs::Create /NOUNLOAD 1018
;Pop $D2Path
;GetFunctionAddress $D2Path OnBack
;nsDialogs::OnBack /NOUNLOAD $D2Path
;${NSD_CreateButton} 0 0 100% 12u Test
;Pop $BUTTON
;GetFunctionAddress $D2Path OnClick
;nsDialogs::OnClick /NOUNLOAD $BUTTON $D2Path
;${NSD_CreateText} 0 35 100% 12u hello
;Pop $EDIT
;GetFunctionAddress $D2Path OnChange
;nsDialogs::OnChange /NOUNLOAD $EDIT $D2Path
;${NSD_CreateCheckbox} 0 -50 100% 8u Test
;Pop $CHECKBOX
;GetFunctionAddress $D2Path OnCheckbox
;nsDialogs::OnClick /NOUNLOAD $CHECKBOX $D2Path
;${NSD_CreateLabel} 0 40u 75% 40u "* Type `hello there` above.$\n* Click the button.$\n* Check the checkbox.$\n* Hit the Back button."
;Pop $D2Path
; nsDialogs::Show
;FunctionEnd
InstType "Standard" InstType "Standard"
InstType "Minimal" InstType "Minimal"
@ -173,7 +169,8 @@ Section "!$(SECTION_NAME_CORE)" Core
File "${D2FILES}\PlugY_The_Survival_Kit_-_Readme.txt" File "${D2FILES}\PlugY_The_Survival_Kit_-_Readme.txt"
File "${D2FILES}\PlugY_The_Survival_Kit_-_LisezMoi.txt" File "${D2FILES}\PlugY_The_Survival_Kit_-_LisezMoi.txt"
File "${D2FILES}\PlugY_The_Survival_Kit_-_Liesmich.txt" File "${D2FILES}\PlugY_The_Survival_Kit_-_Liesmich.txt"
setOutPath "$D2Path\PlugY" File "${D2FILES}\PlugY_The_Survival_Kit_-_讀我檔案.txt"
setOutPath "$INSTDIR\PlugY"
File "${D2FILES}\PlugY\EmptyPage.dc6" File "${D2FILES}\PlugY\EmptyPage.dc6"
File "${D2FILES}\PlugY\PlugYDefault.ini" File "${D2FILES}\PlugY\PlugYDefault.ini"
File "${D2FILES}\PlugY\PlugYFixed.ini" File "${D2FILES}\PlugY\PlugYFixed.ini"
@ -222,10 +219,10 @@ Section $(SECTION_NAME_UNINSTALLER) Uninstaller
WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${NAME}" "NoRepair" 1 WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${NAME}" "NoRepair" 1
SectionEnd SectionEnd
Section $(SECTION_PATCH_D2GFX) PatchD2gfx Section $(SECTION_PATCH_FILE) PatchFile
SetOutPath $D2Path SetOutPath $D2Path
File "${D2FILES}\PatchD2gfxDll.exe" File "${D2FILES}\PatchD2File.exe"
File "${D2FILES}\RestoreD2gfxDll.exe" File "${D2FILES}\RestoreD2File.exe"
SectionEnd SectionEnd
;-------------------------------- ;--------------------------------
@ -242,8 +239,8 @@ Section "Uninstall" Uninstall
; Remove files and uninstaller ; Remove files and uninstaller
Delete "$D2Path\PlugY.dll" Delete "$D2Path\PlugY.dll"
Delete "$D2Path\PatchD2gfxDll.exe" Delete "$D2Path\PatchD2File.exe"
Delete "$D2Path\RestoreD2gfxDll.exe" Delete "$D2Path\RestoreD2File.exe"
Delete "$INSTDIR\PlugY.exe" Delete "$INSTDIR\PlugY.exe"
Delete "$INSTDIR\PlugY.log" Delete "$INSTDIR\PlugY.log"
Delete "$INSTDIR\BnetLog.txt" Delete "$INSTDIR\BnetLog.txt"
@ -251,6 +248,7 @@ Section "Uninstall" Uninstall
Delete "$INSTDIR\PlugY_The_Survival_Kit_-_Readme.txt" Delete "$INSTDIR\PlugY_The_Survival_Kit_-_Readme.txt"
Delete "$INSTDIR\PlugY_The_Survival_Kit_-_LisezMoi.txt" Delete "$INSTDIR\PlugY_The_Survival_Kit_-_LisezMoi.txt"
Delete "$INSTDIR\PlugY_The_Survival_Kit_-_Liesmich.txt" Delete "$INSTDIR\PlugY_The_Survival_Kit_-_Liesmich.txt"
Delete "$INSTDIR\PlugY_The_Survival_Kit_-_讀我檔案.txt"
Delete "$D2Path\PlugY\EmptyPage.dc6" Delete "$D2Path\PlugY\EmptyPage.dc6"
Delete "$D2Path\PlugY\PlugYDefault.ini" Delete "$D2Path\PlugY\PlugYDefault.ini"
Delete "$D2Path\PlugY\PlugYFixed.ini" Delete "$D2Path\PlugY\PlugYFixed.ini"
@ -267,13 +265,11 @@ Section "Uninstall" Uninstall
RMDir "$INSTDIR" RMDir "$INSTDIR"
SectionEnd SectionEnd
!insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN !insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
!insertmacro MUI_DESCRIPTION_TEXT "${Core}" $(DESC_CORE) !insertmacro MUI_DESCRIPTION_TEXT "${Core}" $(DESC_CORE)
!insertmacro MUI_DESCRIPTION_TEXT "${DesktopShortcuts}" $(DESC_DESKTOP_SHORTCUTS) !insertmacro MUI_DESCRIPTION_TEXT "${DesktopShortcuts}" $(DESC_DESKTOP_SHORTCUTS)
!insertmacro MUI_DESCRIPTION_TEXT "${MenuShortcuts}" $(DESC_MENU_SHORTCUTS) !insertmacro MUI_DESCRIPTION_TEXT "${MenuShortcuts}" $(DESC_MENU_SHORTCUTS)
!insertmacro MUI_DESCRIPTION_TEXT "${PatchD2gfx}" $(DESC_PATCH_D2GFX) !insertmacro MUI_DESCRIPTION_TEXT "${PatchFile}" $(DESC_PATCH_FILE)
!insertmacro MUI_DESCRIPTION_TEXT "${Uninstaller}" $(DESC_UNINSTALLER) !insertmacro MUI_DESCRIPTION_TEXT "${Uninstaller}" $(DESC_UNINSTALLER)
!insertmacro MUI_FUNCTION_DESCRIPTION_END !insertmacro MUI_FUNCTION_DESCRIPTION_END

BIN
PlugYInstaller/PlugY/LocalizedStrings.ini
View File

Binary file not shown.

66
PlugYInstaller/PlugY/PlugYDefault.ini
View File

@ -6,7 +6,7 @@
; ; ; ;
; by Yohann Nicolas ; ; by Yohann Nicolas ;
; ; ; ;
; version 11.01 ; ; version 14.03 ;
; ; ; ;
;--------------------------------------------------------------------------------------; ;--------------------------------------------------------------------------------------;
@ -14,6 +14,10 @@
; Voir le fichier PlugY_The_Survival_Kit_-_LisezMoi.txt pour plus d'information. ; Voir le fichier PlugY_The_Survival_Kit_-_LisezMoi.txt pour plus d'information.
; Siehe PlugY_The_Survival_Kit_-_Liesmich.txt für weitere Informationen ; Siehe PlugY_The_Survival_Kit_-_Liesmich.txt für weitere Informationen
[LAUNCHING]
Param=
Library=PlugY.dll
[GENERAL] [GENERAL]
ActivePlugin=1 ActivePlugin=1
@ -51,7 +55,10 @@ AvailableLanguages=ENG|ESP|DEU|FRA|POR|ITA|JPN|KOR|SIN|CHI|POL|RUS
[SAVEPATH] [SAVEPATH]
ActiveSavePathChange=0 ActiveSavePathChange=0
SavePath=Save\ SavePath=
ActiveAutoBackup=0
MaxBackupPerCharacter=20
[MAIN SCREEN] [MAIN SCREEN]
@ -70,29 +77,59 @@ ActiveMultiPageStash=0
NbPagesPerIndex=10 NbPagesPerIndex=10
NbPagesPerIndex2=100 NbPagesPerIndex2=100
MaxPersonnalPages=0 MaxPersonnalPages=0
AutoRenameStashPage=0
PersonalNormalPageColor=0
PersonalIndexPageColor=12
PersonalMainIndexPageColor=9
SharedNormalPageColor=4
SharedIndexPageColor=8
SharedMainIndexPageColor=1
ActiveSharedStash=0 ActiveSharedStash=0
ActiveSharedStashInMultiPlayer=0
SeparateHardcoreStash=1 SeparateHardcoreStash=1
OpenSharedStashOnLoading=0 OpenSharedStashOnLoading=0
SharedStashFilename=SharedStashSave SharedStashFilename=SharedStashSave
displaySharedSetItemNameInGreen=1 DisplaySharedSetItemNameInGreen=1
MaxSharedPages=0 MaxSharedPages=0
ActiveSharedGold=1 ActiveSharedGold=1
PosXPreviousBtn=-1 PosXPreviousBtn=-1
PosYPreviousBtn=-1 PosYPreviousBtn=-1
PosWPreviousBtn=32
PosHPreviousBtn=32
PosXNextBtn=-1 PosXNextBtn=-1
PosYNextBtn=-1 PosYNextBtn=-1
PosWNextBtn=32
PosHNextBtn=32
PosXSharedBtn=-1 PosXSharedBtn=-1
PosYSharedBtn=-1 PosYSharedBtn=-1
PosWSharedBtn=32
PosHSharedBtn=32
PosXPreviousIndexBtn=-1 PosXPreviousIndexBtn=-1
PosYPreviousIndexBtn=-1 PosYPreviousIndexBtn=-1
PosWPreviousIndexBtn=32
PosHPreviousIndexBtn=32
PosXNextIndexBtn=-1 PosXNextIndexBtn=-1
PosYNextIndexBtn=-1 PosYNextIndexBtn=-1
PosWNextIndexBtn=32
PosHNextIndexBtn=32
PosXPutGoldBtn=-1 PosXPutGoldBtn=-1
PosYPutGoldBtn=-1 PosYPutGoldBtn=-1
PosWPutGoldBtn=32
PosHPutGoldBtn=32
PosXTakeGoldBtn=-1 PosXTakeGoldBtn=-1
PosYTakeGoldBtn=-1 PosYTakeGoldBtn=-1
PosWTakeGoldBtn=32
PosHTakeGoldBtn=32
PosXStashNameField=-1
PosYStashNameField=-1
PosWStashNameField=175
PosHStashNameField=20
PosXStashGoldField=-1
PosYStashGoldField=-1
PosWStashGoldField=152
PosHStashGoldField=18
[STATS POINTS] [STATS POINTS]
@ -137,6 +174,24 @@ TimeBeforeAutoSellMax=1200
[UBER QUEST] [UBER QUEST]
ActiveUberQuest=0 ActiveUberQuest=0
UberMephistoX=25130
UberMephistoY=5143
UberDiabloX=25139
UberDiabloY=5139
UberBaalX=25139
UberBaalY=5135
ActiveUberMinions=1
UberMephistoSpawnPercent=80
UberMephistoSpawnRadius=30
UberBaalSpawnPercent=30
UberBaalSpawnRadius=30
UberDiabloSpawnPercent=30
UberDiabloSpawnRadius=30
ActiveUberDiabloRushTweekAI=1
ActiveUberBaalTeleportTweekAI=1
ActiveUberBaalChillingArmorTweekAI=1
UberBaalChillingArmorTimer=6000
[INTERFACE] [INTERFACE]
@ -155,8 +210,7 @@ EnabledTXTFilesWhenMSExcelOpenIt=0
ActiveDisplayBaseStatsValue=0 ActiveDisplayBaseStatsValue=0
ActiveLadderRunewords=0 ActiveLadderRunewords=0
ActiveCowPortalWhenCowKingWasKilled=0 ActiveCowPortalWhenCowKingWasKilled=0
ActiveDoNotCloseNihlathakPortal=0
MoveCainNearHarrogathWaypoint=0
; More features later... :)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

2
PlugYInstaller/PlugY/PlugYFixed.ini
View File

@ -6,7 +6,7 @@
; ; ; ;
; by Yohann Nicolas ; ; by Yohann Nicolas ;
; ; ; ;
; version 11.01 ; ; version 14.03 ;
; ; ; ;
;--------------------------------------------------------------------------------------; ;--------------------------------------------------------------------------------------;

2
PlugYInstaller/PlugY/statsinterface.txt
View File

@ -40,3 +40,5 @@ item_absorbfire_percent 1 2 25 175 1 6 142 0
item_absorbcold_percent 1 2 25 160 3 6 148 0 item_absorbcold_percent 1 2 25 160 3 6 148 0
item_absorblight_percent 1 2 25 145 9 6 144 0 item_absorblight_percent 1 2 25 145 9 6 144 0
item_poisonlengthresist 1 2 25 130 2 6 110 0 item_poisonlengthresist 1 2 25 130 2 6 110 0
player breakpoints 1 3 25 445 1 10000 0
mercenaries breakpoints 1 4 25 445 1 10001 0

1018
PlugYInstaller/PlugY_The_Survival_Kit_-_Liesmich.txt
View File

File diff suppressed because it is too large Load Diff

975
PlugYInstaller/PlugY_The_Survival_Kit_-_LisezMoi.txt
View File

File diff suppressed because it is too large Load Diff

407
PlugYInstaller/PlugY_The_Survival_Kit_-_Readme.txt
View File

@ -4,7 +4,7 @@
; ; ; ;
; by Yohann Nicolas ; ; by Yohann Nicolas ;
; ; ; ;
; version 11.01 ; ; version 14.03 ;
; ; ; ;
;--------------------------------------------------------------------------------------; ;--------------------------------------------------------------------------------------;
@ -13,12 +13,10 @@ You can make a donation if you want.
******** WARNING ******** ******** WARNING ********
- This plug-in works with LoD version 1.09 to 1.13d and mods based on. - This plug-in works with LoD version 1.09 to 1.13d and 1.14d and mods based on.
- This plug-in doesn't work on realms Battle.net. - This plug-in doesn't work on Battle.net and others realms.
- All files may be changed since previous version, so uninstall any previous version. - All files have changed since previous version. Please don't use old files.
- PlugY.ini has changed since previous version, use the one in this package. - LOD 1.14 change the save directory, so you must move PlugY save files manually.
- Don't forget to read the PlugY forum at :
http://d2mods.info/forum/viewforum.php?f=133
******** FEATURES ******** ******** FEATURES ********
@ -26,62 +24,129 @@ Each features can be turn on/off via PlugY.ini (see "COMMENTS ON THE CONFIGURATI
- Disable access to Battle.net. - Disable access to Battle.net.
- Infinite storage space in the stash. - Infinite storage space in the stash.
- Shared storage space in the stash. - Shared storage space in the stash.
- Enabled the ladder only runewords out of realms. - Enable the ladder only runewords for singleplayer and TCP/IP game.
- Local World Event and Uber Quest for singleplayer and multiplayer off-realm ! - World Event and Uber Quest for singleplayer and TCP/IP game.
- Can open Cow Level Portal even when player have kill the Cow King in that difficulty. - Can open Cow Level Portal even when player have kill the Cow King in that difficulty.
- Prevent Nihlathak's portal from closing.
- Move Deckar Cain near the waypoint in Harrogath.
- Unassign assigned skills and stats points. - Unassign assigned skills and stats points.
- Auto backup save files before saving.
- Change the selected language. - Change the selected language.
- Always regenerate maps in SinglePlayer like in MultiPlayer. - Always regenerate maps in SinglePlayer like in MultiPlayer.
- Automatically execute /players X when you launch a new game. - Automatically execute /players X when you launch a new game.
- Added some pages for display more characters stats like %MF. - Added some pages for display more characters stats.
- Display item level in its popup. - Display item level in its popup.
- Launch any number of Diablo II games on the same computer. - Launch any number of Diablo II games on the same computer.
- Increase the stash to 10x10 squares. - Increase the stash to 10x10 squares.
- Change the save path directory. - Change the save path directory.
- Always display Mana and Life values above the globes. - Always display Mana and Life values above the globes.
- D2 can load all files, even those opened with Microsoft Excel (disabled by default). - D2 can load all files, even those opened with Microsoft Excel (disabled by default).
- Display the stats current value (without magical bonus) like Magic/gold find or maximum resistances. - Display the current stats value (without magical bonus).
- Can launch game in windowed mode with some options (lock mouse/resize/on top/noborder). - Can launch game in windowed mode.
- Add following commands (see "COMMENTS ON THE CONFIGURATION FILE") : - Add following commands (see "COMMENTS ON THE CONFIGURATION FILE") :
/save : Save game without exit.
/page 1 : Show normal stats page (stats page must be opened).
/page 2 : Show extra stats page (stats page must be opened).
/page 3 : Show resistance stats page (stats page must be opened).
/page 4 : (beta) Show available runewords (stats page must be opened).
/lockmouse : Lock mouse cursor in the window. /lockmouse : Lock mouse cursor in the window.
/lock : Same as /lockmouse. /lock : Same as /lockmouse.
/unlockmouse : Unlock mouse cursor in the window. /unlockmouse : Unlock mouse cursor in the window.
/unlock : Same as /unlockmouse. /unlock : Same as /unlockmouse.
/renamechar newname : Rename your character and save it. /renamepage name : Rename current page stash (use # for page number).
/renamepage name : Rename current page stash. /rp name : See /renamepage.
/setindex : Set current stash page as index /setindex : Set current stash page as index.
/setmainindex : Set current stash page as main index.
/resetindex : Remove index flag on the current stash page. /resetindex : Remove index flag on the current stash page.
/insertpage : Insert a new page after the current page. /insertpage : Insert a new page after the current page.
/ip : See /insertpage.
/deletepage : Delete current page if empty. /deletepage : Delete current page if empty.
/swap page : Swap the content of current stash page with the content of another page. /dp : See /deletepage.
/toggle page : Swap the content of current stash page with the content of another page in opposing stash shared/personal. /swappage page : Swap the content of current stash page with the content of another page.
/sp page : See /swappage.
/togglepage page : Swap the content of current stash page with the content of another page in opposing stash shared/personal.
/tp page : See /togglepage.
/dlm : Toggle always display mana and life mode. /dlm : Toggle always display mana and life mode.
/dml : Same as /dlm. /dml : See /dlm.
/dl : Toggle always display life mode. /dl : See /dlm.
/dm : Toggle always display mana mode. /dm : See /dlm.
/page 1 : Show normal stats page (stats page must be opened).
/page 2 : Show extra stats page (stats page must be opened).
/page 3 : Show resistance stats page (stats page must be opened).
/page 4 : Show player breakpoints (stats page must be opened).
/page 5 : Show mercenaries breakpoints (stats page must be opened).
/page 6 : (beta) Show available runewords (stats page must be opened).
/save : (beta) Save game without exit.
/listcube : (beta) Create a "cube.txt" file in save directory containing all cube's receipts. /listcube : (beta) Create a "cube.txt" file in save directory containing all cube's receipts.
/renamechar newname : (beta) Rename your character and save it.
v14.03 changes :
- Fix a items diplay bug when only one stash page is filled.
- Add Korean Translation.
v14.02 changes :
- Fix a bug allowing multiple identical unique charms to be in inventory.
v14.01 changes :
- Fix stash items lost on loading a character for the first time.
v14.00 changes :
- Add compatibility with LOD 1.14d. (Thanks to Haxifix)
- Add auto backup save files before saving.
- Prevent Nihlathak's portal from closing.
- Move Deckar Cain near the waypoint in Harrogath.
- Change UberDiablo, UberBaal and UberMephisto starting positions in Uber Tristram.
- UberDiablo, UberBaal and UberMephisto can spawn monsters (Need LOD 1.13c or higher). (Thanks to SnapChip)
- Update UberDiablo, UberBaal and UberMephisto AI (Need LOD 1.13c or higher). (Thanks to SnapChip)
- Add player and mercenaries breakpoints in stats page 4 and 5.
- Disable shared stash in multiplayer by default.
- Change stash page color dependings of indexes flags.
- Increase the maximum length of stash page name from 15 to 20 characters.
- Enable automatic stash page naming.
- Click on page stash name to change index type.
- Shift + click on page stash name to rename it.
- Rename /swap command to /swappage.
- Rename /toggle command to /togglepage.
- Add /rp command as shortcut for /renamepage.
- Add /ip command as shortcut for /insertpage.
- Add /dp command as shortcut for /deletepage.
- Add /sp command as shortcut for /swappage.
- Add /tp command as shortcut for /togglepage.
- The relative folder for SavePath is now the D2 save folder instead of D2 install path.
- Now, the PlugY folder must be in the same directory as PlugY.ini (so in the mod folder).
- Optimize PlugY time loading and infinite stash time loading.
- Fix minimum SOJ sold value for the World Event.
- Fix crash of /swappage command when the target page wasn't created.
- Fix possible crash with stash name allocation. (Thanks to SnapChip)
- Fix NBPlayersByDefault when MultiStash was disabled.
- Fix crash when SkillsUnassignment, StatsUnassignment, NewStatsInterface, BigStash and MultiPageStash was disabled.
- Fix ActiveSkillsUnassignmentOneForOne Feature (option for mods).
- Fix crash in Polish version language.
- Fix the /players anormal message au startup.
- Fix the abnormal message that sometimes appears when starting a game with the NBPlayersByDefault option.
- Fix compatibility issue between NBPlayersByDefault option and D2MultiRes mod.
- More stash buttons parameters in PlugY (option for mods).
- Update Chinese transalation. (Thanks to Nagahaku)
- Fix some translations in different languages.
v12.00 changes :
- Unofficial version supporting LOD 1.14d
v11.02 changes :
- Add command /setmainindex : Set the current stash page as main index (shift + prev/next index button go to an main index if exists)
- Current number of simulated players use with /players command is save with the player and set on game loading. NBPlayersByDefault must be different to 0 in PlugY.ini.
v11.01 changes : v11.01 changes :
Compatibily with 1.13d (thanks to L'Autour) - Compatibily with 1.13d (thanks to L'Autour)
Add command /unlockmouse : Unlock the mouse - Add command /unlockmouse : Unlock the mouse
Add command /unlock : same as /unlockmouse - Add command /unlock : same as /unlockmouse
Add command /renamepage : stash page name are succefully saved. - Add command /renamepage : stash page name are succefully saved.
Add command /setindex : Set the current stash page as index (prev/next index button go to an index if exists) - Add command /setindex : Set the current stash page as index (prev/next index button go to an index if exists)
Add command /resetindex : Remove index flag on the current stash page (prev/next index button go to this index if exists). - Add command /resetindex : Remove index flag on the current stash page (prev/next index button go to this index if exists).
Add command /insertpage : Insert a new page after the current page. - Add command /insertpage : Insert a new page after the current page.
Add command /deletepage : Delete current page if empty. - Add command /deletepage : Delete current page if empty.
Add localizion in Russian and google traduction for not translated language. (thanks to L'Autour) - Add localizion in Russian and google traduction for not translated language. (thanks to L'Autour)
Add an option in PlugY.ini to select shared stash (instead of personal one) on character loading. - Add an option in PlugY.ini to select shared stash (instead of personal one) on character loading.
Rename command /rename to /renamechar. - Rename command /rename to /renamechar.
Remove unfinished command /reload. - Remove unfinished command /reload.
v11.00 changes : Unofficial version supporting LOD 1.13d v11.00 changes :
- Unofficial version supporting LOD 1.13d
v10.01 changes : v10.01 changes :
- Add windowed mode. - Add windowed mode.
@ -343,10 +408,11 @@ v1.00 features (can all be easily enabled or disabled) :
******** CONTENTS ******** ******** CONTENTS ********
19 files, 1 folder : 20 files, 1 folder :
- PlugY_The_Survival_Kit_-_Readme.txt - PlugY_The_Survival_Kit_-_Readme.txt
- PlugY_The_Survival_Kit_-_LisezMoi.txt - PlugY_The_Survival_Kit_-_LisezMoi.txt
- PlugY_The_Survival_Kit_-_Liesmich.txt - PlugY_The_Survival_Kit_-_Liesmich.txt
- PlugY_The_Survival_Kit_-_讀我檔案.txt
- PlugY.exe - PlugY.exe
- PlugY.dll (in Diablo II directory) - PlugY.dll (in Diablo II directory)
- PlugY.ini - PlugY.ini
@ -361,9 +427,8 @@ v1.00 features (can all be easily enabled or disabled) :
- PlugY\UnassignSkillsBtns.dc6 - PlugY\UnassignSkillsBtns.dc6
- PlugY\UnassignStatsBtns.dc6 - PlugY\UnassignStatsBtns.dc6
- PlugY\statsinterface.txt - PlugY\statsinterface.txt
- PlugY Uninstaller.exe (with uninstaller option) - PatchD2File.exe (in Diablo II directory with PatchFile option)
- PatchD2gfxDll.exe (in Diablo II directory with Patcher D2gfxDll option) - RestoreD2File.exe (in Diablo II directory with PatchFile option)
- RestoreD2gfxDll.exe (in Diablo II directory with Patcher D2gfxDll option)
@ -376,14 +441,13 @@ note : You can choice "Diablo II" directory as install directory.
Installation in another mod: Installation in another mod:
- Copy PlugY.ini, PlugY.exe and PlugY folder (+its contents) in the targeted mod folder. - Copy PlugY.ini, PlugY.exe and PlugY folder (+its contents) in the targeted mod folder.
- Edit PlugY.ini to configure some features (see section below). - Edit PlugY.ini to configure some features (see section below).
- Run PlugY.exe and enjoy :) - Run PlugY.exe.
note : you can move the "PlugY" folder in "Diablo II" and it will be see by all PlugY installation.
Example : Example :
You have installed Lord of Destruction here : C:\Games\Diablo II\ You have installed Lord of Destruction in : C:\Games\Diablo II\
And the mod to add this plug-in is here : D:\D2Mod\MyMod\ And the target mod is in : D:\D2Mod\MyMod\
And the second mod to add this plug-in is here : D:\D2Mod\MyMod2\ And the second mod is in : D:\D2Mod\MyMod2\
So the new installation is : So the new installation is :
C:\Games\Diablo II\PlugY.dll C:\Games\Diablo II\PlugY.dll
D:\D2Mod\MyMod\PlugY\SharedGoldBtns.dc6 D:\D2Mod\MyMod\PlugY\SharedGoldBtns.dc6
@ -416,127 +480,86 @@ So the new installation is :
D:\D2Mod\MyMod2\PlugY.exe D:\D2Mod\MyMod2\PlugY.exe
Uninstallation : Use the uninstaller or if you have check this option, simply remove all PlugY files ! Uninstallation : Use the uninstaller or simply remove all PlugY files.
Note : You can also move PlugY.dll in the mod folder but you must remove any on in D2 folder. Note : You can also move PlugY.dll in the mod folder but you must remove any on in D2 folder.
Note : PlugY directory and its contents can be put in a mpq. Note : PlugY directory and its contents can be put in a mpq.
------- D2gfx Patcher : ------- D2File Patcher
If you have problem when you run PlugY.exe then use PatchD2gfxDll.exe. (It happend sometimes with Windows 2000) If you have problem when you run PlugY.exe then use PatchD2File.exe. (It happend sometimes with Windows 2000)
- Go in Diablo II directory. - Do a backup of D2gfx.dll or game.exe.
- Do a backup of D2gfx.dll (in the case, you remove PlugY before restore it) - Run PatchD2File.exe which modify D2gfx.dll or Game.exe.
- Run PatchD2gfxDll.exe (which patches D2gfx.dll for launch PlugY)
- Create a shortcut : Enter target mod directory in "start in" field of properties->shortcut. (unless you install PlugY in Diablo II directory) - Create a shortcut : Enter target mod directory in "start in" field of properties->shortcut. (unless you install PlugY in Diablo II directory)
- Launch with the shorcut !! - Launch with the shorcut !
Before uninstall PlugY Restore your D2gfx.dll with your backup file or run RestoreD2gfxDll.exe.
******************** FAQ ****************** ******************** FAQ ******************
=> I can't find the PlugY.ini file, where is it ? => I can't find PlugY.ini file, where is it ?
>From kingpin : In Windows Explorer, selecting Tools->Folder Options->View.
Microsoft has in their OS hidden known extensions. This is to make sure newbie Mark "Show Hidden files and Folders".
users do not delete those files by accident. You can, of course, turn this off by Unmark "Hide extensions for know file types".
opening up your Windows Explorer, selecting Tools->Folder Options. Then choose View and
mark "Show Hidden files and Folders". Unmark "Hide extensions for know file types".
Then you will for sure see the ini file. Then you will for sure see the ini file.
=> How do I Play sometimes on Battle.net when PlugY is installed ? => How do I Play sometimes on Battle.net when PlugY is installed ?
PlugY automatically disables features on realm. PlugY disable the connection to Battle.net.
But it's always recommended to disable any third software when you go on realm.
Note : When bigStash is enabled, you must restart D2 for play in single/multi/open after playing in closed Bnet (and vice versa).
Tips : Make a shorcut and add -skiptobnet at the of the "target" field for directly go to Battle.net.
=> What do I do if I have an error like "Bad Generic File" on loading a new Character ? => What do I do if I have an error like "Bad Generic File" on loading a new Character ?
This can appear when you have bad item in the shared stash file. This can appear when you have bad item in the shared stash file.
A possible cause is to use same save folder for different mod, in this case just change the save folder in PlugY.ini. A possible cause is to use same save folder for different mod.
In this case, just change the save folder in PlugY.ini.
You can also move the _LOD_SharedStashSave.sss and _LOD_HC_SharedStashSave.sss to another directory. You can also move the _LOD_SharedStashSave.sss and _LOD_HC_SharedStashSave.sss to another directory.
=> I get "sUnitItemInsertItemInvGridBase failed at 1046 in C:\projects\D2\head\Diablo2\Source\D2Client\UNIT\Item.cpp" in D2YYMMDD.txt, what I should do ? => I get "sUnitItemInsertItemInvGridBase failed at 1046 in C:\projects\D2\head\Diablo2\Source\D2Client\UNIT\Item.cpp" in D2YYMMDD.txt, what I should do ?
It's just a warning, don't worry about it, it causes no problem in game. It's just a warning, it causes no problem in game.
=> I have another bug, what should I do ?
1) Read my thread and post a question eventually in PhrozenKeep member annoucement forum.
2) Search on google, ask to your friend, etc but don't ask me, I have no more time to support PlugY.
If one day, I got enough time (like for the version 8.00) I will check forums to get the more commons problems.
Thx
******** CONFIGURATION ******** ******** CONFIGURATION ********
Configuration of this kit for a specified mod : Configuration of this kit for a specified mod :
- Copy the PlugY.ini and PlugY.exe in the target mod directory (the directory where you start it, see it in the properties of the shortcut). - Copy PlugY.ini, PlugY.exe and PlugY folder in the target mod directory.
- In most cases, you will change the save directory in the ini file. - Change the save directory in PlugY.ini.
- Add all extra dll of the mod in PlugY.ini, if any.
- Finally, activate any specific features you want such as MultiPageStash, SharedStash, etc.
- Now, you can start the target mod using the classic method.
D2Mod configuration : D2Mod configuration :
Just add the dll name in PlugY.ini, for example : "DllToLoad=D2Mod.dll" Just add the dll name in PlugY.ini, for example : "DllToLoad=D2Mod.dll"
Note:
- Items in the Cube are always saved on the player, if you want these items shared, you must remove them from the Cube.
Warning : Warning :
- Be careful if you want to edit the configurations files after having played with the mod. - Items stored in the Cube are always saved on the player, if you want to shared them, you must remove them from the Cube.
- In multiplayer game, verify that the server has the same configuration. - Be careful about compatibility if you edit PlugY.inin between 2 games.
- Remember : PlugY doesn't support realms. - In multiplayer game, verify that all player have the same configurations in PlugY.ini.
*** Configuration for modders *** *** Configuration for modders ***
There are 3 files with same structure to configure PlugY : There are 3 files with same structure to configure PlugY :
- "PlugY/PlugYFixed.ini" in mpq or via the switch -direct - "PlugY/PlugYFixed.ini" in mpq or via the switch -direct
All fields set parameters which can't be changed by users via PlugY.ini. This file override parameters set by users in PlugY.ini.
Use it for enabling(disabling) wanted(unwanted) features. Use it to enabled(disabled) wanted(unwanted) features.
Only few thing should be found here.
Warning 1: ActivePlugin=0 doesn't work here (but ActivePlugin=1 works) Warning 1: ActivePlugin=0 doesn't work here (but ActivePlugin=1 works)
Warning 2: SavePath management doesn't work here too. Warning 2: SavePath management is ignore in this file.
Warning 3: Don't abuse it, a lot of field should be set by users. (see note below) Warning 3: Don't abuse it, a lot of field should be set by users. (see note below)
- "PlugY/PlugYDefault.ini" in mpq or via the switch -direct - "PlugY/PlugYDefault.ini" in mpq or via the switch -direct
Use it for changing default values of PlugY. Use it to change default values of PlugY.
Works like PlugY.ini in an mpq in version 4.03 and before. Works like PlugY.ini in an mpq in version 4.03 and before.
All fields which aren't in PlugYFixed.ini (and are always readed) should be here. All fields should be here.
Most fields should be put here.
- "PlugY.ini" in current directory only. - "PlugY.ini" in current directory only.
For users' configuration (like previous version). For users' configuration (like previous version).
Fields which are in PlugYFixed.ini shouldn't be found here. Fields which are in PlugYFixed.ini shouldn't be found here.
In most cases, this file is the same as PlugYDefault.ini but it can be edited by user.
Notes:
Think about each features if you really must disable it.
- The savepath management doesn't work in Fixed.ini (it's users' choice where they want to put their save files)
- The unassignment of skills can really be useful way to learn all your custom skills. I have stopped playing some mods just because I don't know what skill will be useful at very high level. It's more fun to try all skills and do the choosing after that. So don't put it in Fixed.ini
- The World Event should be configured or disabled in Fixed.ini in each mod.
- The extra pages in stats interfaces shouldn't be put in Fixed.ini
Modders can contact me, if they want help or more details about this system.
WARNING : Don't forget, if it's misused, players will use old version of PlugY, and I will have no other choice than to disable it.
******** COMMENTS ON THE CONFIGURATION FILE ******** ******** COMMENTS ON THE CONFIGURATION FILE ********
All Default values mean, if you remove the line, PlugY will use this value. The configuration in PlugY.ini are not the default configuration.
The values in PlugY.ini (included in the zip) are an example of configuration, not default values.
[LAUNCHING] [LAUNCHING]
This section store info for PlugY.exe and don't work in PlugYDefault.ini and PlugYFixed.ini files. This section store info for PlugY.exe and don't work in PlugYDefault.ini and PlugYFixed.ini files.
Add params to transmit to LoD on his command line. Add params to transmit to LoD on his command line.
Params give to PlugY.exe are also transmitted to LoD on his command line. Params give to PlugY.exe are also transmitted to LoD on his command line.
By default no param are trasmited. By default no param are transited.
Most common switch are (without quote) : Most common switch are (without quote) :
"-w" open LoD in windowed form. (See WINDOWED section instead) "-w" open LoD in windowed form. (See WINDOWED section instead)
"-direct" use files in directory instead of those in mpq. "-direct" use files in directory instead of those in mpq.
@ -571,35 +594,43 @@ Separate each dll file name by the character pipe (|)
- DllToLoad2= {(empty): Same as DlltoLoad} - DllToLoad2= {(empty): Same as DlltoLoad}
Activate some new commands in PlugY. In parenthesis is the condition to be able to use the command. Activate some new commands in PlugY. In parenthesis is the condition to be able to use the command.
/save : Save game without exit (LoD 1.11 minimum). /lockmouse : Lock mouse cursor in the window.
/page 1 : Show normal stats page (stats page must be opened, space not mandatory). /lock : Same as /lockmouse.
/page 2 : Show extra stats page (stats page must be opened, space not mandatory). /unlockmouse : Unlock mouse cursor in the window.
/page 3 : Show resistance stats page (stats page must be opened, space not mandatory). /unlock : Same as /unlockmouse.
/page 4 : (beta) Show available runewords (stats page must be opened, space not mandatory). /renamepage name : Rename current page stash (use # for page nuymber).
/lockmouse : Lock mouse cursor in the window. /rp name : Rename current page stash (use # for page nuymber).
/lock : Same as /lockmouse. /setindex : Set current stash page as index.
/unlockmouse : Unlock mouse cursor in the window. /setmainindex : Set current stash page as main index.
/unlock : Same as /unlockmouse. /resetindex : Remove index flag on the current stash page.
/renamechar newname : Rename your character and save it. (You must exit the game to update the stats page.) /insertpage : Insert a new page after the current page.
/renamepage name : Rename current page stash (MultiStash activated). /ip : Insert a new page after the current page.
/setindex : Set current stash page as index (prev/next index button go to an index if exists) (MultiStash activated). /deletepage : Delete current page if empty.
/resetindex : Remove index flag on the current stash page (MultiStash activated). /dp : Delete current page if empty.
/insertpage : Insert a new page after the current page (MultiStash activated). /swappage page : Swap the content of current stash page with the content of another page.
/deletepage : Delete current page if empty (MultiStash activated). /sp page : Swap the content of current stash page with the content of another page.
/swap page : Swap the content of current stash page with the content of another page (space not mandatory) (MultiStash activated). /togglepage page : Swap the content of current stash page with the content of another page in opposing stash shared/personal.
/toggle page : Swap the content of current stash page with the content of another page in opposing stash shared/personal (space not mandatory) (MultiStash activated). /tp page : Swap the content of current stash page with the content of another page in opposing stash shared/personal.
/dlm : Toggle always display mana and life mode. (Since 1.13c, you can click on the bottom of each orbs) /dlm : Toggle always display mana and life mode.
/dml : Same as /dlm. /dml : Same as /dlm.
/dl : Toggle always display life mode. (Since 1.13c, you can click on the bottom of the orb) /dl : Toggle always display life mode.
/dm : Toggle always display mana mode. (Since 1.13c, you can click on the bottom of the orb) /dm : Toggle always display mana mode.
/listcube : (beta) Create a "cube.txt" file in current directory containing all cube's receipts (LoD 1.10 minimum). /page 1 : Show normal stats page (stats page must be opened).
/page 2 : Show extra stats page (stats page must be opened).
/page 3 : Show resistance stats page (stats page must be opened).
/page 4 : Show player breakpoints (stats page must be opened).
/page 5 : Show mercenaries breakpoints (stats page must be opened).
/page 6 : (beta) Show available runewords (stats page must be opened).
/save : (beta) Save game without exit.
/listcube : (beta) Create a "cube.txt" file in save directory containing all cube's receipts.
/renamechar newname : (beta) Rename your character and save it.
- ActiveCommands=0 {0:Disabled; 1:Enabled} - ActiveCommands=0 {0:Disabled; 1:Enabled}
Quit D2, if PlugY failed to installed all features. Quit D2, if PlugY failed to install all features.
Disable it only if you know what you do. Disable it only if you know what you do.
- ActiveCheckMemory=1 - ActiveCheckMemory=1
Activate hidden or not finished feature. (don't use it) Activate hidden or unfinished feature. (don't use it)
- ActiveAllOthersFeatures=0 {0:Disabled; 1:Enabled} - ActiveAllOthersFeatures=0 {0:Disabled; 1:Enabled}
@ -644,9 +675,15 @@ For modders who want to restrict the available languages and the default languag
[SAVEPATH] [SAVEPATH]
This is where all of your characters and the shared stash is saved. This is where all of your characters and the shared stash is saved.
You can use absolute or relative paths. You can use absolute or relative paths.
It don't work in PlugYFixed.ini.
Following are default values, between {} are some examples values with descriptions : Following are default values, between {} are some examples values with descriptions :
- ActiveSavePathChange=0 {0:Disabled; 1:Enabled, you must set "SavePath"} - ActiveSavePathChange=0 {0:Disabled; 1:Enabled, you must set "SavePath"}
- SavePath=Save\ {Save\MyMod\ or D:\Save Games\diablo II\Current Mod\} - SavePath= {MyMod\ or D:\Save Games\diablo II\Current Mod\}
Active autobackup save file just before the save.
The backup will be store in a folder name "backup" in the save folder.
- ActiveAutoBackup=0 {0:Disabled; 1:Enabled}
- MaxBackupPerCharacter=20 {20: Number of backup to keep before delete; 0:No backup purge}
[MAIN SCREEN] [MAIN SCREEN]
@ -655,9 +692,9 @@ Color is an integer which refers to defined D2 colors.
Following are default values, between {} are some examples values with descriptions : Following are default values, between {} are some examples values with descriptions :
- ActiveVersionTextChange=0 {0:Disabled; 1:Enabled} - ActiveVersionTextChange=0 {0:Disabled; 1:Enabled}
- VersionText= {Empty: Display the current version of LoD with the subversion letter (1.11b, 1.09d) ; Mod Name:Text with maximum length of 23 characters (ex : v 1.11b)} - VersionText= {Empty: Display the current version of LoD with the subversion letter (1.11b, 1.09d) ; Mod Name:Text with maximum length of 23 characters (ex : v 1.11b)}
- ColorOfVersionText=0 {0:white; 1:red; 4:gold; etc.} - ColorOfVersionText=0 {0:see * for color list}
- ActivePrintPlugYVersion=1 {0:Disabled; 1:Enabled) - ActivePrintPlugYVersion=1 {0:Disabled; 1:Enabled)
- ColorOfPlugYVersion=4 {0:white; 1:red; 4:gold; etc.} - ColorOfPlugYVersion=4 {0:see * for color list}
[STASH] [STASH]
@ -681,7 +718,16 @@ Following are default values, between {} are some examples values with descripti
- NbPagesPerIndex=10 {10: Index page is 1,10,20,30,...,max} - NbPagesPerIndex=10 {10: Index page is 1,10,20,30,...,max}
- NbPagesPerIndex2=100 {100: Index page (+shift) is 1,50,100,150,...,max} - NbPagesPerIndex2=100 {100: Index page (+shift) is 1,50,100,150,...,max}
- MaxPersonnalPages=0 {0:Infinite number of personnal pages; 1000: Maximum of 1000 shared pages} - MaxPersonnalPages=0 {0:Infinite number of personnal pages; 1000: Maximum of 1000 shared pages}
- AutoRenameStashPage=0 {0:Disabled; 1:Enabled automatic renaming page}
- PersonalNormalPageColor=0 {0:Color of the personal stash name without index (see * for color list)}
- PersonalIndexPageColor=12 {0:Color of the personal stash name with index (see * for color list)}
- PersonalMainIndexPageColor=9 {0:Color of the personal stash name with main index (see * for color list)}
- SharedNormalPageColor=4 {0:Color of the shared stash name without index (see * for color list)}
- SharedIndexPageColor=8 {0:Color of the shared stash name with index (see * for color list)
- SharedMainIndexPageColor=1 {0:Color of the shared stash name with main index (see * for color list)}
- ActiveSharedStash=0 {0:Disabled; 1:Enabled if ActiveMultiPageStash=1} - ActiveSharedStash=0 {0:Disabled; 1:Enabled if ActiveMultiPageStash=1}
- ActiveSharedStashInMultiPlayer=0 {0:Disabled; 1:Enabled shared stash in multiplayer. Use only with different save folders.}
- SeparateHardcoreStash=1 {0:Same shared stash for HC and SC; 1:Use 2 differents stashes} - SeparateHardcoreStash=1 {0:Same shared stash for HC and SC; 1:Use 2 differents stashes}
- OpenSharedStashOnLoading=0 {0:Disabled; 1:Select shared stash (instead of personal one) on character loading} - OpenSharedStashOnLoading=0 {0:Disabled; 1:Select shared stash (instead of personal one) on character loading}
- SharedStashFilename=SharedStashSave {xxx: The filename will be "_LOD_xxx.sss"} - SharedStashFilename=SharedStashSave {xxx: The filename will be "_LOD_xxx.sss"}
@ -689,7 +735,9 @@ Following are default values, between {} are some examples values with descripti
- MaxSharedPages=0 {0:Infinite number of shared pages; 5000: Maximum of 5000 shared pages} - MaxSharedPages=0 {0:Infinite number of shared pages; 5000: Maximum of 5000 shared pages}
- ActiveSharedGold=1 {0:Disabled; 1:Use command to put and take gold (see command section)} - ActiveSharedGold=1 {0:Disabled; 1:Use command to put and take gold (see command section)}
- PosXPreviousBtn=-1 {-1: Default position, 50: Put the button at the position 50 in absiss} - PosXPreviousBtn=-1 {-1: Default position, 50: Put the button at the position 50 in absiss}
Same for PosYPreviousBtn, PosXNextBtn, PosYNextBtn, PosXSharedBtn, PosYSharedBtn, PosXPreviousIndexBtn, PosYPreviousIndexBtn, PosXNextIndexBtn, PosYNextIndexBtn, PosXPutGoldBtn, PosYPutGoldBtn, PosXTakeGoldBtn, PosYTakeGoldBtn. Same for PosYPreviousBtn, PosXNextBtn, PosYNextBtn, PosXSharedBtn, PosYSharedBtn, PosXPreviousIndexBtn, PosYPreviousIndexBtn, PosXNextIndexBtn, PosYNextIndexBtn, PosXPutGoldBtn, PosYPutGoldBtn, PosXTakeGoldBtn, PosYTakeGoldBtn, PosXStashNameField, PosYStashNameField, PosXStashGoldField, PosYStashGoldField.
- PosWPreviousBtn=32 {32: Width of the button}
Same for PosHPreviousBtn, PosWNextBtn, PosHNextBtn, PosWSharedBtn, PosHSharedBtn, PosWPreviousIndexBtn, PosHPreviousIndexBtn, PosWNextIndexBtn, PosHNextIndexBtn, PosWPutGoldBtn, PosHPutGoldBtn, PosWTakeGoldBtn, PosHTakeGoldBtn, PosWStashNameField, PosHStashNameField, PosWStashGoldField, PosHStashGoldField.
[STATS POINTS] [STATS POINTS]
@ -706,6 +754,8 @@ You can define a limit value for points assigned/unassigned with shift.
Following are default values, between {} are some examples values with descriptions : Following are default values, between {} are some examples values with descriptions :
- ActiveShiftClickLimit=0 {0:Disabled; 1:Enabled} - ActiveShiftClickLimit=0 {0:Disabled; 1:Enabled}
- LimitValueToShiftClick=5 (10:Assign or unassign stats points, 10 by 10} - LimitValueToShiftClick=5 (10:Assign or unassign stats points, 10 by 10}
- PosXUnassignSkillBtn=-1 {-1: Default position, 50: X position of the button set to 50.}
- PosYUnassignSkillBtn=-1 {-1: Default position, 50: Y position of the button set to 50.}
[STAT ON LEVEL UP] [STAT ON LEVEL UP]
@ -762,8 +812,24 @@ Following are default values, between {} are some examples values with descripti
Activate the Uber Quest in local. Activate the Uber Quest in local.
It works only in Hell. It works only in Hell.
You must cube the 3 keys then the 3 organs in Harrogath. You must cube the 3 keys then the 3 organs in Harrogath.
Note : This quest will be updated more later to be more similar with the one on realm.
ActiveUberQuest=0 {0:Disabled; 1:Enabled} ActiveUberQuest=0 {0:Disabled; 1:Enabled}
UberMephistoX=25130 {25130:X position of Uber Mephisto}
UberMephistoY=5143 {5143:Y position of Uber Mephisto}
UberDiabloX=25139 {25139:X position of Uber Diablo}
UberDiabloY=5139 {5139:Y position of Uber Diablo}
UberBaalX=25139 {25139:X position of Uber Baal}
UberBaalY=5135 {5135:Y position of Uber Baal}
ActiveUberMinions=1 {0:Disabled; 1:Enabled Uber minions in Tristram}
UberMephistoSpawnPercent=80 {80:Percent chance of Uber Mephisto to spawn a minion}
UberMephistoSpawnRadius=30 {30:Radius of Uber Mephisto to spawn a minion}
UberBaalSpawnPercent=30 {30:Percent chance of Uber Baal to spawn a minion}
UberBaalSpawnRadius=30 {30:Radius of Uber Baal to spawn a minion}
UberDiabloSpawnPercent=30 {30:Percent chance of Uber Diablo to spawn a minion}
UberDiabloSpawnRadius=30 {30:Radius of Uber Diablo to spawn a minion}
ActiveUberDiabloRushTweekAI=1 {0:Disabled; 1:Enabled Uber Diablo Rush tweek}
ActiveUberBaalTeleportTweekAI=1 {0:Disabled; 1:Enabled Uber Baal Teleport tweek}
ActiveUberBaalChillingArmorTweekAI=1 {0:Disabled; 1:Enabled Uber Baal Chilling Armor tweek}
UberBaalChillingArmorTimer=6000 {6000:Timer between Uber Baal casting Chilling Armor}
[INTERFACE] [INTERFACE]
@ -812,35 +878,56 @@ So don't use this column in your mod with this funcion enabled !
Enabled the ability to open the Cow Portal in a difficulty where the player have already killed the Cow King. Enabled the ability to open the Cow Portal in a difficulty where the player have already killed the Cow King.
- ActiveCowPortalWhenCowKingWasKilled=0 {0:Disabled; 1:Enabled} - ActiveCowPortalWhenCowKingWasKilled=0 {0:Disabled; 1:Enabled}
Prevent Nihlathak's portal from closing.
- ActiveDoNotCloseNihlathakPortal=0 {0:Disabled; 1:Enabled}
More features later... :) Move Cain near Harrogath waypoint.
- MoveCainNearHarrogathWaypoint=0 {0:Disabled; 1:Enabled}
This is my email : ynicolas@worldonline.fr. * Color list values (color code greater than 12 is black in 1.14d fullscreen):
But I don't support PlugY anymore so don't hope any help from me if you have problems. Instead go on forums... - Invisible: 6
- Dark gray: 5
- Gray: 16
- Light gray: 15
- White: 0,
- Bright white: 18
- Gold: 4
- Dark yellow: 7
- Yellow: 9
- Orange: 8
- Darkest green: 10
- Dark green: 12
- Green: 2
- Blue: 3
- Purple: 11
- Red: 1
- Crystal red: 19
PS : Sorry for english faults ;)
******** THANKS TO ******** ******** THANKS TO ********
- Blizzard for making Diablo2 and Lord of Destruction. - Blizzard for making Diablo2 and Lord of Destruction.
- Kingpin, Afj666, Joel, SVR, Myrdinn for their great help. - Kingpin, Afj666, Joel, SVR, Myrdinn for their great help.
- Pralinor fo his help in the convertion to 1.12. - Pralinor for his help in the convertion to 1.12.
- L'Autour fo his help in the convertion to 1.13d. - L'Autour for his help in the convertion to 1.13d.
- ChaosEnergy for testing and his translation in German. - Haxifix for his help in the convertion to 1.14d.
- SnapChip for Uber AI in Tristram.
- ChaosEnergy for his testing.
- Char & Darque in the correction of my english. - Char & Darque in the correction of my english.
- Shaitane, K&V, themastercaster, raspa and onyx for testing. - Shaitane, K&V, themastercaster, raspa and onyx for testing.
- Golvmopp, Dark Spot in the Corner, Megalixir and Athara for their help. - Golvmopp, Dark Spot in the Corner, Megalixir and Athara for their help.
- ItalianPlayer for italian translation.
- All members of ProzenKeep chat and forums for their information and feedback. - All members of ProzenKeep chat and forums for their information and feedback.
- PhrozenKeep team for all stuff they shared for us (including mine ;) - PhrozenKeep team.
- Translation : - Translation :
* English : Yohann, Jurica. * English: Yohann, Jurica.
* French : Yohann * French: Yohann
* German : ChaosEnergy, TheMasterCaster. * German: ChaosEnergy, TheMasterCaster, ChaosMarc.
* Italian : ItalianPlayer * Italian: ItalianPlayer
* Spanish : Acrerune * Spanish: Acrerune
* Polish : Serdel * Polish: Serdel
* Russian : L'Autour * Russian: L'Autour
* Chinese (Traditional): Nagahaku
* Japanase : CaiMiao
* Korean : Woodlac
;--------------------------------------------------------------------------------------; ;--------------------------------------------------------------------------------------;

BIN
PlugYInstaller/PlugY_The_Survival_Kit_-_讀我檔案.txt Normal file
View File

Binary file not shown.

151
PlugYRun/PlugYRun.cpp
View File

@ -5,25 +5,12 @@
PlugY launcher. PlugY launcher.
=================================================================*/ =================================================================*/
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include "../Commons/VersionInfo.h" #include "../Commons/VersionInfo.h"
#include "PlugYRun.h" #include "PlugYRun.h"
/* #include <stdlib.h>
0012C458 00000000 |ModuleFileName = NULL #include <stdio.h>
0012C45C 0012C908 |CommandLine = ""C:\Jeux\Diablo II\Game.exe""
0012C460 00000000 |pProcessSecurity = NULL
0012C464 00000000 |pThreadSecurity = NULL
0012C468 00000000 |InheritHandles = FALSE
0012C46C 04000022 |CreationFlags = DEBUG_ONLY_THIS_PROCESS|NORMAL_PRIORITY_CLASS|CREATE_DEFAULT_ERROR_MODE
0012C470 00000000 |pEnvironment = NULL
0012C474 0012DF94 |CurrentDir = "C:\Jeux\Diablo II\"
0012C478 0012C6BC |pStartupInfo = 0012C6BC
0012C47C 0012C5CC \pProcessInfo = 0012C5CC
*/
#define MAX_LOADSTRING 100 #define MAX_LOADSTRING 100
#define SUBKEY "Software\\Blizzard Entertainment\\Diablo II" #define SUBKEY "Software\\Blizzard Entertainment\\Diablo II"
@ -44,7 +31,7 @@ BYTE loadDll[] = {
0xFF,0x15,0x40,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.LoadLibraryA>] ; kernel32.LoadLibraryA 0xFF,0x15,0x40,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.LoadLibraryA>] ; kernel32.LoadLibraryA
0xA3,0xFC,0xEF,0xA8,0x6F, //MOV DWORD PTR DS:[6FA8EFFC],EAX 0xA3,0xFC,0xEF,0xA8,0x6F, //MOV DWORD PTR DS:[6FA8EFFC],EAX
0x85,0xC0, //TEST EAX,EAX 0x85,0xC0, //TEST EAX,EAX
0x74,0x2F, //JE SHORT d2gfx.6FA7BE37 0x74,0x2B, //JE SHORT d2gfx.6FA7BE33
0x50, //PUSH EAX 0x50, //PUSH EAX
0x68,0x90,0xBE,0xA7,0x6F, //PUSH d2gfx.6FA7BE10 ;Init String 0x68,0x90,0xBE,0xA7,0x6F, //PUSH d2gfx.6FA7BE10 ;Init String
0x50, //PUSH EAX 0x50, //PUSH EAX
@ -62,13 +49,8 @@ BYTE loadDll[] = {
0x58, //POP EAX 0x58, //POP EAX
0x58, //POP EAX 0x58, //POP EAX
0xC2,0x04,0x00, //RETN 4 0xC2,0x04,0x00, //RETN 4
0x59, //POP ECX
0xB9,0x80,0xBE,0xA7,0x6F, //MOV ECX,d2gfx.6FA7BE80 ; ASCII "PlugY.dll"
0x83,0x04,0x24,0x10, //ADD DWORD PTR SS:[ESP],10
0xC2,0x04,0x00, //RETN 4
0x00,0x00,0x00,0x00 }; //HANDLE var; 0x00,0x00,0x00,0x00 }; //HANDLE var;
BYTE freeDll[] = { BYTE freeDll[] = {
0xFF,0x74,0x24,0x04, //PUSH DWORD PTR SS:[ESP+4] 0xFF,0x74,0x24,0x04, //PUSH DWORD PTR SS:[ESP+4]
0xFF,0x15,0x48,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>] ; kernel32.FreeLibrary 0xFF,0x15,0x48,0xC0,0xA7,0x6F, //CALL DWORD PTR DS:[<&KERNEL32.FreeLibrary>] ; kernel32.FreeLibrary
@ -94,11 +76,9 @@ BYTE freeDll[] = {
0x58, //POP EAX 0x58, //POP EAX
0xC2,0x04,0x00 }; //RETN 4 0xC2,0x04,0x00 }; //RETN 4
//LPCSTR dllName = "PlugY.dll";
//LPCSTR dllName = "PlugY.dll";
LPCSTR initFctName = "_Init@4"; LPCSTR initFctName = "_Init@4";
LPCSTR releaseFctName = "_Release@0"; LPCSTR releaseFctName = "_Release@0";
static bool versionXP;
typedef int(__stdcall* tDebugActiveProcessStop)(DWORD); typedef int(__stdcall* tDebugActiveProcessStop)(DWORD);
tDebugActiveProcessStop debugActiveProcessStop; tDebugActiveProcessStop debugActiveProcessStop;
@ -124,12 +104,17 @@ bool installPlugY(HANDLE h, LPBYTE addr, char* libraryName, eGameVersion version
LPBYTE loadLibraryAddr = addr; LPBYTE loadLibraryAddr = addr;
LPBYTE freeLibraryAddr = addr; LPBYTE freeLibraryAddr = addr;
LPBYTE getProcAddressAddr = addr; LPBYTE getProcAddressAddr = addr;
switch (version) switch (version)
{ {
case V107: case V107:
loadCallerAddr += 0x3882;
freeCallerAddr += 0x3A6C;
loadLibraryAddr += 0xC038;
freeLibraryAddr += 0xC040;
getProcAddressAddr += 0xC034;
break;
case V108: case V108:
//TODO
return false;
case V109: case V109:
case V109b: case V109b:
case V109d: case V109d:
@ -182,11 +167,27 @@ bool installPlugY(HANDLE h, LPBYTE addr, char* libraryName, eGameVersion version
getProcAddressAddr += 0xD120; getProcAddressAddr += 0xD120;
break; break;
case V114a: case V114a:
loadCallerAddr += 0x1BCB;// Load advapi.dll
freeCallerAddr += 0xF375;// Free dbghelp.dll
loadLibraryAddr += 0x2CD118;
freeLibraryAddr += 0x2CD120;
getProcAddressAddr += 0x2CD11C;
break;
case V114b: case V114b:
case V114c: case V114c:
loadCallerAddr += 0x1BCB;// Load advapi.dll
freeCallerAddr += 0x6F75;// Free dbghelp.dll
loadLibraryAddr += 0x2CD11C;
freeLibraryAddr += 0x2CD124;
getProcAddressAddr += 0x2CD120;
break;
case V114d: case V114d:
//TODO loadCallerAddr += 0x621C;// Load advapi.dll
return false; freeCallerAddr += 0xB514;// Free dbghelp.dll
loadLibraryAddr += 0x2CC144;
freeLibraryAddr += 0x2CC14C;
getProcAddressAddr += 0x2CC148;
break;
default: default:
return false; return false;
} }
@ -230,7 +231,6 @@ bool installPlugY(HANDLE h, LPBYTE addr, char* libraryName, eGameVersion version
DWORD baseOfCode = *(DWORD*)(buf + 0x2C); DWORD baseOfCode = *(DWORD*)(buf + 0x2C);
//MessageBox(0, "no memory", "RunPlugY.\n", MB_OK|MB_ICONASTERISK); //MessageBox(0, "no memory", "RunPlugY.\n", MB_OK|MB_ICONASTERISK);
//memory = addr + 0xBE00 + isAdd * 0x1000;
memory = addr + baseOfCode + sizeOfCode - 200; memory = addr + baseOfCode + sizeOfCode - 200;
if (!VirtualProtectEx(h, memory, 200, PAGE_EXECUTE_READWRITE, &oldProtect)) if (!VirtualProtectEx(h, memory, 200, PAGE_EXECUTE_READWRITE, &oldProtect))
assertion("PlugY : Failed to get memory pool in game thread"); assertion("PlugY : Failed to get memory pool in game thread");
@ -271,7 +271,6 @@ bool installPlugY(HANDLE h, LPBYTE addr, char* libraryName, eGameVersion version
*(LPBYTE*)&loadDll[33] = initNameAddr; *(LPBYTE*)&loadDll[33] = initNameAddr;
*(LPBYTE*)&loadDll[40] = getProcAddressAddr; *(LPBYTE*)&loadDll[40] = getProcAddressAddr;
*(LPBYTE*)&loadDll[63] = getProcAddressAddr; *(LPBYTE*)&loadDll[63] = getProcAddressAddr;
*(LPBYTE*)&loadDll[80] = dllNameAddr;
len = sizeof(loadDll); len = sizeof(loadDll);
res = WriteProcessMemory(h, loadDllAddr, loadDll, len, &nb); res = WriteProcessMemory(h, loadDllAddr, loadDll, len, &nb);
if (!res || (nb != len)) assertion("PlugY: Write custom data in memory failed"); if (!res || (nb != len)) assertion("PlugY: Write custom data in memory failed");
@ -282,16 +281,14 @@ bool installPlugY(HANDLE h, LPBYTE addr, char* libraryName, eGameVersion version
*(LPBYTE*)&freeDll[6] = freeLibraryAddr; *(LPBYTE*)&freeDll[6] = freeLibraryAddr;
*(LPBYTE*)&freeDll[12] = handleAddr; *(LPBYTE*)&freeDll[12] = handleAddr;
*(LPBYTE*)&freeDll[22] = releaseNameAddr; *(LPBYTE*)&freeDll[22] = releaseNameAddr;
// *(LPBYTE*)&freeDll[30] = handleAddr; *(LPBYTE*)&freeDll[29] = getProcAddressAddr;
*(LPBYTE*)&freeDll[36 - 7] = getProcAddressAddr; *(LPBYTE*)&freeDll[48] = getProcAddressAddr;
*(LPBYTE*)&freeDll[55 - 7] = getProcAddressAddr; *(LPBYTE*)&freeDll[60] = freeLibraryAddr;
*(LPBYTE*)&freeDll[67 - 7] = freeLibraryAddr;
len = sizeof(freeDll); len = sizeof(freeDll);
res = WriteProcessMemory(h, freeDllAddr, freeDll, len, &nb); res = WriteProcessMemory(h, freeDllAddr, freeDll, len, &nb);
if (!res || (nb != len)) assertion("PlugY: Write custom data in memory failed"); if (!res || (nb != len)) assertion("PlugY: Write custom data in memory failed");
pos += pos % 16 ? len + 16 - pos % 16 : len; pos += pos % 16 ? len + 16 - pos % 16 : len;
// Patch load library // Patch load library
buf[0] = 0x90; buf[0] = 0x90;
buf[1] = 0xE8; buf[1] = 0xE8;
@ -305,17 +302,14 @@ bool installPlugY(HANDLE h, LPBYTE addr, char* libraryName, eGameVersion version
res = WriteProcessMemory(h, freeCallerAddr, buf, len, &nb); res = WriteProcessMemory(h, freeCallerAddr, buf, len, &nb);
if (!res || (nb != len)) assertion("PlugY: Write free library in memory failed"); if (!res || (nb != len)) assertion("PlugY: Write free library in memory failed");
// if (oldProtect != -1) // if (oldProtect != -1)
// VirtualProtectEx(h,(LPVOID)memory, 200, oldProtect, &oldProtect); // VirtualProtectEx(h,(LPVOID)memory, 200, oldProtect, &oldProtect);
return true; return true;
} }
//###########################################################################################// //###########################################################################################//
/*bool copyLodVersionFiles() /*bool copyLodVersionFiles()
{ {
BYTE folder[MAX_PATH]; BYTE folder[MAX_PATH];
@ -337,32 +331,43 @@ return true;
#define BUF_SIZE 0x300 #define BUF_SIZE 0x300
bool isD2gfx(HANDLE hProcess, LPVOID dllAdr) bool isD2gfxLoaded(HANDLE hProcess, LPVOID addr)
{ {
SIZE_T nbRead; SIZE_T nbRead;
BYTE buf[BUF_SIZE]; BYTE buf[BUF_SIZE];
ReadProcessMemory(hProcess, dllAdr, buf, BUF_SIZE, &nbRead); ReadProcessMemory(hProcess, addr, buf, BUF_SIZE, &nbRead);
if (nbRead < 0x40) return false; if (nbRead < 0x60) return false;
int offsetPESignature = *(DWORD*)(buf + 0x3C);
if (offsetPESignature + 38 >= BUF_SIZE) return false;
DWORD baseOfCode = *(DWORD*)(buf + offsetPESignature + 0x34);
if ((baseOfCode != 0x6FA80000) && (baseOfCode != 0x6FA70000)) return false;
return true;
}
bool isGameLoaded(HANDLE hProcess, LPVOID baseAdr)
{
SIZE_T nbRead;
BYTE buf[BUF_SIZE];
ReadProcessMemory(hProcess, baseAdr, buf, BUF_SIZE, &nbRead);
if (nbRead < 0x40) return false;
int offsetPESignature = *(DWORD*)(buf + 0x3C); int offsetPESignature = *(DWORD*)(buf + 0x3C);
if (offsetPESignature + 0x5C >= BUF_SIZE) return false; if (offsetPESignature + 0x5C >= BUF_SIZE) return false;
DWORD baseOfCode = *(DWORD*)(buf + offsetPESignature + 0x34); DWORD ImageBase = *(DWORD*)(buf + offsetPESignature + 0x34);
DWORD SizeOfImage = *(DWORD*)(buf + offsetPESignature + 0x50); DWORD SizeOfImage = *(DWORD*)(buf + offsetPESignature + 0x50);
DWORD CheckSum = *(DWORD*)(buf + offsetPESignature + 0x58); DWORD CheckSum = *(DWORD*)(buf + offsetPESignature + 0x58);
if ((baseOfCode==0x00400000) && (SizeOfImage == 0x005A5000) && (CheckSum == 0x00374101)) return true;//1.14c if (ImageBase == 0x6FAA0000 && SizeOfImage == 0x00021000 && CheckSum == 0x00000000) return true;// 1.07 - 1.08
if (ImageBase == 0x6FA70000 && SizeOfImage == 0x00021000 && CheckSum == 0x00000000) return true;// 1.09 - 1.09b - 1.09d - 1.10
if (ImageBase == 0x6FA80000 && SizeOfImage == 0x00021000 && CheckSum == 0x0001743E) return true;// 1.11
if (ImageBase == 0x6FA80000 && SizeOfImage == 0x00021000 && CheckSum == 0x0001F6C4) return true;// 1.11b
if (ImageBase == 0x6FA80000 && SizeOfImage == 0x00021000 && CheckSum == 0x0001F0B2) return true;// 1.12
if (ImageBase == 0x6FA80000 && SizeOfImage == 0x00021000 && CheckSum == 0x0001BE5C) return true;// 1.13c
if (ImageBase == 0x6FA80000 && SizeOfImage == 0x00021000 && CheckSum == 0x00018542) return true;// 1.13d
return false;
}
bool isGameLoaded(HANDLE hProcess, LPVOID addr)
{
SIZE_T nbRead;
BYTE buf[BUF_SIZE];
ReadProcessMemory(hProcess, addr, buf, BUF_SIZE, &nbRead);
if (nbRead < 0x60) return false;
int offsetPESignature = *(DWORD*)(buf + 0x3C);
if (offsetPESignature + 0x5C >= BUF_SIZE) return false;
DWORD ImageBase = *(DWORD*)(buf + offsetPESignature + 0x34);
DWORD SizeOfImage = *(DWORD*)(buf + offsetPESignature + 0x50);
DWORD CheckSum = *(DWORD*)(buf + offsetPESignature + 0x58);
if (ImageBase == 0x00400000 && SizeOfImage == 0x005A6000 && CheckSum == 0x00371D8F) return true;//1.14a
if (ImageBase == 0x00400000 && SizeOfImage == 0x005A6000 && CheckSum == 0x0037645F) return true;//1.14b
if (ImageBase == 0x00400000 && SizeOfImage == 0x005A5000 && CheckSum == 0x00374101) return true;//1.14c
if (ImageBase == 0x00400000 && SizeOfImage == 0x005BA000 && CheckSum == 0x0037CED2) return true;//1.14d
return false; return false;
} }
@ -431,20 +436,26 @@ bool launchGame98(LPSTR commandLine, LPSTR currentDirectory, LPSTR libraryName,
if (!GetExitCodeProcess(pi.hProcess, &ret) || (ret != STILL_ACTIVE)) if (!GetExitCodeProcess(pi.hProcess, &ret) || (ret != STILL_ACTIVE))
exit(0); exit(0);
if (isD2gfx(pi.hProcess, (LPVOID)0x6FA80000)) if (isD2gfxLoaded(pi.hProcess, (LPVOID)0x6FA80000))
{ {
installPlugY(pi.hProcess, (LPBYTE)0x6FA80000, libraryName, version); installPlugY(pi.hProcess, (LPBYTE)0x6FA80000, libraryName, version);
ResumeThread(pi.hThread); ResumeThread(pi.hThread);
return true; return true;
} }
if (isD2gfx(pi.hProcess, (LPVOID)0x6FA70000)) if (isD2gfxLoaded(pi.hProcess, (LPVOID)0x6FA70000))
{ {
installPlugY(pi.hProcess, (LPBYTE)0x6FA70000, libraryName, version); installPlugY(pi.hProcess, (LPBYTE)0x6FA70000, libraryName, version);
ResumeThread(pi.hThread); ResumeThread(pi.hThread);
return true; return true;
} }
if (isD2gfxLoaded(pi.hProcess, (LPVOID)0x6FAA0000))
{
installPlugY(pi.hProcess, (LPBYTE)0x6FAA0000, libraryName, version);
ResumeThread(pi.hThread); ResumeThread(pi.hThread);
// Sleep(10); return true;
}
ResumeThread(pi.hThread);
//Sleep(10);
} }
return false; return false;
} }
@ -469,9 +480,9 @@ bool launchGameXP(LPSTR commandLine, LPSTR currentDirectory, LPSTR libraryName,
CloseHandle(DebugEvent.u.CreateThread.hThread); CloseHandle(DebugEvent.u.CreateThread.hThread);
break; break;
case CREATE_PROCESS_DEBUG_EVENT: case CREATE_PROCESS_DEBUG_EVENT:
if (version >= V114a && isGameLoaded(pi.hProcess, DebugEvent.u.CreateProcessInfo.lpBaseOfImage)) if (version >= V114a)// && isGameLoaded(pi.hProcess, DebugEvent.u.CreateProcessInfo.lpBaseOfImage))
{ {
//installPlugYOnGame(pi.hProcess, (DWORD)DebugEvent.u.CreateProcessInfo.lpBaseOfImage, libraryName, (DWORD)DebugEvent.u.LoadDll.lpBaseOfDll == 0x6FA8000, version); installPlugY(pi.hProcess, (LPBYTE)DebugEvent.u.CreateProcessInfo.lpBaseOfImage, libraryName, version);
CloseHandle(DebugEvent.u.CreateProcessInfo.hFile); CloseHandle(DebugEvent.u.CreateProcessInfo.hFile);
CloseHandle(pi.hProcess); CloseHandle(pi.hProcess);
CloseHandle(pi.hThread); CloseHandle(pi.hThread);
@ -486,7 +497,7 @@ bool launchGameXP(LPSTR commandLine, LPSTR currentDirectory, LPSTR libraryName,
MessageBox(0, "EXCEPTION_ACCESS_VIOLATION", "PlugY", MB_OK | MB_ICONASTERISK); MessageBox(0, "EXCEPTION_ACCESS_VIOLATION", "PlugY", MB_OK | MB_ICONASTERISK);
break; break;
case LOAD_DLL_DEBUG_EVENT: case LOAD_DLL_DEBUG_EVENT:
if (version <= V113d && isD2gfx(pi.hProcess, DebugEvent.u.LoadDll.lpBaseOfDll)) if (version <= V113d && isD2gfxLoaded(pi.hProcess, DebugEvent.u.LoadDll.lpBaseOfDll))
{ {
installPlugY(pi.hProcess, (LPBYTE)DebugEvent.u.LoadDll.lpBaseOfDll, libraryName, version); installPlugY(pi.hProcess, (LPBYTE)DebugEvent.u.LoadDll.lpBaseOfDll, libraryName, version);
CloseHandle(DebugEvent.u.LoadDll.hFile); CloseHandle(DebugEvent.u.LoadDll.hFile);
@ -514,8 +525,6 @@ int APIENTRY WinMain (
__in int nShowCmd __in int nShowCmd
) )
{ {
GetD2Version();
char currrentDirectory[MAX_PATH]; char currrentDirectory[MAX_PATH];
char iniFileName[MAX_PATH + sizeof(INIFILE) - 1]; char iniFileName[MAX_PATH + sizeof(INIFILE) - 1];
char command[MAX_PATH + sizeof(GAMEFILE) + 200]; char command[MAX_PATH + sizeof(GAMEFILE) + 200];
@ -592,10 +601,8 @@ int APIENTRY WinMain (
return !launchNormal(command, currrentDirectory); return !launchNormal(command, currrentDirectory);
// Check version // Check version
if (version == UNKNOW) if (version < V107 || version > V114d)
assertion("This LoD version isn't supported by PlugY."); assertion("PlugY isn't compatible with this version : %s", GetVersionString(version));
else if (version < V109 || version > V113d)
assertion("The %s version of LoD isn't supported by PlugY.", GetVersionString(version));
// Launch LoD and install PlugY // Launch LoD and install PlugY
HMODULE module = GetModuleHandle("Kernel32.dll"); HMODULE module = GetModuleHandle("Kernel32.dll");

BIN
PlugYRun/PlugYRun.rc
View File

Binary file not shown.

BIN
PlugYRun/PlugYRun.suo
View File

Binary file not shown.

2
PlugYRun/PlugYRun.vcproj
View File

@ -160,7 +160,7 @@
/> />
<Tool <Tool
Name="VCPostBuildEventTool" Name="VCPostBuildEventTool"
CommandLine="copy &quot;$(TargetPath)&quot; &quot;..\PlugYInstaller\PlugY.exe&quot;" CommandLine="copy &quot;$(TargetPath)&quot; &quot;..\PlugYInstaller\PlugY.exe&quot;&#x0D;&#x0A;"
/> />
</Configuration> </Configuration>
</Configurations> </Configurations>

80
README.md
View File

@ -1,25 +1,63 @@
# PlugY # PlugY
PlugY, The Survival Kit - Plug-in for Diablo II Lord of Destruction (1.09b - 1.13d) PlugY, The Survival Kit - Plug-in for Diablo II Lord of Destruction (1.09b - 1.13d + 1.14d)
Extends Diablo II - Lord of Destruction by a number of useful features which can be enabled/disabled individually Extends Diablo II - Lord of Destruction by a number of useful features
## FEATURES ## FEATURES
* Disable access to Battle.net Each features can be turned on/off via PlugY.ini (see "COMMENTS ON THE CONFIGURATION FILE")
* Infinite storage space in the stash (up to 4,294,967,296 personal pages) * Disable access to Battle.net.
* Shared storage space in the stash (up to 4,294,967,296 shared pages too!) * Infinite storage space in the stash.
* Enabled the ladder only runewords for singleplayer and TCP/IP multiplayer * Shared storage space in the stash.
* Local World Event and Uber Quest for singleplayer and TCP/IP multiplayer * Enable the ladder only runewords for singleplayer and TCP/IP game.
* Can open Cow Level Portal even when the Cow King was killed before in that difficulty * World Event and Uber Quest for singleplayer and TCP/IP game.
* Unassign assigned skills and stats points * Can open Cow Level Portal even when player have kill the Cow King in that difficulty.
* Change the selected language * Prevent Nihlathak's portal from closing.
* Always regenerate maps in SinglePlayer like in MultiPlayer * Move Deckard Cain near the waypoint in Harrogath.
* Automatically execute /players X when you launch a new game * Unassign assigned skills and stats points.
* Added some pages for display more characters stats like %MF * Auto backup save files before saving.
* Display item level * Change the selected language.
* Launch any number of Diablo II games on the same computer * Always regenerate maps in SinglePlayer like in MultiPlayer.
* Increase the stash to 10x10 squares * Automatically execute /players X when you launch a new game.
* Change the save path directory * Added some pages for display more characters stats.
* Always display Mana and Life values above the globes * Display item level in its popup.
* D2 can load all files, even those opened with Microsoft Excel (disabled by default) * Launch any number of Diablo II games on the same computer.
* Display the stats current value (without magical bonus) like Magic/gold find or maximum resistances * Increase the stash to 10x10 squares.
* PlugY is localized in English, French, German, Italian, Spanish, Polish, Portuguese, Japanese, Korean, Chinese, Polish, Russian * Change the save path directory.
* Always display Mana and Life values above the globes.
* D2 can load all files, even those opened with Microsoft Excel (disabled by default).
* Display the current stats value (without magical bonus).
* Can launch game in windowed mode.
* Add following commands (see "COMMENTS ON THE CONFIGURATION FILE") :
* /lockmouse : Lock mouse cursor in the window.
* /lock : Same as /lockmouse.
* /unlockmouse : Unlock mouse cursor in the window.
* /unlock : Same as /unlockmouse.
* /renamepage name : Rename current page stash (use # for page number).
* /rp name : See /renamepage.
* /setindex : Set current stash page as index.
* /setmainindex : Set current stash page as main index.
* /resetindex : Remove index flag on the current stash page.
* /insertpage : Insert a new page after the current page.
* /ip : See /insertpage.
* /deletepage : Delete current page if empty.
* /dp : See /deletepage.
* /swappage page : Swap the content of current stash page with the content of another page.
* /sp page : See /swappage.
* /togglepage page : Swap the content of current stash page with the content of another page in opposing stash shared/personal.
* /tp page : See /togglepage.
* /dlm : Toggle always display mana and life mode.
* /dml : See /dlm.
* /dl : See /dlm.
* /dm : See /dlm.
* /page 1 : Show normal stats page (stats page must be opened).
* /page 2 : Show extra stats page (stats page must be opened).
* /page 3 : Show resistance stats page (stats page must be opened).
* /page 4 : Show player breakpoints (stats page must be opened).
* /page 5 : Show mercenaries breakpoints (stats page must be opened).
* /page 6 : (beta) Show available runewords (stats page must be opened).
* /save : (beta) Save game without exit.
* /listcube : (beta) Create a "cube.txt" file in save directory containing all cube's receipts.
* /renamechar newname : (beta) Rename your character and save it.
## Contribute
If you want to update the translations please use the [POEditor project](https://poeditor.com/join/project/VnO1SKslPV) and create a bug-ticket nofifying me that you have done so. Please do not edit the LocalizedStrings.ini directly. If you absolutely don't want to use POEditor, edit the json files found at [PlugYInstaller/PlugY/translations](https://github.com/ChaosMarc/PlugY/tree/master/PlugYInstaller/PlugY/translations)