[Помогите!] Не работает инжект движения в полете

[Smerch]

Собственно, использую след. инжект:

 procedure MoveASM(pParam: PMove);Stdcall; //StdCall - обязательно, указывает что аргументы попадают в стек в обратном (стандартном) порядке
var                                         //
  P1,flying,CallAddr1,CallAddr2,CallAddr3, BaseAddr: DWord;
  x,y,z: Single;
begin                                       //
  x:= pParam^.x;
  y:= pParam^.y;
  z:= pParam^.z;
  CallAddr1:= CallAdress1;
  CallAddr2:= CallAdress2;
  CallAddr3:= CallAdress3;                   //
  BaseAddr := BaseAdress;
  flying := pParam^.fly;
  asm
    pushad
    mov eax, BaseAddr
    mov eax, dword ptr [eax]
    mov eax, dword ptr [eax+$1C]
    mov edi, dword ptr [eax+$34]      //20
    mov ecx, dword ptr [edi+$154C]
    push 1
    call CallAddr1
    lea edx, dword ptr [esp+$1C]     //18
    mov esi, eax
    push edx
    push flying
    mov ecx, esi
    call CallAddr2
    mov ecx, dword ptr [edi+$154C]
    mov eax, x
    mov dword ptr[esi+$20], eax
    mov eax, z
    mov dword ptr[esi+$24], eax
    mov eax, y
    mov dword ptr[esi+$28], eax
    push 0
    push esi
    push 1
    call CallAddr3
    popad
  end;
end;

Он работает, если персонаж на земле, но если я поставлю flying = 2, а персонаж будет в воздухе, то в результате персонаж летит куда-то за край карты. Если менять координату z, то персонаж все равно остается на одной и той же высота. Даже если в передать текущие координаты в функцию, то персонаж упорно летит за карту. В чем проблема?



UPD: проблеме решена, оказывается что в полете, что в воде нужно ставить flying = 1. Непонятно почему, но это так.

[KLAIDY]

Привет всем! Пытаюсь переписать на шарп вышеуказанный инжект, но чего-то лыжи не едут(( Может быть кто-нибудь подскажет, что я делаю не так?(

public static void WalkTo(int processID, float X, float Y, float Z, int walk)
        {
            //так как при walk_mode=2 надо инжектить значение 1
            int walk_mode = 1;
            if (walk == 0) walk_mode = 0;

            // ---- открываем процесс
            IntPtr oph = WinApi.OpenProcess(WinApi.ProcessAccessFlags.All, false, processID);

            // ---- Создаем скелет пакета для инжектирования

            byte[] walk_packet =
            {
                0x60,                               //pushad
                0xB8, 0x00, 0x00, 0x00, 0x00,       //mov eax, BA
                0x8B, 0x00,                         //mox eax, dword ptr [eax]
                0x8B, 0x40, 0x1c,                   //mov eax, dword ptr[eax + 1C]
                0x8B, 0x78, 0x34,                   //mov edi, dword ptr[eax + 0x34]
                0x8B, 0x8F, 0x4C, 0x15, 0x00, 0x00, //mov ecx, dword ptr[edi + 0x154C]
                0x68, 0x1,                          //push 1
                0xE8, 0x00, 0x00, 0x00, 0x00,       //call Action_1
                0x8D, 0x54, 0x24, 0x1C,             //lea edx, dword ptr[esp + 0x1C]
                0x8B, 0xF0,                         //mov esi, eax
                0x52,                               //push edx
                0xFF, 0x35, 0x00, 0x00, 0x00, 0x00, //push walk_mode
                0x8B, 0xCE,                         //mov ecx, esi
                0xE8, 0x00, 0x00, 0x00, 0x00,       //call Action_2
                0x8B, 0x8F, 0x4C, 0x15, 0x00, 0x00, //mov ecx, dword ptr [edi + 0x154C]
                0x8B, 0x00, 0x00, 0x00, 0x00,       //mov eax, x
                0x89, 0x46, 0x20,                   //mov dword ptr[esi + 0x20], eax
                0x8B, 0x00, 0x00, 0x00, 0x00,       //mov eax, z
                0x89, 0x46, 0x24,                   //mov dword ptr[esi + 0x24], eax
                0x8B, 0x00, 0x00, 0x00, 0x00,       //mov eax, y
                0x89, 0x46, 0x28,                   //mov dword ptr[esi + 0x28], eax
                0x6A, 0x00,                         //push 0
                0x56,                               //push esi
                0x6A, 0x01,                         //push 1
                0xE8, 0x0, 0x0, 0x0, 0x0,           //call Action_3
                0x61,                               //popad
                0xC3                                //ret
            };

            // ---- пишем BA
            Buffer.BlockCopy(BitConverter.GetBytes(Offsets.BaseAdress), 0, walk_packet, 2, 4);
            // ---- пишем Action_1, Action_2, Action_3
            Buffer.BlockCopy(BitConverter.GetBytes(Offsets.Action_1), 0, walk_packet, 23, 4);
            Buffer.BlockCopy(BitConverter.GetBytes(Offsets.Action_2), 0, walk_packet, 43, 4);
            Buffer.BlockCopy(BitConverter.GetBytes(Offsets.Action_3), 0, walk_packet, 83, 4);
            // ---- пишем walk_mode
            Buffer.BlockCopy(BitConverter.GetBytes(walk_mode), 0, walk_packet, 36, 4);
            // ---- пишем X, Y, Z
            Buffer.BlockCopy(BitConverter.GetBytes(X), 0, walk_packet, 54, 4);
            Buffer.BlockCopy(BitConverter.GetBytes(Z), 0, walk_packet, 62, 4);
            Buffer.BlockCopy(BitConverter.GetBytes(Y), 0, walk_packet, 70, 4);
            // ---- временные переменные
            int lpNumberOfBytesWritten = 0;
            IntPtr lpThreadId;
            // ---- выделяем место в памяти
            IntPtr walk_address = WinApi.VirtualAllocEx(oph, IntPtr.Zero, walk_packet.Length, WinApi.AllocationType.Commit, WinApi.MemoryProtection.ReadWrite);
            // ---- записываем в выделенную память наш пакет
            WinApi.WriteProcessMemory(oph, (int)walk_address, walk_packet, walk_packet.Length, out lpNumberOfBytesWritten);
            // ---- запускаем записанную в память функцию
            IntPtr hProcThread = WinApi.CreateRemoteThread(oph, IntPtr.Zero, 0, walk_address, IntPtr.Zero, 0, out lpThreadId);
            // ---- Ожидаем завершения функции
            WinApi.WaitForSingleObject(hProcThread, WinApi.INFINITE);
            // ---- подчищаем за собой
            WinApi.VirtualFreeEx(oph, walk_address, walk_packet.Length, WinApi.FreeType.Release);
            WinApi.VirtualFreeEx(oph, hProcThread, walk_packet.Length, WinApi.FreeType.Release);
            WinApi.CloseHandle(oph);         
        }

[KLAIDY]

В общем по старой доброй традиции "сам спросил - сам ответил" вот решение:
правильный опкод для инжектирования (возможны небольшие вариации, но логика действий такая)

byte[] walk_packet =
            {
                0x60,                                       //pushad
                0xB8, /*2*/0x00, 0x00, 0x00, 0x00,          //mov eax, BA
                0x8B, 0x00,                                 //mox eax, dword ptr [eax]
                0x8B, 0x40, 0x1c,                           //mov eax, dword ptr[eax + 1C]
                0x8B, 0x78, 0x34,                           //mov edi, dword ptr[eax + 0x34]
                0x8B, 0x8F, 0x4C, 0x15, 0x00, 0x00,         //mov ecx, dword ptr[edi + 0x154C]
                0x6A, 0x01,                                 //push 1
                0xB8, /*23*/0x00, 0x00, 0x00, 0x00,         //mov eax, action_1
                0xFF, 0xD0,                                 //call eax
                0x8D, 0x54, 0x24, 0x1C,                     //lea edx, dword ptr[esp + 0x1C]
                0x8B, 0xD8,                                 //mov ebx, eax
                0x52,                                       //push edx
                0x68, /*37*/0x00, 0x00, 0x00, 0x00,         //push walk_mode
                0x8B, 0xCB,                                 //mov ecx, ebx
                0xB8, /*44*/0x00, 0x00, 0x00, 0x00,         //mov eax, action_2
                0xFF, 0xD0,                                 //call eax
                0x8B, 0x8F, 0x4C, 0x15, 0x00, 0x00,         //mov ecx, dword ptr [edi + 0x154C]
                0xB8, /*57*/0x00, 0x00, 0x00, 0x00,         //mov eax, x
                0x89, 0x43, 0x20,                           //mov dword ptr[ebx + 0x20], eax
                0xB8, /*65*/0x00, 0x00, 0x00, 0x00,         //mov eax, z
                0x89, 0x43, 0x24,                           //mov dword ptr[ebx + 0x24], eax
                0xB8, /*73*/0x00, 0x00, 0x00, 0x00,         //mov eax, y
                0x89, 0x43, 0x28,                           //mov dword ptr[ebx + 0x28], eax
                0x6A, 0x00,                                 //push 0
                0x53,                                       //push ebx
                0x6A, 0x01,                                 //push 1
                0xB8, /*86*/0x00, 0x00, 0x00, 0x00,         //mov eax, action_2
                0xFF, 0xD0,                                 //call eax
                0x61,                                       //popad
                0xC3                                        //ret
            };

0x34 - структура персонажа
0x154c - массив действий персонажа