Cheat Engine :: View topic - Best Language for bot creation?

Cheat Engine
The Official Site of Cheat Engine

FAQ

Memberlist

Usergroups

Profile

Best Language for bot creation?
Goto page Previous 1, 2, 3, 4, 5, 6

Cheat Engine Forum Index -> General programming

View previous topic :: View next topic

Author

Message

samuri25404
Grandmaster Cheater

Reputation: 7

Joined: 04 May 2007
Posts: 955
Location: Why do you care?

Posted: Sat Sep 15, 2007 10:09 am Post subject:

blankrider wrote:

they can

how can you say c++ isn't a botting language?

what bots aren't written in c++ | asm

(the nooby ones dont count)

I don't really like to participate in arguments such as these, but I just had to step in at this.

I can make a damned good bot in C#, and it'll be incredibly easy to read--anyone who's done a small bit of C# will be able to understand it with a few comments here and there. I've never done Java, but I assume it's similar because I've read that C# and Java are at least somewhat similar.

I've tried countless times to learn C++, all with no avail--I couldn't write a simple Hello World program in it. Why? There are too many compilers, too many different ways to do it; for example:

Code:

cout << "Hello world"

cout<stfdax> << "Hello World" //or something like that

and probably others that I can't realy think of atm.

There is one standard compiler for C# (Visual Studio), and I assume it's quite similar in Java.

For C#, hello world would be

Code:

Console.WriteLine("Hello world!");

(not including the auto-generated stuff)

A small bot might be:

Code:

ProcessMemoryReaderLib.ProcessMemoryReader preader = new ProcessMemoryReaderLib.ProcessMemoryReader();

public void setup()
{
preader.ReadProcess = Attatcher.myprocs[0];
preader.OpenProcess();

}

private void NoFloor_Click(object sender, EventArgs e)
{
setup();
int byteswritten;

byte[] memory ={ 0xC0 };
preader.WriteProcessMemory((IntPtr)0x0040AEBD, memory, out byteswritten);
}

private void JumpAir_Click(object sender, EventArgs e)
{
setup();
int byteswritten;

byte[] memory ={ 0xD7 }; //the byte for changing the opcode
preader.WriteProcessMemory((IntPtr)0x0040AECA, memory, out byteswritten);
preader.WriteProcessMemory((IntPtr)0x0040AF01, memory, out byteswritten);
}

Code:

//a class I got from gamesguru--no editing required
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace ProcessMemoryReaderLib
{
/// <summary>
/// ProcessMemoryReader is a class that enables direct reading a process memory
/// </summary>
class ProcessMemoryReaderApi
{
// constants information can be found in <winnt.h>
[Flags]
public enum ProcessAccessType
{
PROCESS_TERMINATE = (0x0001),
PROCESS_CREATE_THREAD = (0x0002),
PROCESS_SET_SESSIONID = (0x0004),
PROCESS_VM_OPERATION = (0x0008),
PROCESS_VM_READ = (0x0010),
PROCESS_VM_WRITE = (0x0020),
PROCESS_DUP_HANDLE = (0x0040),
PROCESS_CREATE_PROCESS = (0x0080),
PROCESS_SET_QUOTA = (0x0100),
PROCESS_SET_INFORMATION = (0x0200),
PROCESS_QUERY_INFORMATION = (0x0400)
}

// function declarations are found in the MSDN and in <winbase.h>

//    HANDLE OpenProcess(
//       DWORD dwDesiredAccess, // access flag
//       BOOL bInheritHandle, // handle inheritance option
//       DWORD dwProcessId // process identifier
//       );
[DllImport("kernel32.dll")]
public static extern IntPtr OpenProcess(UInt32 dwDesiredAccess, Int32 bInheritHandle, UInt32 dwProcessId);

//    BOOL CloseHandle(
//       HANDLE hObject // handle to object
//       );
[DllImport("kernel32.dll")]
public static extern Int32 CloseHandle(IntPtr hObject);

//    BOOL ReadProcessMemory(
//       HANDLE hProcess, // handle to the process
//       LPCVOID lpBaseAddress, // base of memory area
//       LPVOID lpBuffer, // data buffer
//       SIZE_T nSize, // number of bytes to read
//       SIZE_T * lpNumberOfBytesRead // number of bytes read
//       );
[DllImport("kernel32.dll")]
public static extern Int32 ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesRead);

//    BOOL WriteProcessMemory(
//       HANDLE hProcess, // handle to process
//       LPVOID lpBaseAddress, // base of memory area
//       LPCVOID lpBuffer, // data buffer
//       SIZE_T nSize, // count of bytes to write
//       SIZE_T * lpNumberOfBytesWritten // count of bytes written
//       );
[DllImport("kernel32.dll")]
public static extern Int32 WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesWritten);

}

public class ProcessMemoryReader
{

public ProcessMemoryReader()
{
}

/// <summary>
/// Process from which to read
/// </summary>
public Process ReadProcess
{
get
{
return m_ReadProcess;
}
set
{
m_ReadProcess = value;
}
}

private Process m_ReadProcess = null;

private IntPtr m_hProcess = IntPtr.Zero;

public void OpenProcess()
{
//       m_hProcess = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 1, (uint)m_ReadProcess.Id);
ProcessMemoryReaderApi.ProcessAccessType access;
access = ProcessMemoryReaderApi.ProcessAccessType.PROCESS_VM_READ
| ProcessMemoryReaderApi.ProcessAccessType.PROCESS_VM_WRITE
| ProcessMemoryReaderApi.ProcessAccessType.PROCESS_VM_OPERATION;
m_hProcess = ProcessMemoryReaderApi.OpenProcess((uint)access, 1, (uint)m_ReadProcess.Id);
}

public void CloseHandle()
{
int iRetValue;
iRetValue = ProcessMemoryReaderApi.CloseHandle(m_hProcess);
if (iRetValue == 0)
throw new Exception("CloseHandle failed");
}

public byte[] ReadProcessMemory(IntPtr MemoryAddress, uint bytesToRead, out int bytesRead)
{
byte[] buffer = new byte[bytesToRead];

IntPtr ptrBytesRead;
ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, MemoryAddress, buffer, bytesToRead, out ptrBytesRead);

bytesRead = ptrBytesRead.ToInt32();

return buffer;
}

public void WriteProcessMemory(IntPtr MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
{
IntPtr ptrBytesWritten;
ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, MemoryAddress, bytesToWrite, (uint)bytesToWrite.Length, out ptrBytesWritten);

bytesWritten = ptrBytesWritten.ToInt32();
}
}
}

Yes, it is large for a program, yes, it is a little hard to understand, and yes it uses API calls from a C++ DLL, but so what? It's pretty damned easy to read, and this is some of the most complicated stuff you can do in C#; most people don't even do this, making things that most people do pretty easy to read.

Display posts from previous:

	Cheat Engine Forum Index -> General programming	All times are GMT - 6 Hours Goto page Previous 1, 2, 3, 4, 5, 6
Page 6 of 6

Jump to:

You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
You cannot attach files in this forum
You can download files in this forum