Originally Posted by
jackkersey
It's at every angle. I've figured out that the further the enemy is from you, the more box drift there is (whichever direction that drift may be). The angle and pronouncedness of the drift seems to be determined by your native resolution.
At 1680x1050 (desktop resolution), the boxes are all much higher and to the left of everyone.
If I switch to 1280x800 native resolution on my desktop, the boxes are all fine, except opponents that are far away the box will be just above them.
In both cases I'm still using the standard Windowed (no border) mode in MW3. So no MW3 settings were changed between those testcases.
Worth noting that I'm using a monitor with a 16:10 aspect ratio which is kind of a rarity on the market.
I started learning to program a few months ago and just started learning about algorithms and data structures, is there any way you'd release the source code for this? Or email it to me? How long does a project like this take? How much of the weight is lifted for you by libraries? Is MW3's ephemeral data encrypted at all, how do you know which pieces are what?
If you want the source code I can email it to you, no problem (Its written in C#)
I don't have a 16:10 monitor, so I can't test if that's what's causing the issue. But it seems like that's where the problem lies.
As for libraries the only library I used was a DirectX library for C# (I used Managed DirectX, which is kind of outdated, should have used SharpDX. But it works).
The ESP I created here is actually not so difficult to make (That is, if you are somewhat experienced) once you understand how data structures are laid out in memory and a bunch of other things like how to draw graphics with DirectX.
You read data structures (structs) from memory, then use the information to draw the ESP.
It kind of looks like this to give you an idea (Code is in C#):
Code:
[StructLayout(LayoutKind.Sequential)] // This means that the elements in the struct are layed out in memory in a sequential manner
public struct Cg
{
public int FrameTime; // Here we have a useful variable, it takes 4 bytes of memory (since sizeof(int) == 4)
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0xC)]
private byte[] Skip000; // Here is a useless section of memory, so we skip it by hex C bytes. (hex C == decimal 12)
public int IsInGame; // Here is another useful variable, it also takes 4 bytes of memory.
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x13C)]
private byte[] Skip001; // This again is unessesary, so we just skip it by 13C bytes.
public int ClientNumber; // Another piece of useful data. (4 bytes)
}
In C++ it's even easier as the language is so low level that you can just create a normal structure and read the memory from the other process into the structure (Or make a pointer to the structure).
Code:
typedef struct
{
int iFrameTime; // 4 bytes
char skip000[0xC]; // 12 bytes, sizeof(char) == 1 byte in C++
int iIsInGame; // 4 bytes
char skip001[0x13C]; // 316 bytes (0x13C == 316)
int iClientNum; // 4 bytes
} Cg;
// To get size of the data structure just add the size of all the variables inside the data structure.
If the cheat is DLL injected all you need to do in C++ is this:
Code:
#define ADDRESS_CG 0x9DC3A0
Cg* pCg = (Cg*)ADDRESS_CG;
// Now pCg points to the section of memory where the structure is located.
If it isn't DLL injected like this one you use RPM to read the data from the game process.
This particular ESP took me about a week (I think) to code (then I made numerous small changes over the span of a month).
It's also the first cheat I've ever made so I'm fairly new to this.