Hallo Freunde,

ich habe eine Frage und zwar war ich eine weile nicht mehr so aktiv in SAMP und nun habe ich gemerkt

das ich meine HP nicht mehr auslesen kann und auch mein cleo mod der meine HP in Zahlen zeigt funktioniert

auch nicht mehr.

Villeicht kann mir da einer helfen

danke schon mal.

Zitat von riyuko.

Wenn du die API usw. ordentlich angewendet hast, dann solltest du einfach wie folgt z.B. die HP im Chat ausgeben

Code

1. HP := GetPlayerHealth()
3. SendChat(HP)

das habe ich nur zeigt es mir dann : 8000086 HP an warum auch immer

Zitat von LeonMrBonnie

Verwendest du es bei LYD? Da ist das der tatsächliche HP Wert wegen dem Anticheat

Ja auf lyd also muss ich das so machen wie riyku sagt

Zitat von iTsMaho

Hier versuchs so:

Code

1. ; # - GetPlayerHealth() Ermittelt die HP des Spielers #
2. ; # - GetPlayerArmor() Ermittelt den Rüstungswert des Spielers #
5. HP := GetPlayerHealth() / 80000 ; Hier wird dein HP also 8000000 Geteiltdruch 80000 gerechnet.
6. HP2 := Round(HP, 0)
7. SendChat(HP2)
11. GetPlayerHealth() {
12. if(!checkHandles())
13. return -1
15. dwCPedPtr := readDWORD(hGTA, ADDR_CPED_PTR)
16. if(ErrorLevel) {
17. ErrorLevel := ERROR_READ_MEMORY
18. return -1
19. }
21. dwAddr := dwCPedPtr + ADDR_CPED_HPOFF
22. fHealth := readFloat(hGTA, dwAddr)
23. if(ErrorLevel) {
24. ErrorLevel := ERROR_READ_MEMORY
25. return -1
26. }
28. ErrorLevel := ERROR_OK
29. return Round(fHealth)
30. }
33. GetPlayerArmor() {
34. if(!checkHandles())
35. return -1
37. dwCPedPtr := readDWORD(hGTA, ADDR_CPED_PTR)
38. if(ErrorLevel) {
39. ErrorLevel := ERROR_READ_MEMORY
40. return -1
41. }
43. dwAddr := dwCPedPtr + ADDR_CPED_ARMOROFF
44. fHealth := readFloat(hGTA, dwAddr)
45. if(ErrorLevel) {
46. ErrorLevel := ERROR_READ_MEMORY
47. return -1
48. }
50. ErrorLevel := ERROR_OK
51. return Round(fHealth)
52. }
54. ; ##### Sonstiges #####
55. checkHandles() {
56. if (iRefreshHandles + 500 > A_TickCount)
57. return true
59. if (!refreshGTA() || !refreshSAMP() || !refreshMemory())
60. return false
62. iRefreshHandles := A_TickCount
63. return true
64. }
66. ; internal stuff
67. refreshGTA() {
68. newPID := getPID("GTA:SA:MP")
69. if(!newPID) { ; GTA not found
70. if(hGTA) { ; open handle
71. virtualFreeEx(hGTA, pMemory, 0, 0x8000)
72. closeProcess(hGTA)
73. hGTA := 0x0
74. }
75. dwGTAPID := 0
76. hGTA := 0x0
77. dwSAMP := 0x0
78. pMemory := 0x0
79. return false
80. }
82. if(!hGTA || (dwGTAPID != newPID)) { ; changed PID, closed handle
83. hGTA := openProcess(newPID)
84. if(ErrorLevel) { ; openProcess fail
85. dwGTAPID := 0
86. hGTA := 0x0
87. dwSAMP := 0x0
88. pMemory := 0x0
89. return false
90. }
91. dwGTAPID := newPID
92. dwSAMP := 0x0
93. pMemory := 0x0
94. return true
95. }
96. return true
97. }
99. ; internal stuff
100. refreshSAMP() {
101. if(dwSAMP)
102. return true
104. dwSAMP := getModuleBaseAddress("samp.dll", hGTA)
105. if(!dwSAMP)
106. return false
108. versionByte := readMem(hGTA, dwSAMP + 0x1036, 1, "UChar")
109. sampVersion := versionByte == 0xD8 ? 1 : (versionByte == 0xA8 ? 2 : (versionByte == 0x78 ? 3 : 0))
110. if (!sampVersion)
111. return false
113. return true
114. }
116. ; internal stuff
117. refreshMemory() {
118. if(!pMemory) {
119. pMemory := virtualAllocEx(hGTA, 6144, 0x1000 | 0x2000, 0x40)
120. if(ErrorLevel) {
121. pMemory := 0x0
122. return false
123. }
124. pParam1 := pMemory
125. pParam2 := pMemory + 1024
126. pParam3 := pMemory + 2048
127. pParam4 := pMemory + 3072
128. pParam5 := pMemory + 4096
129. pInjectFunc := pMemory + 5120
130. }
131. return true
132. }
134. ; internal stuff
135. getPID(szWindow) {
136. local dwPID := 0
137. WinGet, dwPID, PID, %szWindow%
138. return dwPID
139. }
141. ; internal stuff
142. openProcess(dwPID, dwRights = 0x1F0FFF) {
143. hProcess := DllCall("OpenProcess"
144. , "UInt", dwRights
145. , "int", 0
146. , "UInt", dwPID
147. , "Uint")
148. if(hProcess == 0) {
149. ErrorLevel := ERROR_OPEN_PROCESS
150. return 0
151. }
153. ErrorLevel := ERROR_OK
154. return hProcess
155. }
157. ; internal stuff
158. closeProcess(hProcess) {
159. if(hProcess == 0) {
160. ErrorLevel := ERROR_INVALID_HANDLE
161. return 0
162. }
164. dwRet := DllCall( "CloseHandle"
165. , "Uint", hProcess
166. , "UInt")
167. ErrorLevel := ERROR_OK
168. }
170. ; internal stuff
171. getModuleBaseAddress(sModule, hProcess) {
172. if(!sModule) {
173. ErrorLevel := ERROR_MODULE_NOT_FOUND
174. return 0
175. }
177. if(!hProcess) {
178. ErrorLevel := ERROR_INVALID_HANDLE
179. return 0
180. }
182. dwSize = 1024*4 ; 1024 * sizeof(HMODULE = 4)
183. VarSetCapacity(hMods, dwSize)
184. VarSetCapacity(cbNeeded, 4) ; DWORD = 4
185. dwRet := DllCall( "Psapi.dll\EnumProcessModules"
186. , "UInt", hProcess
187. , "UInt", &hMods
188. , "UInt", dwSize
189. , "UInt*", cbNeeded
190. , "UInt")
191. if(dwRet == 0) {
192. ErrorLevel := ERROR_ENUM_PROCESS_MODULES
193. return 0
194. }
196. dwMods := cbNeeded / 4 ; cbNeeded / sizeof(HMDOULE = 4)
197. i := 0
198. VarSetCapacity(hModule, 4) ; HMODULE = 4
199. VarSetCapacity(sCurModule, 260) ; MAX_PATH = 260
200. while(i < dwMods) {
201. hModule := NumGet(hMods, i*4)
202. DllCall("Psapi.dll\GetModuleFileNameEx"
203. , "UInt", hProcess
204. , "UInt", hModule
205. , "Str", sCurModule
206. , "UInt", 260)
207. SplitPath, sCurModule, sFilename
208. if(sModule == sFilename) {
209. ErrorLevel := ERROR_OK
210. return hModule
211. }
212. i := i + 1
213. }
215. ErrorLevel := ERROR_MODULE_NOT_FOUND
216. return 0
217. }
219. ; internal stuff
220. readString(hProcess, dwAddress, dwLen) {
221. if(!hProcess) {
222. ErrorLevel := ERROR_INVALID_HANDLE
223. return 0
224. }
226. VarSetCapacity(sRead, dwLen)
227. dwRet := DllCall( "ReadProcessMemory"
228. , "UInt", hProcess
229. , "UInt", dwAddress
230. , "Str", sRead
231. , "UInt", dwLen
232. , "UInt*", 0
233. , "UInt")
234. if(dwRet == 0) {
235. ErrorLevel := ERROR_READ_MEMORY
236. return 0
237. }
239. ErrorLevel := ERROR_OK
240. if A_IsUnicode
241. return __ansiToUnicode(sRead)
242. return sRead
243. }
245. ; internal stuff
246. readFloat(hProcess, dwAddress) {
247. if(!hProcess) {
248. ErrorLevel := ERROR_INVALID_HANDLE
249. return 0
250. }
252. VarSetCapacity(dwRead, 4) ; float = 4
253. dwRet := DllCall( "ReadProcessMemory"
254. , "UInt", hProcess
255. , "UInt", dwAddress
256. , "Str", dwRead
257. , "UInt", 4
258. , "UInt*", 0
259. , "UInt")
260. if(dwRet == 0) {
261. ErrorLevel := ERROR_READ_MEMORY
262. return 0
263. }
265. ErrorLevel := ERROR_OK
266. return NumGet(dwRead, 0, "Float")
267. }
269. ; internal stuff
270. readDWORD(hProcess, dwAddress) {
271. if(!hProcess) {
272. ErrorLevel := ERROR_INVALID_HANDLE
273. return 0
274. }
276. VarSetCapacity(dwRead, 4) ; DWORD = 4
277. dwRet := DllCall( "ReadProcessMemory"
278. , "UInt", hProcess
279. , "UInt", dwAddress
280. , "Str", dwRead
281. , "UInt", 4
282. , "UInt*", 0)
283. if(dwRet == 0) {
284. ErrorLevel := ERROR_READ_MEMORY
285. return 0
286. }
288. ErrorLevel := ERROR_OK
289. return NumGet(dwRead, 0, "UInt")
290. }
292. ; internal stuff
293. readMem(hProcess, dwAddress, dwLen=4, type="UInt") {
294. if(!hProcess) {
295. ErrorLevel := ERROR_INVALID_HANDLE
296. return 0
297. }
299. VarSetCapacity(dwRead, dwLen)
300. dwRet := DllCall( "ReadProcessMemory"
301. , "UInt", hProcess
302. , "UInt", dwAddress
303. , "Str", dwRead
304. , "UInt", dwLen
305. , "UInt*", 0)
306. if(dwRet == 0) {
307. ErrorLevel := ERROR_READ_MEMORY
308. return 0
309. }
311. ErrorLevel := ERROR_OK
312. return NumGet(dwRead, 0, type)
313. }
315. ; internal stuff
316. writeString(hProcess, dwAddress, wString) {
317. if(!hProcess) {
318. ErrorLevel := ERROR_INVALID_HANDLE
319. return false
320. }
322. sString := wString
323. if A_IsUnicode
324. sString := __unicodeToAnsi(wString)
326. dwRet := DllCall( "WriteProcessMemory"
327. , "UInt", hProcess
328. , "UInt", dwAddress
329. , "Str", sString
330. , "UInt", StrLen(wString) + 1
331. , "UInt", 0
332. , "UInt")
333. if(dwRet == 0) {
334. ErrorLEvel := ERROR_WRITE_MEMORY
335. return false
336. }
338. ErrorLevel := ERROR_OK
339. return true
340. }
342. ; internal stuff
343. writeRaw(hProcess, dwAddress, pBuffer, dwLen) {
344. if(!hProcess) {
345. ErrorLevel := ERROR_INVALID_HANDLE
346. return false
347. }
349. dwRet := DllCall( "WriteProcessMemory"
350. , "UInt", hProcess
351. , "UInt", dwAddress
352. , "UInt", pBuffer
353. , "UInt", dwLen
354. , "UInt", 0
355. , "UInt")
356. if(dwRet == 0) {
357. ErrorLEvel := ERROR_WRITE_MEMORY
358. return false
359. }
361. ErrorLevel := ERROR_OK
362. return true
363. }
365. ; internal stuff
366. Memory_ReadByte(process_handle, address) {
367. VarSetCapacity(value, 1, 0)
368. DllCall("ReadProcessMemory", "UInt", process_handle, "UInt", address, "Str", value, "UInt", 1, "UInt *", 0)
369. return, NumGet(value, 0, "Byte")
370. }
372. ; internal stuff
373. callWithParams(hProcess, dwFunc, aParams, bCleanupStack = true) {
374. if(!hProcess) {
375. ErrorLevel := ERROR_INVALID_HANDLE
376. return false
377. }
378. validParams := 0
380. i := aParams.MaxIndex()
382. ; i * PUSH + CALL + RETN
383. dwLen := i * 5 + 5 + 1
384. if(bCleanupStack)
385. dwLen += 3
386. VarSetCapacity(injectData, i * 5 + 5 + 3 + 1, 0)
388. i_ := 1
389. while(i > 0) {
390. if(aParams[i][1] != "") {
391. dwMemAddress := 0x0
392. if(aParams[i][1] == "p") {
393. dwMemAddress := aParams[i][2]
394. } else if(aParams[i][1] == "s") {
395. if(i_>3)
396. return false
397. dwMemAddress := pParam%i_%
398. writeString(hProcess, dwMemAddress, aParams[i][2])
399. if(ErrorLevel)
400. return false
401. i_ += 1
402. } else if(aParams[i][1] == "i") {
403. dwMemAddress := aParams[i][2]
404. } else {
405. return false
406. }
407. NumPut(0x68, injectData, validParams * 5, "UChar")
408. NumPut(dwMemAddress, injectData, validParams * 5 + 1, "UInt")
409. validParams += 1
410. }
411. i -= 1
412. }
414. offset := dwFunc - ( pInjectFunc + validParams * 5 + 5 )
415. NumPut(0xE8, injectData, validParams * 5, "UChar")
416. NumPut(offset, injectData, validParams * 5 + 1, "Int")
418. if(bCleanupStack) {
419. NumPut(0xC483, injectData, validParams * 5 + 5, "UShort")
420. NumPut(validParams*4, injectData, validParams * 5 + 7, "UChar")
422. NumPut(0xC3, injectData, validParams * 5 + 8, "UChar")
423. } else {
424. NumPut(0xC3, injectData, validParams * 5 + 5, "UChar")
425. }
427. writeRaw(hGTA, pInjectFunc, &injectData, dwLen)
428. if(ErrorLevel)
429. return false
431. hThread := createRemoteThread(hGTA, 0, 0, pInjectFunc, 0, 0, 0)
432. if(ErrorLevel)
433. return false
435. waitForSingleObject(hThread, 0xFFFFFFFF)
437. closeProcess(hThread)
439. return true
440. }
442. ; internal stuff
443. virtualAllocEx(hProcess, dwSize, flAllocationType, flProtect) {
444. if(!hProcess) {
445. ErrorLevel := ERROR_INVALID_HANDLE
446. return 0
447. }
449. dwRet := DllCall( "VirtualAllocEx"
450. , "UInt", hProcess
451. , "UInt", 0
452. , "UInt", dwSize
453. , "UInt", flAllocationType
454. , "UInt", flProtect
455. , "UInt")
456. if(dwRet == 0) {
457. ErrorLEvel := ERROR_ALLOC_MEMORY
458. return 0
459. }
461. ErrorLevel := ERROR_OK
462. return dwRet
463. }
465. ; internal stuff
466. virtualFreeEx(hProcess, lpAddress, dwSize, dwFreeType) {
467. if(!hProcess) {
468. ErrorLevel := ERROR_INVALID_HANDLE
469. return 0
470. }
472. dwRet := DllCall( "VirtualFreeEx"
473. , "UInt", hProcess
474. , "UInt", lpAddress
475. , "UInt", dwSize
476. , "UInt", dwFreeType
477. , "UInt")
478. if(dwRet == 0) {
479. ErrorLEvel := ERROR_FREE_MEMORY
480. return 0
481. }
483. ErrorLevel := ERROR_OK
484. return dwRet
485. }
487. ; internal stuff
488. createRemoteThread(hProcess, lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, lpThreadId) {
489. if(!hProcess) {
490. ErrorLevel := ERROR_INVALID_HANDLE
491. return 0
492. }
494. dwRet := DllCall( "CreateRemoteThread"
495. , "UInt", hProcess
496. , "UInt", lpThreadAttributes
497. , "UInt", dwStackSize
498. , "UInt", lpStartAddress
499. , "UInt", lpParameter
500. , "UInt", dwCreationFlags
501. , "UInt", lpThreadId
502. , "UInt")
503. if(dwRet == 0) {
504. ErrorLEvel := ERROR_ALLOC_MEMORY
505. return 0
506. }
508. ErrorLevel := ERROR_OK
509. return dwRet
510. }
512. ; internal stuff
513. waitForSingleObject(hThread, dwMilliseconds) {
514. if(!hThread) {
515. ErrorLevel := ERROR_INVALID_HANDLE
516. return 0
517. }
519. dwRet := DllCall( "WaitForSingleObject"
520. , "UInt", hThread
521. , "UInt", dwMilliseconds
522. , "UInt")
523. if(dwRet == 0xFFFFFFFF) {
524. ErrorLEvel := ERROR_WAIT_FOR_OBJECT
525. return 0
526. }
528. ErrorLevel := ERROR_OK
529. return dwRet
530. }
532. ; internal stuff
533. __ansiToUnicode(sString, nLen = 0) {
534. If !nLen
535. {
536. nLen := DllCall("MultiByteToWideChar"
537. , "Uint", 0
538. , "Uint", 0
539. , "Uint", &sString
540. , "int", -1
541. , "Uint", 0
542. , "int", 0)
543. }
545. VarSetCapacity(wString, nLen * 2)
547. DllCall("MultiByteToWideChar"
548. , "Uint", 0
549. , "Uint", 0
550. , "Uint", &sString
551. , "int", -1
552. , "Uint", &wString
553. , "int", nLen)
555. return wString
556. }
558. ; internal stuff
559. __unicodeToAnsi(wString, nLen = 0) {
560. pString := wString + 1 > 65536 ? wString : &wString
562. If !nLen
563. {
564. nLen := DllCall("WideCharToMultiByte"
565. , "Uint", 0
566. , "Uint", 0
567. , "Uint", pString
568. , "int", -1
569. , "Uint", 0
570. , "int", 0
571. , "Uint", 0
572. , "Uint", 0)
573. }
575. VarSetCapacity(sString, nLen)
577. DllCall("WideCharToMultiByte"
578. , "Uint", 0
579. , "Uint", 0
580. , "Uint", pString
581. , "int", -1
582. , "str", sString
583. , "int", nLen
584. , "Uint", 0
585. , "Uint", 0)
586. return sString
587. }

Alles anzeigen

Sehr nett von dir das werde ich später testen.

Ich danke dir vielmals