Покажите как написать скрипт, с объяснением

[Hakor]

В игре есть полоска энергии, она уменьшается когда, к примеру, стреляешь огненным шаром
вот функция:

1077D020 - 55                    - push ebp { 〈push word or doubleword onto the stack〉 %s }
1077D021 - 8B EC                 - mov ebp,esp { 〈copy memory〉 %s }
1077D023 - 64 A1 00000000        - mov eax,fs:[00000000] { 〈copy memory〉 %s }
1077D029 - 6A FF                 - push -01 { 〈push byte onto the stack〉 %s }
1077D02B - 68 0C63F010           - push 10F0630C { 〈push word or doubleword onto the stack (sign extended)〉 %s }
1077D030 - 50                    - push eax { 〈push word or doubleword onto the stack〉 %s }
1077D031 - 64 89 25 00000000     - mov fs:[00000000],esp { 〈copy memory〉 %s }
1077D038 - 83 EC 0C              - sub esp,0C { 〈subtract〉 %s }
1077D03B - 64 A1 2C000000        - mov eax,fs:[0000002C] { 〈copy memory〉 %s }
1077D041 - 8B 15 44F19911        - mov edx,[1199F144] { 〈copy memory〉 %s }
1077D047 - 56                    - push esi { 〈push word or doubleword onto the stack〉 %s }
1077D048 - 57                    - push edi { 〈push word or doubleword onto the stack〉 %s }
1077D049 - 8B 14 90              - mov edx,[eax+edx*4] { 〈copy memory〉 %s }
1077D04C - 8B F9                 - mov edi,ecx { 〈copy memory〉 %s }
1077D04E - A1 686D7211           - mov eax,[11726D68] { 〈copy memory〉 %s }
1077D053 - 3B 82 08010000        - cmp eax,[edx+00000108] { 〈compare two operands〉 %s }
1077D059 - 0F8F F0000000         - jg 1077D14F { 〈jump near if greater (ZF=0 and SF=OF)〉 %s }
1077D05F - A1 5C6D7211           - mov eax,[11726D5C] { 〈copy memory〉 %s }
1077D064 - 83 EC 0C              - sub esp,0C { 〈subtract〉 %s }
1077D067 - D9 45 08              - fld dword ptr [ebp+08] { 〈load floating point value〉 %s }
1077D06A - 8B CC                 - mov ecx,esp { 〈copy memory〉 %s }
1077D06C - D9 5C 24 08           - fstp dword ptr [esp+08] { 〈store single〉 %s }
1077D070 - 89 01                 - mov [ecx],eax { 〈copy memory〉 %s }
1077D072 - A1 606D7211           - mov eax,[11726D60] { 〈copy memory〉 %s }
1077D077 - 89 41 04              - mov [ecx+04],eax { 〈copy memory〉 %s }
1077D07A - 8B CF                 - mov ecx,edi { 〈copy memory〉 %s }
1077D07C - E8 69E07BFF           - call 0FF3B0EA { 〈call procedure〉 %s }
1077D081 - F3 0F10 87 C00C0000   - movss xmm0,[edi+00000CC0] { 〈move scalar single-fp〉 %s }
1077D089 - 0F57 C9               - xorps xmm1,xmm1 { 〈bit-wise logical xor for single-fp data〉 %s }
1077D08C - D9 5D 08              - fstp dword ptr [ebp+08] { 〈store single〉 %s }
1077D08F - D9 45 08              - fld dword ptr [ebp+08] { 〈load floating point value〉 %s }
1077D092 - D9 5D 08              - fstp dword ptr [ebp+08] { 〈store single〉 %s }
1077D095 - D9 87 BC0C0000        - fld dword ptr [edi+00000CBC] { 〈load floating point value〉 %s }
1077D09B - D8 65 08              - fsub dword ptr [ebp+08] { 〈substract〉 %s }
1077D09E - F3 0F11 45 EC         - movss [ebp-14],xmm0 { 〈move scalar single-fp〉 %s }
1077D0A3 - D9 5D F0              - fstp dword ptr [ebp-10] { 〈store single〉 %s }
1077D0A6 - D9 45 F0              - fld dword ptr [ebp-10] { 〈load floating point value〉 %s }
1077D0A9 - D9EE                  - fldz  { 〈Push +0.0 onto the FPU register stack〉 %s }
1077D0AB - DFF1                  - fcomip st(0),st(1) { 〈compare real and set eflags〉 %s }
1077D0AD - 76 07                 - jna 1077D0B6 { 〈jump short if not above (ZF=1 or CF=1)〉 %s }
1077D0AF - DDD8                  - fstp st(0) { 〈store real〉 %s }
1077D0B1 - 0F28 C1               - movaps xmm0,xmm1 { 〈move aligned four packed single-fp〉 %s }
1077D0B4 - EB 0E                 - jmp 1077D0C4 { 〈jump short〉 %s }
1077D0B6 - D9 45 EC              - fld dword ptr [ebp-14] { 〈load floating point value〉 %s }
1077D0B9 - DFF1                  - fcomip st(0),st(1) { 〈compare real and set eflags〉 %s }
1077D0BB - DDD8                  - fstp st(0) { 〈store real〉 %s }
1077D0BD - 76 05                 - jna 1077D0C4 { 〈jump short if not above (ZF=1 or CF=1)〉 %s }
1077D0BF - F3 0F10 45 F0         - movss xmm0,[ebp-10] { 〈move scalar single-fp〉 %s }
1077D0C4 - F3 0F11 87 BC0C0000   - movss [edi+00000CBC],xmm0 { 〈move scalar single-fp〉 %s }
1077D0CC - F3 0F10 45 08         - movss xmm0,[ebp+08] { 〈move scalar single-fp〉 %s }
1077D0D1 - 0F2E C1               - ucomiss xmm0,xmm1 { 〈unordered scalar single-fp compare and set eflags〉 %s }
1077D0D4 - 9F                    - lahf  { 〈load status flag into ah register〉 %s }
1077D0D5 - F6 C4 44              - test ah,44 { 〈logical compare〉 %s }
1077D0D8 - 7B 63                 - jnp 1077D13D { 〈jump short if not parity (PF=0)〉 %s }
1077D0DA - 8B 07                 - mov eax,[edi] { 〈copy memory〉 %s }
1077D0DC - 8B CF                 - mov ecx,edi { 〈copy memory〉 %s }
1077D0DE - FF 90 48050000        - call dword ptr [eax+00000548] { 〈call procedure〉 %s }
1077D0E4 - 8B 07                 - mov eax,[edi] { 〈copy memory〉 %s }
1077D0E6 - 8B CF                 - mov ecx,edi { 〈copy memory〉 %s }
1077D0E8 - FF 90 B4050000        - call dword ptr [eax+000005B4] { 〈call procedure〉 %s }
1077D0EE - 8B 8F 10010000        - mov ecx,[edi+00000110] { 〈copy memory〉 %s }
1077D0F4 - 8B 49 5C              - mov ecx,[ecx+5C] { 〈copy memory〉 %s }
1077D0F7 - E8 E7D67CFF           - call 0FF4A7E3 { 〈call procedure〉 %s }
1077D0FC - 8B C8                 - mov ecx,eax { 〈copy memory〉 %s }
1077D0FE - E8 5C207BFF           - call 0FF2F15F { 〈call procedure〉 %s }
1077D103 - F3 0F10 45 08         - movss xmm0,[ebp+08] { 〈move scalar single-fp〉 %s }
1077D108 - 8B F0                 - mov esi,eax { 〈copy memory〉 %s }
1077D10A - 6A 00                 - push 00 { 〈push byte onto the stack〉 %s }
1077D10C - 8D 45 E8              - lea eax,[ebp-18] { 〈load effective address〉 %s }
1077D10F - 89 7D E8              - mov [ebp-18],edi { 〈copy memory〉 %s }
1077D112 - 50                    - push eax { 〈push word or doubleword onto the stack〉 %s }
1077D113 - A1 BCBC7211           - mov eax,[1172BCBC] { 〈copy memory〉 %s }
1077D118 - 6A 00                 - push 00 { 〈push byte onto the stack〉 %s }
1077D11A - 83 EC 08              - sub esp,08 { 〈subtract〉 %s }
1077D11D - F3 0F11 45 EC         - movss [ebp-14],xmm0 { 〈move scalar single-fp〉 %s }
1077D122 - 8B CC                 - mov ecx,esp { 〈copy memory〉 %s }
1077D124 - 89 01                 - mov [ecx],eax { 〈copy memory〉 %s }
1077D126 - A1 C0BC7211           - mov eax,[1172BCC0] { 〈copy memory〉 %s }
1077D12B - 89 41 04              - mov [ecx+04],eax { 〈copy memory〉 %s }
1077D12E - 8B CE                 - mov ecx,esi { 〈copy memory〉 %s }
1077D130 - E8 30327CFF           - call 0FF40365 { 〈call procedure〉 %s }
1077D135 - 8B 16                 - mov edx,[esi] { 〈copy memory〉 %s }
1077D137 - 8B CE                 - mov ecx,esi { 〈copy memory〉 %s }
1077D139 - 50                    - push eax { 〈push word or doubleword onto the stack〉 %s }
1077D13A - FF 52 0C              - call dword ptr [edx+0C] { 〈call procedure〉 %s }
1077D13D - 8B 4D F4              - mov ecx,[ebp-0C] { 〈copy memory〉 %s }
1077D140 - 5F                    - pop edi { 〈pop a value from the stack〉 %s }
1077D141 - 64 89 0D 00000000     - mov fs:[00000000],ecx { 〈copy memory〉 %s }
1077D148 - 5E                    - pop esi { 〈pop a value from the stack〉 %s }
1077D149 - 8B E5                 - mov esp,ebp { 〈copy memory〉 %s }
1077D14B - 5D                    - pop ebp { 〈pop a value from the stack〉 %s }
1077D14C - C2 0400               - ret 0004 { 〈near return to calling procedure and pop 4 bytes from stack〉 %s }
1077D14F - 68 686D7211           - push 11726D68 { 〈push word or doubleword onto the stack (sign extended)〉 %s }
1077D154 - E8 64087BFF           - call 0FF2D9BD { 〈call procedure〉 %s }
1077D159 - 83 C4 04              - add esp,04 { 〈add (sign extended)〉 %s }
1077D15C - 83 3D 686D7211 FF     - cmp dword ptr [11726D68],-01 { 〈compare two operands〉 %s }
1077D163 - 0F85 F6FEFFFF         - jne 1077D05F { 〈jump near if not equal (ZF=0)〉 %s }
1077D169 - 6A 01                 - push 01 { 〈push byte onto the stack〉 %s }
1077D16B - 6A 02                 - push 02 { 〈push byte onto the stack〉 %s }
1077D16D - 68 A8C00311           - push 1103C0A8 { 〈push word or doubleword onto the stack (sign extended)〉 %s }
1077D172 - B9 5C6D7211           - mov ecx,11726D5C { 〈copy memory〉 %s }
1077D177 - C7 45 FC 00000000     - mov [ebp-04],00000000 { 〈copy memory〉 %s }
1077D17E - E8 81CA7BFF           - call 0FF39C04 { 〈call procedure〉 %s }
1077D183 - 68 686D7211           - push 11726D68 { 〈push word or doubleword onto the stack (sign extended)〉 %s }
1077D188 - C7 45 FC FFFFFFFF     - mov [ebp-04],FFFFFFFF { 〈copy memory〉 %s }
1077D18F - E8 81927AFF           - call 0FF26415 { 〈call procedure〉 %s }
1077D194 - 83 C4 04              - add esp,04 { 〈add (sign extended)〉 %s }
1077D197 - E9 C3FEFFFF           - jmp 1077D05F { 〈jump near〉 %s }

В игре я нашёл конкретное значение этой полоски, адрес со значением 130
Нашел инструкцию, которая записывают в данный адрес, это movss [edi+00000CBC],xmm0 по адресу 1077D0C4
Если её отключить (nop), то энергия не отнимается
Есть ещё одна инструкция по адресу 10E9D09B, это fsub dword ptr [ebp+08], вместо fsub я ставил fadd, до какого-то момента работало (вместо уменьшения полоска прибавлялась), и после перезапуска игры, и с сохранением и загрузкой, но в какой-то момент игра начала вылетать, когда включал скрипт, скрипт простой вот такой был:

[ENABLE]
10E9D09B:
db D8 45 08 F3 0F 11 45 EC

[DISABLE]
10E9D09B:
db D8 65 08 F3 0F 11 45 EC

Ставить nop куда-либо я понял вообще идея не очень
Как сделать максимально рабочий и простой вариант? Вообще что лучше, инъекция кода, полная инъекция или AOB?
Кстати, сделал movss xmm0,[edi+00000CBC] вместо movss [edi+00000CBC],xmm0 - тоже не отнимается энергия, но какие осложнения могут быть при таких манипуляциях?

[StoneWeaver]

Пользователь @Hakor написал в Покажите как написать скрипт, с объяснением:

Вообще что лучше, инъекция кода, полная инъекция или AOB?

Что ты подразумеваешь под каждым из этих вариантов?

Пользователь @Hakor написал в Покажите как написать скрипт, с объяснением:

Кстати, сделал movss xmm0,[edi+00000CBC] вместо movss [edi+00000CBC],xmm0 - тоже не отнимается энергия, но какие осложнения могут быть при таких манипуляциях?

А у тебя есть понимание, что конкретно ты сделал этой заменой? В реверсинге нужно чётко понимать, что ты делаешь. Методом тыка иногда можно добиться нужного результата, но не получится понять, почему игра вдруг начинает вылетать через какое-то время. Если ты не понимаешь, что ты делаешь, сделай паузу, разберись, что конкретно ты делаешь, какой при этом будет результат, и какие могут быть последствия и/или побочные эффекты. Только после этого ты делай что-то.