《生死僵局》v1.0 偏移量自動獲取工具 - C#/C++雙版本支援 實時更新dwEntityList等關鍵數據

《生死僵局》(Deadlock)偏移量獲取教學

☑️ 生死僵局偏移量獲取指南

本教學將介紹如何獲取生死僵局(Deadlock)遊戲中的重要偏移量,包括:

- dwEntityList
- ViewMatrix  
- LocalPlayerController (LocalPlayer)
- CCameraManager
- SchemaSystemInterface

請注意,由於遊戲經常更新,這些偏移量可能會在幾小時後失效。以下提供C#和C++兩種程式碼,可以運行其中之一來獲取最新偏移量。

☑️ C#程式碼

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Diagnostics;
   
4. using System.Linq;
   
5. using System.Runtime.InteropServices;
   
6. using System.Text;
   
7. 
   
8. class Program
   
9. {
   
10.     [StructLayout(LayoutKind.Sequential)]
    
11.     public struct MODULEINFO
    
12.     {
    
13.         public IntPtr lpBaseOfDll;
    
14.         public uint SizeOfImage;
    
15.         public IntPtr EntryPoint;
    
16.     }
    
17. 
    
18.     class Signature
    
19.     {
    
20.         public string Pattern { get; }
    
21.         public uint Offset { get; }
    
22.         public uint Extra { get; }
    
23. 
    
24.         public Signature(string pattern, uint offset, uint extra)
    
25.         {
    
26.             Pattern = pattern;
    
27.             Offset = offset;
    
28.             Extra = extra;
    
29.         }
    
30. 
    
31.         public List<byte> ParsePattern()
    
32.         {
    
33.             var bytes = new List<byte>();
    
34.             var patternParts = Pattern.Split(' ');
    
35. 
    
36.             foreach (var byteStr in patternParts)
    
37.             {
    
38.                 if (byteStr == "?" || byteStr == "??")
    
39.                 {
    
40.                     bytes.Add(0);
    
41.                 }
    
42.                 else
    
43.                 {
    
44.                     bytes.Add(Convert.ToByte(byteStr, 16));
    
45.                 }
    
46.             }
    
47. 
    
48.             return bytes;
    
49.         }
    
50. 
    
51.         static T ReadMemory<T>(IntPtr processHandle, IntPtr address) where T : struct
    
52.         {
    
53.             var size = Marshal.SizeOf(typeof(T));
    
54.             var buffer = new byte[size];
    
55.             int bytesRead;
    
56. 
    
57.             if (ReadProcessMemory(processHandle, address, buffer, size, out bytesRead) && bytesRead == size)
    
58.             {
    
59.                 GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
    
60.                 T result = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
    
61.                 handle.Free();
    
62.                 return result;
    
63.             }
    
64.             throw new InvalidOperationException("Failed to read memory.");
    
65.         }
    
66. 
    
67. 
    
68.         public void Find(IEnumerable<byte> memory, IntPtr processHandle, IntPtr moduleBase)
    
69.         {
    
70.             var pattern = ParsePattern();
    
71.             var printedAddresses = new HashSet<UIntPtr>();
    
72. 
    
73.             for (int i = 0; i < memory.Count() - pattern.Count(); i++)
    
74.             {
    
75.                 bool patternMatch = true;
    
76.                 for (int j = 0; j < pattern.Count(); j++)
    
77.                 {
    
78.                     if (pattern[j] != 0 && memory.ElementAt(i + j) != pattern[j])
    
79.                     {
    
80.                         patternMatch = false;
    
81.                         break;
    
82.                     }
    
83.                 }
    
84. 
    
85.                 if (patternMatch)
    
86.                 {
    
87.                     var patternAddress = (UIntPtr)(moduleBase.ToInt64() + i);
    
88.                     int of = ReadMemory<int>(processHandle, (IntPtr)(patternAddress.ToUInt64() + Offset));
    
89.                     var result = patternAddress.ToUInt64() + (UInt64)of + Extra;
    
90. 
    
91.                     var resultPtr = new UIntPtr((UInt64)result - (UInt64)moduleBase.ToInt64());
    
92. 
    
93.                     // Print the address only if it's not already printed
    
94.                     if (printedAddresses.Add(resultPtr))
    
95.                     {
    
96.                         Console.WriteLine($"> 0x{resultPtr.ToUInt64():X}");
    
97.                     }
    
98.                 }
    
99.             }
    
100.         }
     
101.     }
     
102. 
     
103.     static void Main()
     
104.     {
     
105.         Console.WriteLine("By 5komar (Catrine)\n");
     
106.         Console.WriteLine("My Discord Username > catrine\n");
     
107. 
     
108.         var localPlayerSig = new Signature("48 8B 0D ? ? ? ? 48 85 C9 74 65 83 FF FF", 3, 7);
     
109.         var viewMatrixSig = new Signature("48 8D ? ? ? ? ? 48 C1 E0 06 48 03 C1 C3", 3, 7);
     
110.         var entityListSig = new Signature("48 8B 0D ? ? ? ? 8B C5 48 C1 E8", 3, 7);
     
111.         var CCameraManagerSig = new Signature("48 8D 3D ? ? ? ? 8B D9", 3, 7);
     
112.         var chemas_sig = new Signature("48 89 05 ? ? ? ? 4C 8D 0D ? ? ? ? 0F B6 45 E8 4C 8D 45 E0 33 F6", 3, 7);
     
113. 
     
114. 
     
115.         string processName = "project8.exe";
     
116.         var processHandle = GetProcessHandle(processName);
     
117. 
     
118.         if (processHandle == IntPtr.Zero)
     
119.         {
     
120.             Console.WriteLine("Game process not found!");
     
121.             return;
     
122.         }
     
123. 
     
124.         var moduleInfo = GetModuleInfo(processHandle, "client.dll");
     
125.         var moduleInfo2 = GetModuleInfo(processHandle, "schemasystem.dll");
     
126.         if (moduleInfo.lpBaseOfDll == IntPtr.Zero)
     
127.         {
     
128.             Console.WriteLine("client.dll not found!");
     
129.             return;
     
130.         }
     
131.         if (moduleInfo2.lpBaseOfDll == IntPtr.Zero)
     
132.         {
     
133.             Console.WriteLine("schemasystem.dll not found!");
     
134.             return;
     
135.         }
     
136. 
     
137.         var memory = ReadMemoryBytes(processHandle, moduleInfo.lpBaseOfDll, (int)moduleInfo.SizeOfImage);
     
138.         var memory2 = ReadMemoryBytes(processHandle, moduleInfo2.lpBaseOfDll, (int)moduleInfo.SizeOfImage);
     
139. 
     
140.         Console.WriteLine("LocalPlayerController:");
     
141.         localPlayerSig.Find(memory, processHandle, moduleInfo.lpBaseOfDll);
     
142.         Console.WriteLine("ViewMatrix:");
     
143.         viewMatrixSig.Find(memory, processHandle, moduleInfo.lpBaseOfDll);
     
144.         Console.WriteLine("EntityList:");
     
145.         entityListSig.Find(memory, processHandle, moduleInfo.lpBaseOfDll);
     
146.         Console.WriteLine("CCameraManager:");
     
147.         CCameraManagerSig.Find(memory, processHandle, moduleInfo.lpBaseOfDll);
     
148.         Console.WriteLine("SchemaSystemInterface:");
     
149.         chemas_sig.Find(memory2, processHandle, moduleInfo2.lpBaseOfDll);
     
150. 
     
151.         CloseHandle(processHandle);
     
152.     }
     
153. 
     
154.     static List<byte> ReadMemoryBytes(IntPtr processHandle, IntPtr address, int size)
     
155.     {
     
156.         var buffer = new byte[size];
     
157.         ReadProcessMemory(processHandle, address, buffer, size, out _);
     
158.         return buffer.ToList();
     
159.     }
     
160. 
     
161.     static IntPtr GetProcessHandle(string processName)
     
162.     {
     
163.         processName = processName.EndsWith(".exe") ? processName.Substring(0, processName.Length - 4) : processName;
     
164. 
     
165.         var processes = Process.GetProcessesByName(processName);
     
166.         if (processes.Length > 0)
     
167.         {
     
168.             IntPtr processHandle = OpenProcess(0x0010 | 0x0400, false, processes[0].Id);
     
169. 
     
170.             if (processHandle != IntPtr.Zero)
     
171.             {
     
172.                 return processHandle;
     
173.             }
     
174.             else
     
175.             {
     
176.                 Console.WriteLine($"Failed to open process handle. Error code: {Marshal.GetLastWin32Error()}");
     
177.             }
     
178.         }
     
179.         else
     
180.         {
     
181.             Console.WriteLine($"No process found with name '{processName}'");
     
182.         }
     
183. 
     
184.         return IntPtr.Zero;
     
185.     }
     
186. 
     
187.     static MODULEINFO GetModuleInfo(IntPtr processHandle, string moduleName)
     
188.     {
     
189.         MODULEINFO modInfo = new MODULEINFO();
     
190.         IntPtr[] hMods = new IntPtr[1024];
     
191.         GCHandle gch = GCHandle.Alloc(hMods, GCHandleType.Pinned);
     
192.         if (EnumProcessModules(processHandle, gch.AddrOfPinnedObject(), (uint)(hMods.Length * IntPtr.Size), out uint cbNeeded))
     
193.         {
     
194.             for (int i = 0; i < (cbNeeded / IntPtr.Size); i++)
     
195.             {
     
196.                 StringBuilder szModName = new StringBuilder(1024);
     
197.                 if (GetModuleBaseName(processHandle, hMods[i], szModName, szModName.Capacity) > 0)
     
198.                 {
     
199.                     if (moduleName == szModName.ToString())
     
200.                     {
     
201.                         GetModuleInformation(processHandle, hMods[i], out modInfo, (uint)Marshal.SizeOf(typeof(MODULEINFO)));
     
202.                         break;
     
203.                     }
     
204.                 }
     
205.             }
     
206.         }
     
207.         gch.Free();
     
208.         return modInfo;
     
209.     }
     
210. 
     
211.     [DllImport("psapi.dll", SetLastError = true)]
     
212.     static extern bool EnumProcessModules(IntPtr hProcess, IntPtr lphModule, uint cb, out uint lpcbNeeded);
     
213. 
     
214.     [DllImport("psapi.dll", SetLastError = true)]
     
215.     static extern uint GetModuleBaseName(IntPtr hProcess, IntPtr hModule, StringBuilder lpBaseName, int nSize);
     
216. 
     
217.     [DllImport("psapi.dll", SetLastError = true)]
     
218.     static extern bool GetModuleInformation(IntPtr hProcess, IntPtr hModule, out MODULEINFO lpmodinfo, uint cb);
     
219. 
     
220.     [DllImport("kernel32.dll", SetLastError = true)]
     
221.     static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [Out] byte[] lpBuffer, int dwSize, out int lpNumberOfBytesRead);
     
222. 
     
223.     [DllImport("kernel32.dll", SetLastError = true)]
     
224.     static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, out int lpBuffer, int dwSize, out int lpNumberOfBytesRead);
     
225. 
     
226.     [DllImport("kernel32.dll", SetLastError = true)]
     
227.     static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
     
228. 
     
229.     [DllImport("kernel32.dll", SetLastError = true)]
     
230.     static extern bool CloseHandle(IntPtr hObject);
     
231. }

複製代碼

☑️ C++程式碼

1. #include <Windows.h>
   
2. #include <TlHelp32.h>
   
3. #include <IOStream>
   
4. #include <vector>
   
5. #include <string>
   
6. #include <Psapi.h>
   
7. #include <sstream>
   
8. 
   
9. struct Signature {
   
10.     std::string pattern;
    
11.     uint32_t offset;
    
12.     uint32_t extra;
    
13. 
    
14.     Signature(const std::string& pat, uint32_t off, uint32_t ext)
    
15.         : pattern(pat), offset(off), extra(ext) {}
    
16. 
    
17.     std::vector<uint8_t> parse_pattern() const {
    
18.         std::vector<uint8_t> bytes;
    
19.         std::istringstream patternStream(pattern);
    
20.         std::string byteStr;
    
21. 
    
22.         while (patternStream >> byteStr) {
    
23.             if (byteStr == "?" || byteStr == "??") {
    
24.                 bytes.push_back(0);
    
25.             }
    
26.             else {
    
27.                 bytes.push_back(static_cast<uint8_t>(strtol(byteStr.c_str(), nullptr, 16)));
    
28.             }
    
29.         }
    
30.         return bytes;
    
31.     }
    
32. 
    
33.     void find(const std::vector<uint8_t>& memory, HANDLE processHandle, uintptr_t moduleBase) const {
    
34.         std::vector<uint8_t> pattern = parse_pattern();
    
35.         for (size_t i = 1000000; i < memory.size(); ++i) {
    
36.             bool patternMatch = true;
    
37.             for (size_t j = 0; j < pattern.size(); ++j) {
    
38.                 if (pattern[j] != 0 && memory[i + j] != pattern[j]) {
    
39.                     patternMatch = false;
    
40.                     break;
    
41.                 }
    
42.             }
    
43.             if (patternMatch) {
    
44.                 uintptr_t patternAddress = moduleBase + i;
    
45.                 int32_t of;
    
46.                 ReadProcessMemory(processHandle, reinterpret_cast<LPCVOID>(patternAddress + offset), &of, sizeof(of), nullptr);
    
47.                 uintptr_t result = patternAddress + of + extra;
    
48.                 std::cout << "+ 0x" << std::hex << (result - moduleBase) << std::endl;
    
49.             }
    
50.         }
    
51.     }
    
52. };
    
53. 
    
54. // Helper function to convert TCHAR to std::string or std::wstring
    
55. #ifdef UNICODE
    
56. std::wstring toString(const TCHAR* tcharArray) {
    
57.     return std::wstring(tcharArray);
    
58. }
    
59. #else
    
60. std::string toString(const TCHAR* tcharArray) {
    
61.     return std::string(tcharArray);
    
62. }
    
63. #endif
    
64. 
    
65. std::string wstringToString(const std::wstring& wstr) {
    
66.     std::string str(wstr.begin(), wstr.end());
    
67.     return str;
    
68. }
    
69. 
    
70. HANDLE getProcessHandle(const std::string& processName) {
    
71.     PROCESSENTRY32 processEntry;
    
72.     processEntry.dwSize = sizeof(PROCESSENTRY32);
    
73.     HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    
74. 
    
75.     if (Process32First(snapshot, &processEntry)) {
    
76.         do {
    
77.             std::string exeFileName = wstringToString(processEntry.szExeFile);
    
78.             if (processName == exeFileName) {
    
79.                 CloseHandle(snapshot);
    
80.                 return OpenProcess(PROCESS_VM_READ | PROCESS_QUERY_INFORMATION, FALSE, processEntry.th32ProcessID);
    
81.             }
    
82.         } while (Process32Next(snapshot, &processEntry));
    
83.     }
    
84.     CloseHandle(snapshot);
    
85.     return nullptr;
    
86. }
    
87. 
    
88. 
    
89. MODULEINFO getModuleInfo(HANDLE processHandle, const std::string& moduleName) {
    
90.     HMODULE hMods[1024];
    
91.     DWORD cbNeeded;
    
92.     MODULEINFO modInfo = { 0 };
    
93. 
    
94.     if (EnumProcessModules(processHandle, hMods, sizeof(hMods), &cbNeeded)) {
    
95.         for (unsigned int i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
    
96.             char szModName[MAX_PATH];
    
97.             if (GetModuleBaseNameA(processHandle, hMods[i], szModName, sizeof(szModName) / sizeof(char))) {
    
98.                 if (moduleName == szModName) {
    
99.                     GetModuleInformation(processHandle, hMods[i], &modInfo, sizeof(modInfo));
    
100.                     break;
     
101.                 }
     
102.             }
     
103.         }
     
104.     }
     
105.     return modInfo;
     
106. }
     
107. 
     
108. std::vector<uint8_t> readMemoryBytes(HANDLE processHandle, uintptr_t address, size_t size) {
     
109.     std::vector<uint8_t> buffer(size);
     
110.     ReadProcessMemory(processHandle, reinterpret_cast<LPCVOID>(address), buffer.data(), size, nullptr);
     
111.     return buffer;
     
112. }
     
113. 
     
114. int main() {
     
115.     std::cerr << "By 5komar (Catrine)\n" << std::endl;
     
116. 
     
117.     Signature localPlayerSig("48 8B 0D ? ? ? ? 48 85 C9 74 65 83 FF FF", 3, 7);
     
118.     Signature viewMatrixSig("48 8D ? ? ? ? ? 48 C1 E0 06 48 03 C1 C3", 3, 7);
     
119.     Signature entityListSig("48 8B 0D ? ? ? ? 8B C5 48 C1 E8", 3, 7);
     
120.     Signature CCameraManagerSig("48 8D 3D ? ? ? ? 8B D9", 3, 7);
     
121. 
     
122. 
     
123.     std::string processName = "project8.exe";
     
124.     HANDLE processHandle = getProcessHandle(processName);
     
125.     if (!processHandle) {
     
126.         std::cerr << "Game process not found!" << std::endl;
     
127.         return 1;
     
128.     }
     
129. 
     
130.     MODULEINFO moduleInfo = getModuleInfo(processHandle, "client.dll");
     
131. 
     
132.     if (!moduleInfo.lpBaseOfDll) {
     
133.         std::cerr << "client.dll not found!" << std::endl;
     
134.         return 1;
     
135.     }
     
136. 
     
137.     std::vector<uint8_t> memory = readMemoryBytes(processHandle, reinterpret_cast<uintptr_t>(moduleInfo.lpBaseOfDll), moduleInfo.SizeOfImage);
     
138. 
     
139.     std::cout << "LocalPlayerController:" << std::endl;
     
140.     localPlayerSig.find(memory, processHandle, reinterpret_cast<uintptr_t>(moduleInfo.lpBaseOfDll));
     
141.     std::cout << "ViewMatrix:" << std::endl;
     
142.     viewMatrixSig.find(memory, processHandle, reinterpret_cast<uintptr_t>(moduleInfo.lpBaseOfDll));
     
143.     std::cout << "EntityList:" << std::endl;
     
144.     entityListSig.find(memory, processHandle, reinterpret_cast<uintptr_t>(moduleInfo.lpBaseOfDll));
     
145.     std::cout << "CCameraManager:" << std::endl;
     
146.     CCameraManagerSig.find(memory, processHandle, reinterpret_cast<uintptr_t>(moduleInfo.lpBaseOfDll));
     
147. 
     
148.     CloseHandle(processHandle);
     
149.     return 0;
     
150. }

複製代碼

☑️ 使用說明

1. 選擇C#或C++程式碼,複製到您的開發環境中。
2. 確保您已安裝必要的開發工具和相關函式庫。
3. 編譯並運行程式。
4. 程式會自動搜索生死僵局遊戲進程並獲取所需的偏移量。
5. 獲取到的偏移量將顯示在控制台輸出中。

☑️ 常見問題

Q1: 為什麼我無法獲取偏移量?
A1: 請確保遊戲正在運行,且您擁有足夠的權限訪問遊戲進程。

Q2: 獲取到的偏移量多久更新一次?
A2: 建議每次遊戲更新後重新運行程式獲取最新偏移量。

Q3: 使用這些偏移量是否安全?
A3: 使用任何非官方工具都有風險,請謹慎使用並自行承擔後果。


👉 福 利 遊 戲 推 薦 ⬇️ 點 ⬇️⬇️ 免費玩各種動漫手遊