Stop Buying Cheats! Make Your Own in 10 Minutes transcript

Are you someone who pays $50 every month for cheats? Well, it's time to stop being a customer and start being a developer. In this video, we're going to learn exactly how to create our own ESP hack for any game. I'll break down all the logic in very easy language, even if you have absolutely zero coding or software engineering knowledge. By the end of this video, you will be able to make this. But why should you actually make the cheat yourself instead of buying?

Simple, because understanding and making cheats yourself saves you from two major things: getting scammed and getting banned. Think about it. Every time you buy a cheat online, you're taking a massive risk. You're downloading files from random strangers, praying they don't steal your data, and hoping the developer actually updates it. And the moment the game updates, boom, you're hit with an instant ban wave because you're using the exact same public software as thousands of other players.

But when you build it yourself, you're the one in control. You know exactly how it works, you know it's safe, and because the code is entirely yours, it stays completely hidden from the anti-cheat. Even if it does get detected, you can just fix it yourself. And one more thing, making cheats yourself is almost 100% free. Once you learn how to do this, you never have to pay anyone for a cheat ever again. All right, let's jump right into the tutorial.

First, we need to set up our environment. Head over to Google, search for Visual Studio, and download the Visual Studio Installer. Once that's downloaded and open, go over to the available tab and click on install. Now, you'll see a bunch of different options, but don't let them confuse you. We only need two things here. Make sure to select .NET desktop development and desktop development with C++, which is our Windows C++ application development kit.

Check both of those boxes, click install at the bottom right, and let it download. This is going to give us all the exact tools and compilers we need to write and run our code. Once Visual Studio is fully installed, launch it. Click on create a new project, look for the Windows desktop application template using C++. Select it, click next, and give your project any name you want. Let's call it anything just for the tutorial.

Hit create. Now, don't get intimidated by the empty screen. We just need to link a few important tools to our project so it can talk to the game properly. Look over to the right side of your screen at the Solution Explorer tab. Right click on your project name and click on properties. Inside the properties window, navigate to linker, then click on input. Look for additional dependencies, click edit, and paste the lines of code that I've pinned over on our Telegram channel.

Once that's done, click okay, hit apply, and click okay again. Next, you're going to grab the source zip file from that same Telegram post. Inside, you'll find the foundation code we need. Open up the cs2esphack.cpp file from the zip, copy everything inside it, and paste it right into your main C++ file in Visual Studio, replacing whatever was there. But, we aren't done yet. Our cheat needs to know where things are inside the game's memory, and it needs a way to read that memory.

So, right click your project name again, go to add, then select new item. Create a header file, name it offsets.hpp, and paste the contents from the zip file's offset header. Repeat this exact same process to create a second file called memory manager.h, and paste the memory management code into it. Finally, do it one last time for a file named shader.hlsl. This is what handles the graphics and draws the actual boxes on your screen.

Once the shader file is added, right click it, go to its properties, and under item type, change it to does not participate in build. Hit apply and close it, and we are all set. Now, before we look at the lines of code we just pasted, you first need to understand how a game actually works behind the scenes. Everything you see in a game, your player, the enemies, your teammates, is stored in your computer's RAM or memory.

Every single player, whether it's your local player that you control, your enemies, or your teammates, has a set of data attached to them. Things like their health, their team ID, and their exact position are all stored in the RAM for every single player. In technical terms, these players are called entities. Now, the game also maintains a master list that contains every single player in your current match. This is called the entity list, and it tracks everyone, you, your teammates, and your enemies.

But, here's the interesting part. Your computer or phone screen is completely 2D, while the game world is 3D. The game has to create an illusion of being 3D on your flat 2D screen to give you that immersive feeling. To do this, all 3D games use a technique called world to screen. World to screen basically uses complex math to convert those 3D game world coordinates into 2D coordinates that match your phone or PC screen.

In order to pull off this math, the game relies on something called a view matrix. So, when we build an ESP hack, our our job is simple. We have to pull all of this game information out of the RAM, convert the 3D positions of the enemies into 2D positions by creating our own world to screen logic, and then simply draw that information directly onto our screens. But, how do we actually pull that information out of the game's memory in the first place?

It comes down to three main steps. Step one, attach to the game's process. This is like asking our operating system for permission to access another app's memory. Every modern operating system restricts you from accessing another app's memory directly due to security and hacking risks. So, our code has to establish this connection first. Step two, find the module base address. Think of the game's memory like a massive city.

The module base address is the front gate or the starting point of the game specific neighborhood inside your RAM. Step three, use offsets. Once we are at the starting point, we use things called offsets. Offsets are like specific street addresses or GPS coordinates. They tell our code the exact location of the specific information we want to pull, like the exact spot where the entity list or the player's health is hidden.

Now that you understand the exact blueprint of how our cheat reads the game, let's jump back into Visual Studio and look at how our code puts this logic into action. In Visual Studio, scroll through the code until you find the W Win Main function. This function is the absolute starting point of our cheat. This means whenever we run our program, the computer will start executing the code in order right from this exact spot.

Inside this function, you'll spot this specific line, mem. attach to process with Counter-Strike 2's process name inside the brackets. What this line of code does is exactly what we discussed earlier. It asks the operating system to allow us to access the game's memory. If you want to make an ESP for any other game in the future, you just need to change the name inside those brackets to match that specific game. Right below this code, you can see the line, mem.get module base.

Just like the previous line, you will also need to change this to match your game in the future. For Counter-Strike 2, we need the client.dll base address. So, that is exactly what we have put inside the brackets here. Most of the codes written here are for drawing the ESP overlay using the DirectX 11 graphics API, which you currently don't need to understand as a beginner. You can completely ignore all those other codes and scroll up until you find the void render function.

Right here is where all of our actual ESP codes are written. First, we are getting the screen width and height, which our program needs for the world-to-screen logic. The codes directly below it get the view matrix and the entity list that we talked about earlier. We also read the local player controller, which we will talk about later. And if you remember, I told you about offsets earlier, here in the code, you can see text written like offsets double colon W entity list and offsets double colon DW view matrix.

They are written exactly like this, so our cheat knows the precise location to find that information. Now, offsets are completely different for every single game, and they also change with every game update. This means if your game gets updated, you need to find the new offsets again, or your cheat will completely stop working. I will tell you exactly how to find them in just a minute. Inside our offsets.hpp file, we have already declared the correct offsets for the current version of Counter-Strike 2.

If you want to make an ESP for any other game, you will need to find and change the offsets to match that specific game. In the next piece of code, we are traversing through the entity list that we talked about. Loops through every player and reads each player's health, team ID, and their 3D positions. We also need the local player offset, which represents our own player, to get our own team ID. The code then compares our team ID against the enemy's team ID.

This allows the cheat to completely skip our teammates and draw boxes over enemies only. Finally, the code takes that data, performs a world to screen math, and uses it to draw the box, the health bar, and snap lines onto your screen based on the real-time data we just pulled from the RAM. Now, let's look at exactly To find them, go back to that same Telegram post and click on the GitHub link provided there. Once you are on the GitHub page, go into the folder named output.

All the offsets you will ever need can be found right inside these files. For player information, look inside client_dll.hpp. You can just copy the specific offset name from our project's offsets.hpp file, and search for it inside this GitHub file to get the updated number. For global offsets like the entity list and the view matrix, you just need to navigate to the other file on the GitHub page named offsets.hpp. By checking this repository whenever the game updates, you can quickly grab the newest numbers, paste them into your project, and your cheat will be fully updated and working again in seconds.

Once you're done updating the offsets, look at the top of Visual Studio and click on the play icon to compile and start your first ever cheat. Make sure your game is already running in the background before you start it. If you have followed all the steps correctly and updated the offsets to match the current version of the game, the cheat will successfully pop up and start running over your game just like this. You can press the escape key on your keyboard anytime you want to safely close the cheat and stop it from running.

And that is absolutely it for today's video, guys. You have just built your very own fully functional ESP hack from scratch. If you found this tutorial helpful and want to learn more about the engineering behind game modding, make sure to smash that like button and subscribe. Don't forget to join our Telegram channel using the link in the description below to get access to all the source files, scripts, and our growing developer community.

See you in the next one.