Исходник трейнера на C# без дополнительных DLL(с помощью VAMemory)

[крайслер]

Исходник трейнера, в данном случаи работающее ESP, без необходимости держать рядом с ExE, DLL VAMemory.dll...Класс прописан в коде...

[Ссылки могут видеть только зарегистрированные пользователи. ]



Реализованы ГлобалКей...(указываются десятичным кодом [Ссылки могут видеть только зарегистрированные пользователи. ])
Включение\выключение по нажатию клавиши "V"...

class VAMemory

public class VAMemory
    {

        private enum ProcessAccessFlags : uint
        {
            All = 0x1f0fff,
            CreateThread = 2,
            DupHandle = 0x40,
            QueryInformation = 0x400,
            SetInformation = 0x200,
            Synchronize = 0x100000,
            Terminate = 1,
            VMOperation = 8,
            VMRead = 0x10,
            VMWrite = 0x20

        }
        private enum VirtualMemoryProtection : uint
        {
            PAGE_EXECUTE = 0x10,
            PAGE_EXECUTE_READ = 0x20,
            PAGE_EXECUTE_READWRITE = 0x40,
            PAGE_EXECUTE_WRITECOPY = 0x80,
            PAGE_GUARD = 0x100,
            PAGE_NOACCESS = 1,
            PAGE_NOCACHE = 0x200,
            PAGE_READONLY = 2,
            PAGE_READWRITE = 4,
            PAGE_WRITECOPY = 8,
            PROCESS_ALL_ACCESS = 0x1f0fff

        }
        public static bool debugMode = false;
        private IntPtr baseAddress;
        private ProcessModule processModule;
        private Process[] mainProcess;
        private IntPtr processHandle;
        public string processName
        {
            get;
            set;
        }
        public long getBaseAddress
        {
            get
            {
                this.baseAddress = (IntPtr)0;
                this.processModule = this.mainProcess[0].MainModule;
                this.baseAddress = this.processModule.BaseAddress;
                return (long)this.baseAddress;
            }
        }
        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint dwSize, uint lpNumberOfBytesRead);
        [DllImport("kernel32.dll")]
        private static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint nSize, uint lpNumberOfBytesWritten);
        [DllImport("kernel32.dll")]
        private static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle, int dwProcessId);
        [DllImport("kernel32.dll")]
        private static extern bool CloseHandle(IntPtr hObject);
        [DllImport("kernel32.dll")]
        private static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress, UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);
        [DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true)]
        private static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
        public VAMemory()
        {
        }
        public VAMemory(string pProcessName)
        {
            this.processName = pProcessName;
        }
        public bool CheckProcess()
        {
            bool result;
            if (this.processName != null)
            {
                this.mainProcess = Process.GetProcessesByName(this.processName);
                if (this.mainProcess.Length == 0)
                {
                    this.ErrorProcessNotFound(this.processName);
                    result = false;
                }
                else
                {
                    this.processHandle = VAMemory.OpenProcess(2035711u, false, this.mainProcess[0].Id);
                    if (this.processHandle == IntPtr.Zero)
                    {
                        this.ErrorProcessNotFound(this.processName);
                        result = false;
                    }
                    else
                    {
                        result = true;
                    }
                }
            }
            else
            {
                MessageBox.Show("Programmer, define process name first!");
                result = false;
            }
            return result;
        }
        public byte[] ReadByteArray(IntPtr pOffset, uint pSize)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            byte[] result;
            try
            {
                uint flNewProtect;
                VAMemory.VirtualProtectEx(this.processHandle, pOffset, (UIntPtr)pSize, 4u, out flNewProtect);
                byte[] array = new byte[pSize];
                VAMemory.ReadProcessMemory(this.processHandle, pOffset, array, pSize, 0u);
                VAMemory.VirtualProtectEx(this.processHandle, pOffset, (UIntPtr)pSize, flNewProtect, out flNewProtect);
                result = array;
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadByteArray" + ex.ToString());
                }
                result = new byte[1];
            }
            return result;
        }
        public string ReadStringUnicode(IntPtr pOffset, uint pSize)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            string result;
            try
            {
                result = Encoding.Unicode.GetString(this.ReadByteArray(pOffset, pSize), 0, (int)pSize);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadStringUnicode" + ex.ToString());
                }
                result = "";
            }
            return result;
        }
        public string ReadStringASCII(IntPtr pOffset, uint pSize)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            string result;
            try
            {
                result = Encoding.ASCII.GetString(this.ReadByteArray(pOffset, pSize), 0, (int)pSize);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadStringASCII" + ex.ToString());
                }
                result = "";
            }
            return result;
        }
        public char ReadChar(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            char result;
            try
            {
                result = BitConverter.ToChar(this.ReadByteArray(pOffset, 1u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadChar" + ex.ToString());
                }
                result = ' ';
            }
            return result;
        }
        public bool ReadBoolean(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = BitConverter.ToBoolean(this.ReadByteArray(pOffset, 1u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadByte" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public byte ReadByte(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            byte result;
            try
            {
                result = this.ReadByteArray(pOffset, 1u)[0];
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadByte" + ex.ToString());
                }
                result = 0;
            }
            return result;
        }
        public short ReadInt16(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            short result;
            try
            {
                result = BitConverter.ToInt16(this.ReadByteArray(pOffset, 2u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadInt16" + ex.ToString());
                }
                result = 0;
            }
            return result;
        }
        public short ReadShort(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            short result;
            try
            {
                result = BitConverter.ToInt16(this.ReadByteArray(pOffset, 2u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadInt16" + ex.ToString());
                }
                result = 0;
            }
            return result;
        }
        public int ReadInt32(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            int result;
            try
            {
                result = BitConverter.ToInt32(this.ReadByteArray(pOffset, 4u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadInt32" + ex.ToString());
                }
                result = 0;
            }
            return result;
        }
        public int ReadInteger(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            int result;
            try
            {
                result = BitConverter.ToInt32(this.ReadByteArray(pOffset, 4u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadInteger" + ex.ToString());
                }
                result = 0;
            }
            return result;
        }
        public long ReadInt64(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            long result;
            try
            {
                result = BitConverter.ToInt64(this.ReadByteArray(pOffset, 8u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadInt64" + ex.ToString());
                }
                result = 0L;
            }
            return result;
        }
        public long ReadLong(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            long result;
            try
            {
                result = BitConverter.ToInt64(this.ReadByteArray(pOffset, 8u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadLong" + ex.ToString());
                }
                result = 0L;
            }
            return result;
        }
        public ushort ReadUInt16(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            ushort result;
            try
            {
                result = BitConverter.ToUInt16(this.ReadByteArray(pOffset, 2u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadUInt16" + ex.ToString());
                }
                result = 0;
            }
            return result;
        }
        public ushort ReadUShort(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            ushort result;
            try
            {
                result = BitConverter.ToUInt16(this.ReadByteArray(pOffset, 2u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadUShort" + ex.ToString());
                }
                result = 0;
            }
            return result;
        }
        public uint ReadUInt32(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            uint result;
            try
            {
                result = BitConverter.ToUInt32(this.ReadByteArray(pOffset, 4u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadUInt32" + ex.ToString());
                }
                result = 0u;
            }
            return result;
        }
        public uint ReadUInteger(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            uint result;
            try
            {
                result = BitConverter.ToUInt32(this.ReadByteArray(pOffset, 4u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadUInteger" + ex.ToString());
                }
                result = 0u;
            }
            return result;
        }
        public ulong ReadUInt64(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            ulong result;
            try
            {
                result = BitConverter.ToUInt64(this.ReadByteArray(pOffset, 8u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadUInt64" + ex.ToString());
                }
                result = 0uL;
            }
            return result;
        }
        public long ReadULong(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            long result;
            try
            {
                result = (long)BitConverter.ToUInt64(this.ReadByteArray(pOffset, 8u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadULong" + ex.ToString());
                }
                result = 0L;
            }
            return result;
        }
        public float ReadFloat(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            float result;
            try
            {
                result = BitConverter.ToSingle(this.ReadByteArray(pOffset, 4u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadFloat" + ex.ToString());
                }
                result = 0f;
            }
            return result;
        }
        public double ReadDouble(IntPtr pOffset)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            double result;
            try
            {
                result = BitConverter.ToDouble(this.ReadByteArray(pOffset, 8u), 0);
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: ReadDouble" + ex.ToString());
                }
                result = 0.0;
            }
            return result;
        }
        public bool WriteByteArray(IntPtr pOffset, byte[] pBytes)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                uint flNewProtect;
                VAMemory.VirtualProtectEx(this.processHandle, pOffset, (UIntPtr)((ulong)((long)pBytes.Length)), 4u, out flNewProtect);
                bool flag = VAMemory.WriteProcessMemory(this.processHandle, pOffset, pBytes, (uint)pBytes.Length, 0u);
                VAMemory.VirtualProtectEx(this.processHandle, pOffset, (UIntPtr)((ulong)((long)pBytes.Length)), flNewProtect, out flNewProtect);
                result = flag;
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteByteArray" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteStringUnicode(IntPtr pOffset, string pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, Encoding.Unicode.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteStringUnicode" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteStringASCII(IntPtr pOffset, string pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, Encoding.ASCII.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteStringASCII" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteBoolean(IntPtr pOffset, bool pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteBoolean" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteChar(IntPtr pOffset, char pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteChar" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteByte(IntPtr pOffset, byte pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes((short)pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteByte" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteInt16(IntPtr pOffset, short pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteInt16" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteShort(IntPtr pOffset, short pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteShort" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteInt32(IntPtr pOffset, int pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteInt32" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteInteger(IntPtr pOffset, int pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteInt" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteInt64(IntPtr pOffset, long pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteInt64" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteLong(IntPtr pOffset, long pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteLong" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteUInt16(IntPtr pOffset, ushort pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteUInt16" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteUShort(IntPtr pOffset, ushort pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteShort" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteUInt32(IntPtr pOffset, uint pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteUInt32" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteUInteger(IntPtr pOffset, uint pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteUInt" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteUInt64(IntPtr pOffset, ulong pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteUInt64" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteULong(IntPtr pOffset, ulong pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteULong" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteFloat(IntPtr pOffset, float pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteFloat" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        public bool WriteDouble(IntPtr pOffset, double pData)
        {
            if (this.processHandle == IntPtr.Zero)
            {
                this.CheckProcess();
            }
            bool result;
            try
            {
                result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
            }
            catch (Exception ex)
            {
                if (VAMemory.debugMode)
                {
                    Console.WriteLine("Error: WriteDouble" + ex.ToString());
                }
                result = false;
            }
            return result;
        }
        private void ErrorProcessNotFound(string pProcessName)
        {
            MessageBox.Show(this.processName + " is not running or has not been found. Please check and try again", "Process Not Found", MessageBoxButtons.OK, MessageBoxIcon.Hand);
        }
    }

Требует:

using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;

[Ссылки могут видеть только зарегистрированные пользователи. ]
[Ссылки могут видеть только зарегистрированные пользователи. ]

[maSter™]

скрытие я так понимаю самому?!
сяп за исход)
да и тут
разве не PointBlank.exe.exe ?

[крайслер]

Цитата: Сообщение от maSter™ скрытие я так понимаю самому?!

Скритие не нужно....

Цитата: Сообщение от maSter™ разве не PointBlank.exe.exe

Нет, там все правильно написано...

[BLACK_DEAD]

maSter™, какое скрытие это тренер,, не нужно там все правильно написано

[Нагибаю*ВСЕХ]

Можете начинающему рассказать:"Этот код только для ЕСП?А с этим надо прописывать функции(т.е.то что отмеченно красным(есп)мне нужно переделать)?
Извиняюсь если где нафлудил
[Ссылки могут видеть только зарегистрированные пользователи. ]

[Skilful]

Цитата: Сообщение от крайслер this.

сразу видно, рефактор рулит

Почему у вас всегда активация/деактивация на разные кнопки?
можно же на 1 делать (вот один из примеров реализации ) :

static bool aktiv = true;

private void Button1_Click(object sender, EventArgt e)
{
if(aktiv == false)
{
Button1.Text = "Выключено";
//Тут функция деактивации
aktiv = true;
}
else
{
Button1.Text = "Включено";
//Тут функция активации
aktiv = false;
}
}

пишу в редакторе, так что мог где-то ошибиться

Добавлено через 13 часов 41 минуту
Кстати, в VAMemory есть ошибка в чтении байтов. Вроде вот такая, я уже не помню :

Цитата: Сообщение от крайслер Твой код public byte[] ReadByteArray(IntPtr pOffset, uint pSize) { if (this.processHandle == IntPtr.Zero) { this.CheckProcess(); } byte[] result; try { uint flNewProtect; VAMemory.VirtualProtectEx(this.processHandle, pOffset, (UIntPtr)pSize, 4u, out flNewProtect); byte[] array = new byte[pSize]; VAMemory.ReadProcessMemory(this.processHandle, pOffset, array, pSize, 0u); VAMemory.VirtualProtectEx(this.processHandle, pOffset, (UIntPtr)pSize, flNewProtect, out flNewProtect); result = array; } catch (Exception ex) { if (VAMemory.debugMode) { Console.WriteLine("Error: ReadByteArray" + ex.ToString()); } result = new byte[1]; } return result; }

а вот какой должен быть:

public byte[] ReadByteArray(IntPtr pOffset, uint pSize)
        {
            if (this.processHandle == IntPtr.Zero) this.CheckProcess();
            try
            {
                uint flNewProtect;
                VAMemory.VirtualProtectEx(this.processHandle, pOffset, (UIntPtr)pSize, 4u, out flNewProtect);
                byte[] array = new byte[(int)pSize];
                VAMemory.ReadProcessMemory(this.processHandle, pOffset, array, pSize, 0u);
                VAMemory.VirtualProtectEx(this.processHandle, pOffset, (UIntPtr)pSize, flNewProtect, out flNewProtect);
                return array;
            }
            catch (Exception ex) 
            { 
                if (VAMemory.debugMode) MessageBox.Show("Error: ReadByteArray" + ex.ToString());
                return null;
            }
            return null;
        }

вроде так

[крайслер]

Цитата: Сообщение от Mathers сразу видно, рефактор рулит

Не отрицаю, есть грешок....

Цитата: Сообщение от Mathers Почему у вас всегда активация/деактивация на разные кнопки? можно же на 1 делать (вот один из примеров реализации ) :

Тут Рука-Лицо...
Посмотри код внимательней.... Может и увидешь в нем реализацию....

[if{StrikeF}]

Цитата: Сообщение от *Nyan* А сейчас можно сделать Trainer? Если да, то я скоро выпущу свой трейнер

т.к. я уже неделю не заходил в пб и не проверял работоспособность трейнеров 100% сказать не могу,но до обновы тренеры пахали только на х32

[*Nyan*]

Цитата: Сообщение от if{StrikeF} т.к. я уже неделю не заходил в пб и не проверял работоспособность трейнеров 100% сказать не могу,но до обновы тренеры пахали только на х32

Ты ошибся, только на х64
Были слухи что все, теперь трейнеры не будут работать

[if{StrikeF}]

Цитата: Сообщение от *Nyan* Ты ошибся, только на х64 Были слухи что все, теперь трейнеры не будут работать

это ты ошибаешься до последней обновы пахали только на х32,а щас хз

[pro100ni]

if{StrikeF}, .... только х64

[Aunedetal]

Доброго времени суток, а можо ещё раз выложить пример кода?