YT YouTube2Text

YouTube2Text → Transcripts → The SIMPLEST Way To Make Your OWN CHEATS For Any GAME

The SIMPLEST Way To Make Your OWN CHEATS For Any GAME — Transcript

by BranchLink · 6,909 words · 965 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00So, you want to become a game hacker and
0:02make cheats for any game you want. But
0:03every tutorial on the internet just
0:05confuses you. And if you ask expert game
0:07hackers on forums or Discord servers,
0:09they tell you to go learn programming
0:10for a few years first. That's really
0:12demotivating when you're a beginner. But
0:14don't worry because Branch Link is here.
0:16In this video, I'm going to teach you
0:17the simplest way to start making your
0:19own cheats. This video is fully
0:21practical. By the end of it, you'll be
0:22able to make this ESP hack yourself for
0:24any game that you want. And the best
0:26part, I guarantee that after this video,
0:28you'll understand how every cheat in the
0:30world actually works. You don't need any
0:32programming experience at all. Even if
0:33you've never written a single line of
0:35code, you'll still understand
0:36everything. Just pay close attention.
0:38Before we begin, here's a quick
0:39disclaimer. This video is made strictly
0:41for education, security, and anti-che
0:44research. Its purpose is to teach you
0:46the science behind video game cheats,
0:48not to promote, sell, or distribute any
0:51free or paid cheats. Please be ethical
0:53and take responsibility for your
0:54actions. All right, let's begin. But
0:56first, there are two very important
0:58things you need to understand. First,
1:00don't just watch this video, do it
1:01yourself. Whatever I do in this video,
1:03you need to do it, too. If you just
1:04watch, think, "Okay, I get it." and
1:06leave, you'll learn nothing. It's like
1:08watching a Fortnite gameplay video on
1:09YouTube and thinking you'll
1:10automatically become good at Fortnite.
1:12That's not how it works. You don't get
1:14good at anything in life without
1:15practice. So, don't just watch. Follow
1:17along. Second, these concepts apply to
1:19every game. What I'm teaching you
1:21applies to every game out there,
1:22including the most popular battle royale
1:24and tactical shooter games. So, focus on
1:26understanding the concepts, not just
1:28copying the steps. At the end of this
1:30video, I'll also explain how you can
1:32apply these concepts to any other game
1:34you want, and what you will exactly need
1:35to do in order to do that. Let's start
1:38with the part most people struggle with,
1:40programming. A lot of you don't really
1:41understand what a programming language
1:43is or why we need to write code to make
1:45cheats. So, let me explain it simply.
1:47Imagine you have a robot at home that
1:48follows every order you give it. You
1:50tell it to go to the supermarket and
1:52bring groceries, clean your toilet, or
1:54wash your clothes, and it does exactly
1:56what you said. Nothing more, nothing
1:58less. A computer is just like that
2:00robot. You give it orders and it follows
2:02them. The difference is that a computer
2:03doesn't have arms and legs, so it can't
2:05go shopping or clean your house, but it
2:07can do other things. Open YouTube, open
2:09Discord, play a movie, run a game, or
2:12send a message to your friend. Think
2:13about how you got to this video. You
2:15ordered your computer to open your
2:16browser. Then you typed YouTube.com,
2:18clicked on this video, and your computer
2:20started playing it. Every one of those
2:21steps was an order. So far, you've been
2:23giving orders using your mouse and
2:25keyboard. But there's another way to
2:27give orders to a computer, and that's a
2:28programming language. You can talk to
2:30your robot in English or Spanish, but a
2:32computer doesn't understand English or
2:33Spanish. It only understands programming
2:35languages. That's why we call them the
2:37language of computers. Every app, game,
2:39and website you use was made with a
2:41programming language by software
2:43engineers. You've probably heard of
2:44them. Their job is to use programming
2:46languages to build apps and games like
2:49Discord, YouTube, and Fortnite. So, how
2:51do they actually build a game? They give
2:52the computer very exact orders. Let's
2:55say they're making a battle royale game
2:56using code. They tell the computer,
2:58"Show 100 players on an island map.
3:00Create a battle bus that flies over the
3:01island, and when a player presses space,
3:04drop them onto the map. Add weapons and
3:06vehicles that players can pick up and
3:07use. When a player presses space, make
3:09them jump. When they press shift, make
3:11them run." So, a video game or any app
3:14is just an illusion your computer
3:15creates by following the exact order
3:17software engineers gave it. That's how
3:19all software and games are made. And
3:20that's what programming languages are
3:22for, telling the computer exactly what
3:24to do. So, why do we need programming to
3:26make cheats? For the exact same reason.
3:29A cheat is also just an app like
3:30Discord, Telegram, or YouTube. The only
3:33difference is its purpose. Showing
3:34players through walls, helping you aim
3:36with an aimbot, or giving you god mode,
3:38infinite health, or infinite ammo. We
3:40use a programming language to tell the
3:42computer to do exactly that. Uh let's
3:44take an ESP, also called a wall hack, as
3:46an example. An ESP lets you see players
3:49through walls. To make one, we only need
3:51to tell the computer two things. One,
3:53find the location of the enemy players
3:54in the game. Two, draw boxes and lines
3:57on top of them. That's it. That's all
3:58our code needs to do. Now, there are
4:00hundreds of programming languages just
4:02like there are thousands of human
4:03languages like English, French, and
4:06Spanish. Some popular ones are Java, C,
4:09C++, Python, and Rust. But for making
4:12cheats, the industry standard is C++.
4:15So, here's exactly what we need to do to
4:16make our ESP in the simplest way
4:18possible. Use C++ to tell the computer
4:21to keep finding the location of every
4:23player in the match and draw boxes and
4:25lines on top of them. And don't worry if
4:27you don't know C++ at all. I'm not going
4:29to tell you to go learn C++ for 3 years
4:31first like other people do. I'll show
4:33you the simplest way around it. So relax
4:35and just follow along. Now let's talk
4:38about the bigger problem. Why beginners
4:40struggle to learn programming on their
4:41own. The reasons are actually quite
4:43interesting. The first reason is that
4:44programming sounds confusing. The second
4:46is that it feels boring and takes a long
4:48time to learn. And today social media
4:50has damaged our attention span so badly
4:53that even getting out of bed feels like
4:54too much work. Our brains are trained to
4:56expect fast results. So when something
4:58takes time, we give up. That's exactly
5:01the problem this video solves. The
5:02simplest way is not to learn programming
5:04separately. It's to learn it while
5:06making cheats. That way, you hit two
5:07targets with one shot. And this is
5:09exactly how I learned. I didn't get a
5:10computer science degree just to make
5:12cheats. And I didn't watch programming
5:14tutorials on YouTube for 3 years
5:15straight. Now, you might be thinking,
5:16"How can I make cheats without knowing
5:18programming?" Here's how. Unlike other
5:19tutorials, we won't write the code word
5:21by word. Instead, we'll paste code that
5:23I've already written for you and then
5:25understand what each line does. Trust
5:26me, this is the best way for beginners
5:28to learn. It's how I learned eight years
5:30ago when I was a beginner. And today I
5:31can make cheats for pretty much any
5:33game. But we're not going to paste code
5:34blindly. I'll explain what each part
5:36does in the simplest way possible. This
5:38way you'll see how lines of code come
5:40together to form a fully working cheat.
5:42Because learning programming isn't about
5:43memorizing every line of code. It's
5:45about learning how to make the computer
5:46do the job you want. In programming,
5:48this is called logic building. For us,
5:50that means figuring out which code finds
5:52the location of our enemies and which
5:54code makes the computer draw boxes and
5:56lines over them. If anything is still
5:58confusing, rewatch this part until it
6:00makes sense, or drop a comment telling
6:02me exactly what confused you. I read and
6:04reply to almost every comment. All
6:06right, now let's jump into our computer
6:08screen. The first thing we need to do is
6:10install Visual Studio. Visual Studio is
6:12the software we'll use to write our code
6:13and build our cheats. Simply search on
6:15Google for download Visual Studio and
6:18download the installer. Make sure you
6:20don't accidentally download Visual
6:21Studio Code. That's a completely
6:23different program with a similar name,
6:25so be careful. Once it's downloaded,
6:27open the Visual Studio installer. Go to
6:30the available tab and click install on
6:32Visual Studio Community 2026. Now, it'll
6:34ask you which components you want. Here,
6:36you need to select desktop development
6:37with C++ and then click install. This
6:40will take some time to download, so let
6:42it run in the background. While that's
6:43downloading, go to my Telegram channel
6:45or my Discord server. The links are in
6:47the description. There you'll find a zip
6:49file called beginner_resources.zip.
6:52Download it from there and extract it.
6:54Inside, you'll find two folders. Open
6:56the source code folder and doubleclick
6:58the slnx file. This will open the
7:00project inside Visual Studio. Once it's
7:03open, look at the solution explorer.
7:05Expand the little arrow and open the
7:07main CPP file. This is the file where
7:10we're going to write everything. Now,
7:11there's one last thing to do before the
7:13code will build. Click on the project
7:15name, rightclick, and go to properties.
7:17In that window, go to the C/ C++ tab,
7:20then general, and select additional
7:22include directories. Click on the edit
7:24option. Here you'll see two lines.
7:25Select the first one and click on the
7:27three dots. Now go to where you
7:28extracted the zip file. Open the source
7:31code folder, then the MUI folder and
7:33select the backends folder inside it.
7:35For the second line, do the same thing,
7:37but this time select the MUI folder
7:39itself, not backends. Then click okay
7:41and apply. And our setup is done.
7:55Now look at your screen. You can see
7:56some code here. And I already know
7:58what's going through your mind right
7:59now. This looks complicated. I don't
8:01understand anything. This is not for me.
8:02Relax. Take a breath. You do not need to
8:04understand this code by looking at it.
8:06Nobody does. Not even me when I started
8:088 years ago. You only need to understand
8:09two words. And after that, this whole
8:11thing will look boring and simple to
8:13you. I'm serious. Just give me the next
8:14two minutes. The first word is variable.
8:17A variable is just a box where your
8:19computer stores something and you give
8:20that box a name so you can use it later.
8:22Think about your phone contacts. You
8:24don't remember your friend's phone
8:25number. You saved it with the name Jake.
8:26And whenever you want to call him, you
8:28just tap the name and your phone already
8:30knows the number. The name is what you
8:32use. The number is what's stored inside.
8:33A variable is exactly that. Put a value
8:35inside a box, give the box a name, and
8:37from then on just use the name. The
8:40second word is function. Let's go back
8:42to our robot again because this one is
8:43important. Say you want your robot to
8:45make you a cup of tea. Remember what I
8:46told you earlier. The computer does
8:48nothing extra. It only does exactly what
8:50you order. So you can't just say tea.
8:52You'd have to say go to the kitchen,
8:54take a pot, fill it with water, put it
8:55on the stove, turn on the stove, add tea
8:58leaves, add milk, add sugar, wait 5
9:00minutes, turn off the stove, pour it
9:01into a cup, bring it to me. That's 12
9:03orders for one cup of tea. Now tomorrow
9:04morning, you want tea again. You have to
9:06say all 12 again. Evening comes, your
9:08friend visits. tea again, all 12 again,
9:10every single time. And if one day you
9:12forget the turn off the stove step, your
9:14robot will just keep boiling it forever
9:16because it only does what you said. So
9:18this is clearly stupid, right? There has
9:20to be a better way. And here's the
9:21better way. You tell the robot all 12
9:23steps one time. And then you tell it
9:25from now on, all of this together is
9:27called make tea. That's it. Now, you
9:29never say those 12 steps again. You just
9:31say make tea. And the robot already
9:34knows the whole thing and does it from
9:36start to finish. That is what a function
9:38is. A bunch of orders grouped together
9:40and given one name so you can use them
9:42again and again just by saying that
9:44name. And that's not just a trick to
9:45save time. This is literally how every
9:48app and every game on your computer is
9:49built. Nobody writes millions of orders
9:51one by one. They group them into jobs,
9:53give them names, and then just call
9:55those names. Fortnite doesn't rewrite
9:57how a bullet flies every time you shoot.
9:59Somebody wrote that job once, gave it a
10:01name, and now the game calls it every
10:03time you press the mouse button. Now,
10:05one more thing about our robot.
10:07Sometimes the job needs a small detail
10:09from you. Maybe today you want two cups
10:11instead of one or no sugar. So when you
10:13give the order, you also pass those
10:14details along. Make tea, two cups, no
10:17sugar. In code, those details go inside
10:20the brackets. So whenever you see
10:21brackets after a name, that name is a
10:23job. And whatever is inside the brackets
10:25is the information the job needs to do
10:26its work. That's it. That's the scary
10:28part done. Now let's read our code.
10:30First, how your computer sees your
10:31screen. Before we read the code, you
10:33need to know one simple thing. how you
10:35tell the computer where to draw the
10:36line. Every point on your screen has two
10:38numbers, an X and a Y. X is how far it
10:40is from the left side of your screen. Y
10:42is how far it is from the top of your
10:44screen. Both are counted in pixels. A
10:46pixel is just one tiny dot on your
10:48screen. My screen is 1,920 pixels wide
10:51and 1,080 pixels tall and yours is
10:53probably the same. So x=0 is the far
10:56left and x= 1,920 is the far right. Yals
10:590 is the very top and y= 1080 is the
11:02very bottom. The only thing you need to
11:04be careful about is the Y. Since it's
11:06counted from the top, a bigger Y means
11:08lower on the screen, not higher.
11:10Remember that one line and you're done.
11:11And if I want the middle of my screen
11:13from left to right, I take 1,920
11:17and divide it by two, which gives me
11:19960. That's exactly why you'll see 960
11:23in our code in a second. Now, look at
11:24these two lines. These are our two
11:27variables, our two boxes. The word
11:29vector 2 tells the computer what kind of
11:31thing goes in the box. A vector 2 just
11:34holds two numbers together, an X and a
11:36Y. In other words, it holds one point on
11:38your screen. That's all it is. Then
11:40comes the name we chose. I named the
11:42first box line underscore start position
11:45and the second one enemy position. The
11:47computer doesn't care what you name
11:48them. You could call them ABC and XYZ,
11:51and it would work exactly the same. We
11:53use clear names only so that we can
11:55understand our own code later. And
11:56inside the brackets are the two numbers
11:58we're putting in the box. So the first
12:00box holds x= 960 and y equals 0. That's
12:04960 pixels from the left, which is the
12:07middle, and 0 from the top, which is the
12:09very top. So it's the top center of my
12:11screen. And the second box holds x=
12:141,000 and y= 500, which is a bit to the
12:17right and about halfway down. Right now,
12:19I'm typing these numbers myself. Later
12:21in this video, we won't type the enemy
12:22position at all. We'll take it from the
12:25game's memory from a real enemy running
12:27around in the match. But this drawing
12:28part will stay exactly the same. That's
12:31why I want you to understand it
12:32properly. Now, now the line itself, draw
12:34a line is a function exactly like make
12:36t. Somebody had to write all the small
12:38orders for drawing a line on your
12:40screen. And I already did that for you
12:41inside that overlay.h file in the
12:43project and gave the whole thing the
12:45name draw line. So you never have to
12:47look inside it. You just say the name
12:49and it happens. And inside the brackets
12:51are the four details this job needs.
12:53One, where the line should start. Two,
12:55where the line should end. three. What
12:57color it should be for, how thick it
12:59should be. Read it like a normal
13:01sentence. Draw a line. Start from here.
13:03End over there. Make it green. Make it
13:05five pixels thick. That's all this line
13:07is saying. And notice one thing inside
13:09the brackets. I didn't write the numbers
13:11again. I wrote the names of our two
13:12boxes. And the computer goes and takes
13:14the numbers out of them by itself, just
13:16like tapping Jake's name instead of
13:18typing his number. Now, let's actually
13:19run it. At the top of Visual Studio,
13:21you'll see a green play button that says
13:23local Windows debugger. That button
13:25builds your code and runs your program.
13:27Let's click it. Give it a second. And
13:29there it is. As you can see, our program
13:31is now drawing a big green line right on
13:33your screen. That line is not inside any
13:35window. It's sitting on top of
13:37everything, which is exactly what an
13:38overlay is, and that's what we'll later
13:40draw on top of the game. You just ran
13:42your first cheat code. Take a moment and
13:44enjoy that cuz most people never get
13:46past this point. By the way, your
13:47program is still running in the
13:48background. Press the end key to close
13:50the overlay whenever you want. Now,
13:52let's play with it because this is how
13:54you actually learn. Let's move the
13:55starting point. I'll change 960 to 100.
13:58Look at that. The line now starts near
14:00the top left corner because 100 means
14:02only 100 pixels from the left. The end
14:05point didn't move at all because we
14:06didn't touch that box. Now, let's move
14:08the enemy. I'll change the enemy
14:09position to x= 600 and y= 1,000. See how
14:13the line now goes all the way down to
14:14the bottom of my screen? That's because
14:161,00 is almost 10,080, which is the very
14:19bottom. This is that Y thing I told you
14:21about. A bigger Y takes you down, not
14:24up. Now, pause the video and try this
14:26yourself. Change these numbers, run it,
14:28and see where the line goes. Do it four
14:29or five times until you can guess where
14:31the line will land before you even press
14:33play. Once you can do that, you've
14:35understood screen coordinates, and that
14:37is most of the work behind every ESP
14:39cheat in the world. Now, the last two
14:40details, the third detail is the color.
14:43Right now, it's green, so let me change
14:44it to red. And the fourth one is the
14:46thickness in pixels. Let me put
14:48something crazy like 50 so you can
14:50clearly see what it does. That's a huge
14:52line, right? That's 50 pixels thick. Let
14:54me bring it back to something normal
14:55like four. So now you know every single
14:58part of this code, where the line
14:59starts, where it ends, what color it is,
15:02and how thick it is. And more
15:03importantly, you now know what a
15:04variable is, and what a function is,
15:06which is honestly most of what beginners
15:08are scared of. And here's what I really
15:10want you to realize. What we just made
15:12is basically a snapline. One of the most
15:14common cheat features in the world. In a
15:17real game, the line starts from your
15:19screen and ends on the enemy, pointing
15:21at them like an arrow, even through
15:23walls. The only thing we're still faking
15:25is the enemy position. We type those
15:27numbers ourselves. So, the real question
15:29is this. How do we get the actual
15:31position of a real enemy from the game?
15:33That's exactly what we're doing next.
15:36All right. So, right now, we are typing
15:38the enemy's position ourselves. But
15:40think about this for a second. In a real
15:41game, the enemy is not standing still.
15:43He's running, jumping, taking cover,
15:46moving every single second. So, am I
15:48supposed to type his new position,
15:49rebuild the program, and run it again 60
15:52times per second? Obviously, not. That's
15:54impossible. So, we need our program to
15:56ask the game itself, where is the enemy
15:57right now? And we need it to ask that
15:59again and again every frame
16:01automatically. That's what makes a cheat
16:03actually work. Now, to ask that
16:05question, we need to know where the game
16:06keeps that information. And that's
16:08exactly what an offset is. So, what is
16:09an offset? When you run a game,
16:11everything in it is stored somewhere in
16:13your computer's memory. Your health,
16:14your ammo, your position, the enemy's
16:16position, all of it is just numbers
16:19sitting in memory. Now, think of your
16:20game's memory like a huge apartment
16:22building. Every single value lives in
16:24its own flat, and every flat has a
16:25number. The enemy's position is in one
16:27of those flats. Your health is in
16:28another one. An offset is basically that
16:31flat number. It tells our program
16:33exactly which flat to go to in order to
16:34find the value we want. So, if I know
16:36the offset of the enemy's position, my
16:38program can go straight to that flat,
16:40read the number that's inside, and get
16:42the enemy's live position while the game
16:44is running. No typing, no rebuilding.
16:46The game tells us, and it keeps telling
16:49us every single frame. That's all an
16:51offset is just an address that says the
16:54thing you're looking for is here. Okay,
16:55so how do we get these offsets? There
16:57are two ways. The first way is reverse
17:00engineering. This means you go into the
17:01game yourself, dig through its memory,
17:03and find these addresses manually with
17:05your own hands. Now, I'll be honest with
17:07you, this takes experience, and it takes
17:09time. It's not something you learn in
17:11one video, but this is the real skill.
17:13If you master reverse engineering, you
17:15don't depend on anyone. You can find
17:16offsets for any game, even a game nobody
17:18has ever touched before. I'll cover this
17:20properly in a future video. The second
17:22way is using a dumper, and that's what
17:24we're using today. A dumper is just a
17:26small program that someone has already
17:28written for a specific game. You run it,
17:30it looks inside that game's memory,
17:32finds all the important addresses, and
17:34writes them out for you in a file.
17:36That's it. As somebody already did the
17:37reverse engineering, and the dumper just
17:39hands you the result. So, the dumper
17:42isn't magic, and it's not a shortcut
17:43around understanding. It's just a tool
17:46that saves you the hard part while
17:47you're still learning. Let's use it. In
17:49this video, we're using CS2 dumper. It's
17:51a public open- source dumper made for
17:54CS2 and it's linked to the GitHub repo
17:56is included below the resources zip I
17:58gave you earlier. Now, one important
18:00thing first. The game must be running
18:02before you run the dumper because
18:03remember the dumper looks inside the
18:05game's memory. And if the game isn't
18:07open, there's no memory to look into.
18:09So, open CS2 first. Once the game is
18:12running, simply run CS2 dumper.exe.
18:16It'll do its job in a second, and you'll
18:18see that it has created an output
18:20folder. Open that folder and inside
18:22you'll find two files. Open offsets.hpp
18:26and client_dll.hpp
18:29and notepad. And there they are. Those
18:31are our offsets, the flat numbers we
18:33were talking about. Now, don't panic
18:34when you see this. I know there's a huge
18:36list in here and it looks like a lot.
18:39You do not need to read all of this and
18:41you definitely don't need to understand
18:43every line. Out of this whole list, we
18:46only need two or three of them for our
18:48snapline. And I'll tell you exactly
18:50which ones when we get there. So, for
18:52now, just keep both of these files open
18:54in your notepad. Leave them on the side
18:57and don't touch anything. We're going to
18:59come back to them in a minute. Now,
19:00let's get back to our code. All right,
19:03before we touch any code, let's fix our
19:05game settings first because if you skip
19:07this, your overlay won't show up on the
19:09game and you'll think something is
19:10broken. Open CS2 and make sure the game
19:13is running in borderless windowed mode,
19:14not full screen. Our overlay is a
19:16separate window sitting on top of
19:17everything and full screen mode takes
19:19over your whole screen and doesn't let
19:21anything draw on top of it. Borderless
19:23windowed still looks exactly like full
19:25screen, so you lose nothing. Once that's
19:27set, go into a practice match with bots.
19:29And I want to be clear about this. We're
19:31doing this offline against bots only,
19:33not on public servers with real people.
19:35Nobody learns anything by ruining
19:37someone else's match. Now go back to the
19:39resources you extracted. Open the second
19:41folder called paste_codes
19:43and open the paste_code.hpp
19:47file. Everything we need is sitting
19:48inside this file and we're just going to
19:50move it into our project piece by piece
19:52and I'll explain each piece as we go.
19:55The first piece goes inside main. Copy
19:58this first block and paste it inside
20:00main above the run overlay my drawings
20:02line. That order matters because this
20:04has to happen before our overlay starts
20:05running. So what is this actually doing?
20:07Two things. The first part is called
20:08attaching. Remember, our cheat is a
20:10completely separate program from the
20:11game. They're two different apps running
20:13on your computer, and normally they
20:15can't touch each other's memory at all.
20:17So, the first thing we do is ask Windows
20:18for permission to read CS2's memory.
20:21That's what attach is doing. And we're
20:23telling it which program we want by its
20:25name, CS2.exe.
20:28And notice what happens if it fails. And
20:30if the game isn't running, our program
20:32prints failed to find or open process
20:35and stops right there. That's actually
20:37useful for you. Uh, if you ever see that
20:39message, it's not a bug. It just means
20:42um your game isn't open. The second part
20:45gets something called the module base
20:47address. And this one is important, so
20:49stay with me. Remember the apartment
20:51building I told you about? Here's the
20:53thing. Every time you open the game,
20:54Windows puts that whole building in a
20:56different place. So the flat numbers
20:58from our dumper are not full addresses
20:59by themselves. They're the flat number
21:01inside the building. And we still need
21:03to know where the building itself is
21:04standing today. That's what the module
21:06base is. It's the address of the
21:07building. And then the actual address
21:09becomes base plus offset. Building
21:11location plus flat number. This is also
21:13the answer to a question a lot of
21:15beginners have. Why did my cheat work
21:16yesterday and not today? Because they
21:18used a fixed address instead of doing
21:19base plus offset. Now the next pieces
21:21these go above the my drawings function
21:23in the exact same order as they're
21:25written in the file. Don't change the
21:27order because in C++ your program needs
21:29to already know about a job before you
21:31can use it. Now don't panic looking at
21:32this one. I know it looks like the
21:34scariest thing you've seen so far, but
21:36remember what I taught you about
21:37functions. You don't need to understand
21:38what's inside the job. You need to
21:40understand what the job does. And this
21:42job does exactly one thing. You give it
21:44a number like player one, player two,
21:46player three, and it gives you back that
21:48player from the game. Here's why it
21:49needs to do all this work. The game
21:51doesn't keep players in one nice simple
21:53place. It keeps a list of every player
21:55in the match. And to get to one player,
21:57you have to go through that list step by
21:58step. Each mum read line is one step.
22:01read the list, then read the entry, then
22:03read the player from that entry. And
22:05those if lines you see, like if
22:07exclamation mark list entry, return
22:09zero, are just safety checks. If a slot
22:11is empty, for example, there are only
22:13four bots, but we asked for player 10,
22:15it stops and returns nothing instead of
22:18crashing your program. That's it. Give
22:19it a number, get a player back, move on.
22:22Now, this one is beautifully simple, and
22:24this is the one we've been waiting for
22:25the whole video. You give it a player
22:27and it reads that player's position out
22:28of the game's memory and hands it back
22:30to you. One single line. That's the
22:32thing we were typing by hand earlier,
22:34except now it's coming from the actual
22:35game. And look at the return type. It's
22:38a vector 3, not a vector 2. Remember,
22:40vector 2 is a point on your flat screen,
22:42X and Y. But a player in the game is
22:44standing in a 3D world. So his position
22:46needs three numbers, X, Y, and zed. Left
22:49and right, forward and back, and up and
22:51down. Which brings us to the last piece.
22:53And this is the one that makes the whole
22:55ESP possible. Now, here's the problem
22:57this solves. And once you get this,
22:58you've basically understood how every
23:00ESP in the world works. The enemy is
23:03standing somewhere in the 3D game world,
23:04but our draw line function can only draw
23:06on your flat 2D screen using an X and a
23:09Y in pixels. So, we have a mismatch. We
23:11have a 3D position, and we need a 2D
23:14screen point. So, we need something that
23:16takes a position in the game world and
23:18tells us on your screen right now, that
23:20thing is at this exact pixel. That's
23:22what this function does. You give it a
23:24vector three from the game and it gives
23:26you back a vector two for your screen.
23:28Look at the very first line of the
23:29function and the return type and you'll
23:32see exactly that. And how does it know?
23:34Cuz it reads something from the game
23:36called the view matrix. That's just a
23:38set of numbers the game itself uses to
23:41decide where everything appears on your
23:43screen while you're looking around. It's
23:46the game's own camera information and
23:48we're borrowing it. Then those lines
23:50with all the multiplication are doing
23:52the actual conversion using that camera
23:55information. And I'll be straight with
23:57you, you do not need to understand that
23:58math today. Not a single line of it.
24:01This exact function is used in almost
24:03every ESP ever made. And most people
24:05writing cheats just use it. What you
24:07need to understand is the input and the
24:09output. 3D position in, screen position
24:11out. One more thing worth noticing. See
24:13this line? That's the check for enemies
24:15who are behind you. If someone is behind
24:17your camera, they're not on your screen
24:18at all. So, it stops and returns
24:21nothing. Without this check, you'd see
24:22boxes drawing in weird places for
24:24players behind you. And that's one of
24:26the most common bugs beginners hit. So,
24:28let's take stock of what we now have. We
24:30can get into the game's memory. We can
24:32get a player. We can get that player's
24:33real position in the 3D world. We can
24:35turn that 3D position into a point on
24:37our screen. And we already know how to
24:39draw a line to a point on our screen.
24:41So, we have every single piece we need.
24:43Now, the only thing left is those
24:44offsets because, as you can see, all of
24:46these addresses are still zeros. That's
24:48what we're filling in next. Now, let's
24:51fill in those zeros. We need four
24:52offsets, and we already have all of them
24:54sitting in our notepad. One, the entity
24:56list. Go to offsets.hpp and search for
24:59DW entity list. Copy that value and
25:01paste it here in get player where the
25:02entity list is read. This one is a list
25:04of every player in the match. So, the
25:06game knows where everyone is. Two. M
25:09player pawn. This one is in the other
25:11file, client_dll.hpp.
25:14So switch to that notepad and search for
25:16m_h player pawn. Copy the value and
25:19paste it into the pawn handle line three
25:20the position. Stay in the same file and
25:23search for m_v old origin. That's the
25:26offset of a player's position in the 3D
25:28world. Paste it into get location of
25:30player. This is the important one. This
25:32is the enemy position we were typing by
25:33hand earlier. Four, the view matrix. Go
25:36back to offsets.hpp
25:38and search for DW viewmatrix. Paste it
25:40into world 2creen. That's the game's
25:42camera information, which we need to
25:44turn a 3D position into a point on your
25:47screen. And that's it. Four offsets, no
25:48more zeros. Our program now knows
25:50exactly where to look inside the game.
25:52One small thing to remember, if CS2 ever
25:55updates, these values can change. You
25:57don't panic and you don't start over.
25:59You just run CS2 dumper again and paste
26:01the new values in these same four
26:03places. Now we have everything. We can
26:04get a player, get his real position, and
26:06turn it into a screen point. So, let's
26:08actually use all of it and finally draw
26:09on a real enemy. Now go to the my
26:11drawings function, type four and press
26:14enter and Visual Studio writes the whole
26:16loop for you. Change the number to 64
26:18and put our old code inside it. And let
26:21me explain the loop first. Until now, we
26:23were drawing one line to one fake
26:24position. But a match has many players
26:26and we want a line on every one of them.
26:29A for loop just means do the same thing
26:31again and again. Here it runs 64 times
26:34because 64 is the maximum number of
26:36players CS2 can hold. And I is just the
26:39count, zero. the first time then one
26:42then two and so on. So each time it runs
26:44we ask for a different player. Now let's
26:46add our functions one by one. First get
26:48the player. Remember this job you give
26:50it a number it gives you back that
26:51player from the game. So we pass it I
26:54which means player zero then player one
26:56then player two all the way to 63. And
26:58player here is a box. And by box I mean
27:01a variable. The same thing we talked
27:02about earlier. So whatever get player
27:04hands us we're putting it inside this
27:06box name player so we can use it in the
27:08next line. Now, what about this word
27:10auto at the start? Normally, you have to
27:12tell the computer what kind of thing
27:13goes in the box, like we did with vector
27:152. But auto just means figure it out
27:17yourself. The computer looks at what get
27:19player gives back and makes the right
27:20kind of box automatically. That's all
27:22auto does. It saves you typing. Next,
27:24get his position. Now, we take that
27:26player and ask for his actual position
27:28in the game world. And look at the box
27:30we're storing it in. Again, by box, I
27:31mean a variable. This one is a vector 3,
27:34not a vector 2, cuz he's standing in a
27:363D world. So, we get three numbers back.
27:38X, Y, and Z. Now convert it to our
27:40screen. 3D position goes in, screen
27:42position comes out, and look what it
27:44gives us back. A vector 2, which is
27:46exactly what our draw line needs. And
27:47notice something. Enemy position is the
27:49exact same box. The same variable from
27:52earlier in the video, the one we were
27:53typing numbers into by hand. We're not
27:55deleting it. We're just letting the game
27:57fill it for us now, every single frame
27:59while the enemy runs around. And our
28:01line stays exactly the same. We didn't
28:03touch this at all. Same start point at
28:04the top center of the screen. Same draw
28:06line, same four details. The only thing
28:08that changed is where the end point
28:10comes from. Here's everything together.
28:11That's the whole cheat. Everything
28:12before this was just building the
28:14pieces. Now, hit the green play button
28:15and go look at your game. And there it
28:17is. Look at that. Red lines pointing
28:19straight at every single enemy,
28:21following them while they run around,
28:23even through walls. And you made this
28:25yourself. Take a second and look back at
28:26what you just did, cuz it's a lot more
28:28than one cheat. You learned what a
28:30variable is. You learned what a function
28:31is. You learned how your computer sees
28:33your screen. You learned that everything
28:35in a game is just numbers sitting in
28:37memory. You learned what offsets are and
28:39how to get them. You learned how a 3D
28:41position in the game world becomes a
28:42point on your flat screen. And you took
28:44all of that and built a working ESP.
28:46That's not a small thing. Most people
28:48who want to get into game hacking never
28:50write a single working line. You just
28:52did. Now, here's the part I really want
28:53you to hear. Everything you just learned
28:56is not about CS2. These exact same
28:58concepts apply to every single game on
29:01this planet, including the biggest
29:03online shooters and battle royale games.
29:05Their cheats work on the exact same
29:07idea. Find the players, read their
29:09positions, convert to screen, draw. So,
29:12what actually has to change when you go
29:13to a different game? Honestly, less than
29:15you think. First, your offsets. This is
29:18the main one. Every game keeps its data
29:19in different places, so the addresses
29:21you paste in will be different.
29:22Everything we did in the offsets part of
29:24this video is the same process just with
29:26that game's dumper or your own reverse
29:28engineering. Second, the get player
29:30code. Every game stores its player list
29:32a bit differently, so the steps for
29:33walking through that list will look
29:34different, but the job stays the same.
29:36Give it a number, get a player back.
29:38Third, get location of player. In most
29:40cases, this is the easiest one. You
29:42usually just change the offset and
29:44you're done. And world to screen usually
29:45needs little or no change at all. Some
29:48games need small tweaks, but the math is
29:50the same everywhere because every 3D
29:52game draws to your screen the same way.
29:53So, the structure of your cheat never
29:55changes. Only the details inside it do.
29:57That's exactly why I taught you the
29:58concepts instead of telling you to
30:00memorize code. And now, it's your turn
30:02to build on it. Right now, we're drawing
30:03a line. But look at your My Drawings
30:05function. You already have the enemy's
30:07screen position sitting in a variable.
30:09So, what else can you do with that same
30:10position? You can draw a box around him
30:12instead of a line. You can put his name
30:14above his head. You can read his health
30:16and draw a health bar. You can measure
30:18how far away he is and show the
30:19distance. Every single one of those
30:21features uses the exact same position
30:22you already have. That's all an ESP
30:24really is. If you want to learn more
30:26advanced game hacking, today we used a
30:28dumper to get our offsets. But remember
30:30what I told you earlier. The dumper only
30:32worked because somebody else already did
30:33the hard work for us. So the next thing
30:35you need to learn is how to find offsets
30:37yourself through reverse engineering.
30:38That's the real skill. And once you have
30:40it, you don't depend on anyone for any
30:42game. That's what my Patreon is for. The
30:43link is in the description. I've put
30:45everything I know over there and I built
30:47it as the place I wish existed when I
30:49was starting out eight years ago.
30:51There's a full series on reverse
30:52engineering and finding offsets yourself
30:54and then building your own dumper for
30:56any Unreal Enginebased game so you never
30:58wait for someone else to release offsets
31:00again. There's kernel driver development
31:02too and a lot more. And it's the same
31:04style as this video. I explain why
31:06things work, not just what to click, so
31:08you can apply it to any game. And it
31:10costs less than most people spend on
31:12junk food in a week. Except this one
31:14won't wreck your health. So if you're
31:15serious about this, come join us. And
31:17whatever you do, keep practicing because
31:19that's the only thing that actually
31:21makes you good at this.

About this transcript

This page contains the full transcript of The SIMPLEST Way To Make Your OWN CHEATS For Any GAME by BranchLink, generated from the public captions YouTube serves with the video. The transcript has 6,909 words across 965 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.