Holstin help

(I've also said it later but I'm going to be teaching you how to modify the ammo of this game even though you specifically said you want to do stamina only because the type of data will be easier for you to understand in the beginning and there will be a decent amount of reading. You can jump back and forth to use what I wrote down as a reference if you want to try and jump straight into it, but I'd recommend at least giving everything a once over first)

This may be a bit unorganized because I only actually use reddit on the phone on the go but I'll try to hit as many points as I can and I'd say that out of every game that I've used CE on, I've used pointers maybe twice and every other time I wanted a permanent modification for later, I've modified the code like this

It will require that you learn some very basic terms in ASM(assembly- which is actually a programming language) this is what makes it more "difficult", but it's actually pretty comparable to learning to say hello, goodbye, and how to ask where the bathroom is in a new language. The thing is, for a large majority of games you will only really need to learn some basic instructions and learn to recognize how they are being used. After you have that knowledge under your belt, it's usually possible to have a functional, lasting cheat up and working in a matter of a few minutes... usually lol. There are cases where your knowledge of the language will be tested, but it's impossible to know for any specific game until you try.

Also, before we actually get started, in the code that you copied to your table(which you can see by double clicking on script beside the entry on the table) you may notice several lines of // followed by blue words. This is not how it looks in all programming languages, but it has the same effect in all languages. Those blue words are known as "comments" in code. It's something programmers usually include in order to help others understand their code or to help remind themselves of something later. These lines do not actually get executed when the code is ran, and is only there to be helpful or to be a reminder etc. I left those comments to try and help you understand the code, but they are pretty useless without some of the basic knowledge under your belt.

Let me start by trying to explain some of the instructions and value types you see in the code, but know that dealing with float values like the one we have for stamina in this game will actually require reaching into more advanced territory of learning the language.

-----------------

An integer is basically a whole number (1,100,-28,0 etc.)
Just for reference, the ammo for this game in specific is an integer value, While the health/stamina are floating point numbers↓

A floating point number is a fractional number(what we are dealing with in this game for stamina specifically) floating point numbers do get into the more complicated territory and I would recommend learning to work with integers first. But examples of these numbers would look like (0.5,50.852,-25.43)

(Just for ease of teaching and opening the door for you, we'll be working with the ammo even though I know you said you only want to do the health/stamina)

(Also, you don't need to learn this next one, but you definitely need to be able to at least understand what it is and how you can translate it)

Decimal or base 10 is the number system that you should be very familiar with. It is comprised of 10 symbols which then repeat as a value grows(0,1,2,3,4,5,6,7,8,9)

Hexadecimal or base 16 is a number system commonly used in programming and even more specifically, debugging. It is comprised of 16 symbols (0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F)

(In order to translate hexadecimal into a number easier to understand, you can simply type in any hexadecimal value that you have in your calculator on Windows by selecting the programmer option and the calculator will translate it to decimal on the side automatically)

A byte is a single unit of memory and is viewed in hexadecimal however it can be translated to decimal for ease of understanding(3C, 7A,04,FE) the largest number a single byte can represent is 255 or FF.

So a 4 byte value would look like (BB 21 4C 33, or 05 2C 1A 96) these can be obviously be used to represent much larger numbers and are commonly used in newer games because of the ability to represent such a large variety of numbers that a game developer might want to display to the player(for example a money count in the hundreds of thousands)


Now a floating point value also takes up 4 byte of memory but is handled differently in a way that you may learn later but is not necessary to know right now but it could be represented in the same way that an integer could be

An array of bytes or AOB is basically just a grouping of these bytes and can range from 1 byte to as many as you can imagine really. This will be important to know, but for the purposes of you making your own modifications for personal use, it won't be necessary right now.

Like I said, we'll start with the basics on the hopes I can help you

Registers look like (EAX, RBX, EBP, RSI) and their function is to hold a value for use later basically. Computers have to move memory around a lot in order to produce everything you see on your screen and registers help facilitate said movement. These registers look different based on whether the application is 64bit or 32bit but they mostly function the same and it is not necessary to delve deeper into that yet.

So for example part of the code might include a calculation on your health to see how much damage you actually receive and at the end of which, it would need to store the value somewhere before it can transfer the new "calculated health" over to the address where the players health is actually stored. The location the computer would store this value is in a register.

Now the value that these registers hold can also include locations in memory as well as regular values. This is what you are seeing when you see something like [rbx+20]. The brackets are indicating that the value contained in the register is actually a memory location not a regular value and the "+20" is indicating that the necessary memory location is actually stored 20 bytes ahead of the address inside of "rbx" in this case. However you can also encounter a memory location that looks like [RAX] which indicates the value is stored directly at the location inside of the register

It's worth mentioning that this stored memory location in brackets is in fact a pointer, but again we don't need that knowledge just yet.

When looking at the code we will be finding later, it will be comprised of both read and write commands

Read- this is when an instruction will be looking at our value of the address we want to modify but not actually changing it in the instruction so that it can use the value for something else(like for a damage calculation)

Write- this is when an instruction changes the value of the address we want to modify

Now on to some basic assembly commands

MOV - this instruction moves a value from one location to another...for example by moving the new calculated health into our actual health address...(In the case of the stamina code I wrote for you you may notice that the instruction is actually MOVSS...this is a variant of the instruction that preforms the same task, however it looks different because we are working with a float value and not a regular integer in that case) the mov instruction moves the value on the right into the value on the left. For example "mov eax,[ebx]" this moves the value that is at the memory location of ebx into eax. It's also worth mentioning that the register in brackets in all the code we find will actually contain the address of the value we want to modify.



CMP - this instruction compares two values and basically checks a flag to say are these equal or not

JMP- this instruction tells the code that it needs to actually stop running normally (which would typically be sequentially from top to bottom) and to move to a new location in order to continue.

JE,JNE,JG(there are more, but they are pretty easy to identify on your own) - these instructions are known as conditional jumps...they all have different functions similar to the JMP command. However, whereas JMP will always jump to a new location, these jumps only occur if a certain flag is checked for example the one I mentioned with CMP. This can be used in many ways like for example "is health equal to 0? If so jump to the line of code that shows the death animation. If not, continue running normally."

NOP- this instruction literally means do nothing. It is basically used as filler  but can also be used when we make our cheats. Each of the above commands takes up a certain amount of bytes and NOP takes up one byte. You could in theory sometimes find the code that moves say "calculated health" into your "health" and replace it with code that does nothing so that your health never changes, but this is kind of sloppy and can result in problems like a game crash if not careful

These are the most common instructions you will need to be familiar with and when writing code you actually will only regularly need one especially for simpler games. Some games include protections that will require more advanced work arounds, but that's for a later time.

This also concludes basically everything you should need to know to get started with the basics of having lasting code modifications.

-------

ACTUAL APPLICATION OF KNOWLEDGE

-------

To start we are going to find the ammo in our magazine and it seems to be an integer value so we'll go ahead and scan for it by using a 4 byte scan. It will be easy to find by just shooting to change the ammo and scanning for the new decreased value.

Once we have that value we want to find what accesses the address. You'll notice in this game specifically as soon as you do that and the game is active there are several instructions constantly counting up. In the case of the ammo In this specific case, there should be two. We can assume these are necessary for the game to do some other task like being able to display ammo on screen later or some other function.

Now if we zoom in our weapon a few more pop up, one that ticks up as long as the ammo is displayed on screen one that only goes up by one each time we zoom in, and one that only goes up as long as you are holding the zoom. These are all different functions that are accessing our address for different purposes which we can assume based solely on when they appear.

This is where what I taught you comes into play and where the beauty of code injection shines. all of these codes are just that, codes. They are lines of instructions that never change. The game is written to do specific things and those instructions will pretty much always be in the same spot every time we load the game up (unless an update changes the location of the code, but that's where an AOB scan can come in handy sometimes)

All of these codes we see here can actually be saved for later to find our address at a later time if we wanted we will go ahead and save only one for right now however. This is just in case we mess up our code and cause the game to crash.....(It happens lol)

So what we will do first is click on the top MOV instruction that is always active no matter what and click add to code list. Let's name the code "code accessing our ammo" this will also pull up our code list. If you save the table now, you can pull this up later for ease of use by clicking advanced options.

 So far all of these instructions have been read instructions which is okay, we can modify them later to make them write instructions.(This is another reason why I wanted to teach you with the ammo first because the health in this game in specific contains a bit of an anomaly. It not only has multiple codes reading from it constantly, but it also has multiple codes constantly writing to it as well. This does happen, but is not too common)

You should be made aware at this point that anytime you see a CMP instruction with our address that it is a read instruction. Also any time you see a mov instruction with our address on the right, that it is also a read instruction. If there is a mov instruction with our address on the left, then a value is being moved into our address or being "written" to.


Now that we have saved our code in the code list, we can right click on it in the code list and click open the disassembler at this location

It may look confusing here, but for our purposes right now the only thing we need to look at is the one code we saved which should already be highlighted now in the memory viewer.

With our code selected we can begin to modify it by selecting tools, and then auto assemble.

Now CE has some great built in scripts to help you get started writing your code that will make it so we only have to write a single line basically and we should have a working cheat in this case. (In the case of the code you copied into your table I had to write 9...again that's why we will be working with the 4 byte ammo value first)

Click on template and then cheat table framework code and boom it auto writes the script necessary to use your code with an on and off function on the table.

Next click template and click code injection. The address it shows here is the address containing the code that we saved. Click okay. from right here we should actually be able to go to file an assign to our table and be able to turn it on and off. However, at the moment the code will accomplish nothing.

What we have so far is basically CE injecting a jump into the lines of code where the our old instruction was to go to a new area at which point we can execute as many new lines of code that we need to make our cheats work. Right now it is jumping to a new area but still just executing the same code in a different area. You can see our instruction under the label originalcode:

But you may say that the code is only reading our instruction so how do we do something that can make it so we have infinite ammo if it's not actually writing to our address...that's where our knowledge of the instructions comes in.

Under originalcode: is where we want to make our modifications to the code.

All we want to do in this case is add a line of code right above the original that moves a new value into our address.

One way we can do this (know there are many many ways we can do this, but we are starting simple)is to write

 mov [the register and any offsets in brackets in the code below],(int)99

If we are on the same version, it should look like

Mov [rbx+20],(int)99

We know that the register in brackets contains our address we want to modify and we know it's an integer value so we move the value of 99(it is important to specify the value type as I have done here or CE will get confused) into our address.

Now when the game gets to the code that is reading our address, it will instead jump to our new location while the cheat is active, and executes our new line of code as well as the original read code

At this point you should be able to assign this cheat to your table and have a working ammo code.

If you choose to go for modifying a write code however, you will typically want to change the actual instruction instead of leaving it be like we did here.

This is because code executes from top to bottom and if we put a line of code that changes our address to a specific value but the original write commands is left intact beneath it, the write commands will still go ahead and put it's value into our address immediately after rendering our code useless. Alternatively with a write command, you can put a new line of code directly beneath it which would then render the original write command useless.

--------------

should you experience any issues like a crash from this point, you can open up your code list and use the code we saved to do what ever you may want to do. You can also use this code we saved to help you narrow down your pointer scans or just as a way to re find your address quickly

If you right click the code in the code list, but this time click find what addresses this code accesses, a window will pop up and whenever our code is executed (which should be all the time in this case) it will show the address that it is reading which just so happens to be our ammo.

It gets more advanced, but you should be able to get the basics from what I've wrote here. I'm tired lol. I hope this helps.