 |
Cheat Engine The Official Site of Cheat Engine
|
View previous topic :: View next topic |
Author |
Message |
++METHOS I post too much
Reputation: 92
Joined: 29 Oct 2010 Posts: 4197
|
Posted: Wed Mar 06, 2013 9:13 pm Post subject: Trouble with finding player ID |
|
|
I think I published a thread about this some time ago, but I am still having trouble with it.
I am wondering if anyone has ever had a problem with finding the player ID for friend/enemy? Where did you start the dissection? At player health? Have you ever seen any oddball values for player ID (as opposed to 0, 1, 2 etc.)? If you did not find this value near the health address, where did you find it? Was it close/far from your dissection address?
Since I cannot find the player ID, I am using my health address to compare, as a temporary fix. I have hacked the health address to go beyond what any other player in the game will have, to make it unique, so the health cheat must be enabled for the script to work. I'd like to change this so that all scripts will not be dependent on the health address. So far, I have created a script that immobilizes all players except hero player, but this script is relying on the fact that the health address is being manipulated.
Thanks.
|
|
Back to top |
|
 |
Gniarf Grandmaster Cheater Supreme
Reputation: 43
Joined: 12 Mar 2012 Posts: 1285
|
Posted: Thu Mar 07, 2013 12:04 am Post subject: |
|
|
Personally I don't use PlayerID to differentiate between variables because I don't know any reliable or semi reliable method to find it. I tried this approach once, with serious sam3, and my reasoning was the following:
1-the number's address was close to the health's address. I don't remember how far, but I think it was less than 0x100 bytes.
2-the number was too small to be a pointer or a botched float/double.
3-it looked like it were always the same value (0x101 iirc) when it handles the player's health and uses another for enemies (0x103 iirc).
Well it didn't work that well since some enemies were unkillable too. In the end I found that game has cheat codes, so I didn't try other stuff.
In your case I'd try "find out what accesses..." and find a function - any function - the handles the "hero player" 's health and nothing else (the one that reads his health to display it in a corner is often a good candidate...). The "find our what addresses this function access" feature is quite useful for that.
Then either turn this function into a freezer or simply use it to note the hero player's health address somewhere. After that, in your hooked functions, just use compare the address of the health you're going to write with the stored address and if it's the same do your hack(s).
EDIT: this video shows a russian guy finding the player ID in mass effect 3: http://www.youtube.com/watch?v=NjkheCO0hfo
Looks like health=[esi+6C], playerID = [esi+2C]=D3.
|
|
Back to top |
|
 |
++METHOS I post too much
Reputation: 92
Joined: 29 Oct 2010 Posts: 4197
|
Posted: Thu Mar 07, 2013 1:12 am Post subject: |
|
|
Thanks for the tips. This definitely gives me something to think about. This particular game allows you to choose from multiple characters, all with different stats/values, so I may have to get creative.
Thanks, again.
|
|
Back to top |
|
 |
lp0 Advanced Cheater
Reputation: 2
Joined: 25 Feb 2013 Posts: 73
|
Posted: Sat Mar 09, 2013 10:33 am Post subject: |
|
|
Some random thoughts on my approx. 1 week with Cheat Engine, plus some general insight on programming, computing, best practices, etc. As with the GNU license, there is no implied usefulness of any of this information. Ignorance is bliss, and if I'm stupid, don't tell me because it's much more fun this way.
For me, it's all about having controllable conditions in which you can test, which provides a sufficient variety of data for a meaningful comparison, while not providing too much data so-as-to bury any investigatory efforts. That's a long sentence, dripping with subtlety and nuance; I'll try to dissect it a bit.
Controllable conditions: This is paramount to any investigation, because if you cannot control the initial (or thereabouts) conditions of the investigation, you will never be able to separate the "noise" from meaningful results. What this means, relevant to your question, and in the context of CE, is that you should strive to create a situation (possibly a save point) that you can use a starting point for your iterative investigation. An example in the context of your question:
Investigation: I want to find a piece of data that can be used to identify between friend and foe.
Initial conditions: Create a scenario that has four (I use four, you can scale up as you like) "actors" - two from the player side, two from the enemy side. If possible (such as a map game, etc), create this point with the same four units every time.
I use four units, with an even split between friend and foe, because it provides me (personally, that is; YMMV) with a sufficient amount of information that I can do comparisons, fiddle with memory, etc - while not having so much information that my brain will fail to extract patterns between the four sets of data.
So, you have your initial conditions now; with a save point (or equivalent) to reset the investigation as needed. Next thing, is to find a value that you can use to derive the base structure for a unit. A popular one is health, probably, but any value will generally do - as long as it is a value that is shared between all units, regardless of type, friend, foe, etc. So, let's assume health.
Find the health value for a unit - maybe 4 byte integer, possibly float. Whatever the case may be, let's assume you've found it. Now, add it to the address list and use "What writes to this address". A quick aside.
Some suggest using "what accesses this address" - I tend to shy away from that, because I'm not interested in what reads the address in question to display on a GUI or whatever; I want the code that modifies the address. But that is my preference, not a Law of Nature.
When your watching what writes to that address, go take some damage (once or twice, not a thousand times). If your lucky, there should only be a single code result - more on this in a minute. If there are multiple results, that does complicate things a little more, in that you should now see if these multiple code addresses are really all part of a single "block" - use the disassembler for this. If they are all close together (probably floating point, then) it is up to you to discern the purposes of the registers in that code. Once you've done that, you can inject code at a specific spot to modify the register you are interested in.
So, let's make up a scenario, according to the following rules:
`eax` holds the value of the new health for the actor in question
`edx` holds the damage being inflicted on the actor in question
`esi` holds the pointer for the structure of the actor in question (offsets have to be relative to something, after all)
[esi+4] is the current health of the actor
[esi+8] is the max health of the actor
Code: | mov eax,[esi+4]
sub eax,edx
mov [esi+4],eax // inject point alpha
|
To make god mode, you could set `edx` to zero before this block is executed; or, you could use "inject point alpha" (awesome name, I know) to set `eax` to [esi+8]. The moral of this convoluted story is that if you get multiple results, see if they are part of the same block, then establish the purposes of the registers, then inject code at the "simplest" point to accomplish your goal.
Ok, back to the single result - now, for some ranting on why there is a single result, with the same address, for every actor in a game. This part deserves a special disclaimer, because of so many things - different games, different designs, code folding via compilers, probably infinite other things. Nevertheless, the rabbit hole goes deeper ...
In short: because from a design standpoint, it's easier. Have a single procedure for modifying health of any actor in the game - or have a slew of procedures, one for every actor, that replicates the exact same code. The former is (usually) the goal. So, from the sounds of your original post (trust me, this is still relevant!), this is what you have.
So, you've found the code address, and you have your injection point. You have your basic AA script, and are ready to do some damage (or not, as the case may be). How do you do a friend or foe test (henceforth, referred to as an IFF test)?
To do so, I'll deviate even more from your original question, into the topic of "structures". In the abstract, structures are collections of data - there are a ton of practical software benefits as to why structures are used, but we don't really have to care about any of that. What we do care about, is that structures exist and if you can find one member of a structure, along with the code that modifies it, you can find the start of the structure and begin looking for patterns - such as a player ID.
So, using the code example I used above, this snippet of assembly would pop up in your "find out what writes" window:
Once that shows up in the window, you can show the disassembler to see it and the surrounding code - however, before you show the disassembler, look at the other information listing the values in the registers when that instruction was executed. We can get the value of `esi`, and we know that it is the base of the structure we're investigating.
Now show the disassembler, go up top to 'Tools->Dissect data/structures', and it will open a new window for you. In the address box, you want to put in the value of `esi` as shown in the 'what writes to this address' window. Use 'Structures->Define new' and let CE guess the offset/types for you - it won't always be right, but it will be close enough for now.
There should now be some information that is visibly relevant to the actor you are investigating - I generally go around in the game, jot down a few attributes and statistics of the actor I'm investigating, and see if I can find them in the first hundred or so offsets in the structure. I generally find at least one or two. You should always be able to find at least one, because we already have the offset for the actors health - in the above example, +4; although, in practice it will be much farther down (probably a hundred or so offsets).
So, you now have one structure, which represents a single known actor in the game. We need three more. Luckily, we can skip some of the steps of the previous process, and just find their health value; once we do, open up your favorite calculator, put it into hex mode, and then subtract the 'current health' offset from the value you find with CE. To be more specific, let's say we have our first structure, open in dissect data structures, and we begin a new search for the next actors health. We find that second actors health. Now, we go to 'find what writes to' ... stop. We don't need to do that.
Using a calculator (or in your head if your nerdy), subtract whatever the offset was from the assembly code we looked at earlier (4) from the second actors health address, and that will be the base of the structure for the second actor. Again, being more concrete, if the address which held the second actors' current health was 01DB7F3C, and the offset for the current health is 4, then subtracting the offset from the value yields 01DB7F38 - which we will use as the base for our second structure.
Going back to the dissect data/structures window, use 'File->Add new group' (or Ctrl+G), and paste that second address into there; some of the colors will probably change a bit, which will be highlighting differences, and not changing color for no differences. Now, we repeat this process (find health value of actor->subtract known offset->paste base structure value into a new group) for the remaining actors.
In the end, you'll have 4 groups, showing you the differences between each actor. At this point, you can look for patterns - generally, a player ID is a simple value (probably a single byte, as it has a max value of 255 (unsigned) and that is more than enough "sides" for most games), so I usually start with the least complex options and work my way up from there.
We've opened data, looked at it, fiddled with it, and think we have an IFF test for an offset of [+C]; so, let's go back to the code example I used above.
Code: | mov eax,[esi+4]
sub eax,edx
mov [esi+4],eax // inject point alpha
|
Say we wrote an AA script, then, that did nothing but execute the code that the game uses now. It might go something like this (not checked for validity):
Code: | [ENABLE]
alloc(newmem,4096) // page size
label(newCode)
label(returnHealthCheat)
newmem:
newCode:
// IFF test
mov [esi+4],eax // original code
jmp returnHealthCheat
SomeGame.exe+01234567:
jmp newCode
nop
returnHealthCheat:
[DISABLE]
SomeGame.exe+01234567:
mov [esi+4],eax // original code
dealloc(newmem) |
The issue now (among so many issues, I'm sure) is that we have to branch and handle player health different then we do for enemy health; ruminations on programming languages aside, the way to do this is to use the IFF test as a branch for deciding how to handle the health of an actor. So, we do something like this:
Code: | [ENABLE]
alloc(newmem,4096) // page size
label(newCode)
label(originalCode)
label(returnHealthCheat)
newmem:
newCode:
cmp [esi+C],0 // We will assume [esi+C] equal to zero is the player; not equal is an enemy
jne originalCode // If [esi+C] is not equal to zero, go to this label
// We know [esi+C] is zero, so this is how we handle player health
// - As above, we know [esi+8] is an actors max health
mov eax,[esi+8] // player units always have max health
originalCode:
mov [esi+4],eax // original code; updates an actors health
jmp returnHealthCheat
SomeGame.exe+01234567:
jmp newCode
nop
returnHealthCheat:
[DISABLE]
SomeGame.exe+01234567:
mov [esi+4],eax // original code
dealloc(newmem) |
I think I'm out of things to say; I shouldn't drink beer this early in the morning.
(Can't post URL's).
Also, watch the video's on YouTube by jgoemat, for CE. All 3 of them, then watch them again; then, do what he just did to a simple game - not floating points. Then, watch them again, and do it to another game. "Hack" every game you own, because ... well, why not. Then, watch them again.
|
|
Back to top |
|
 |
++METHOS I post too much
Reputation: 92
Joined: 29 Oct 2010 Posts: 4197
|
Posted: Sat Mar 09, 2013 1:49 pm Post subject: |
|
|
lp0, I appreciate the effort...it looks like you spent a lot of time with that reply. Thanks.
Unfortunately, everything that you have posted is old news for me. The problem that I am having with finding the player ID is not in how to do it, but in actually finding a static value that can be used at all.
The player values in this game are random and recycled. If one troop dies, another troop will take that spot, at the same address. I have looked high and low (very) while dissecting data structures, and none of the addresses that are similar are static. Unfortunately, for this game, I think I am going to have to continue using my own manipulated code, and just create an ID that can be used to separate my player from the rest.
Thanks, again.
|
|
Back to top |
|
 |
daspamer Grandmaster Cheater Supreme
Reputation: 54
Joined: 13 Sep 2011 Posts: 1588
|
Posted: Sat Mar 09, 2013 2:08 pm Post subject: |
|
|
GNIREENIGNE,
If you did not understood what the person above me wrote (very helpful), I'm willing to help you out .
Not far ago, decided to use the dissect structres (Well I made some teleport hack for some MMO game, some famous MMO game, told the admin, and helped him to patch it.. and got some great stuff inside the game ).
And you can always do
do
Code: |
alloc(check,1)
registersymbol(check)
db 00 //equals to 0.. lol
|
add an address named check
Add hotkeys to it (like hotkey F1 will set the value to 0 and hotkey F2 will set it to 1)
then do in the assembly script this
[/code]
...
newmem:
cmp [check],0 //useful ONLY when its turn-based. if its not, you'll be screwd, but I will help you out .
je enemy
jne player
jmp exit
player:
mov ebx,[eax+08] //08 is max health..
mov [eax+04],ebx //just example.. like 04 is min health
jmp exit //jmp to exit, to the rest of the original function, because if you don't it will do the enemy script part..
enemy:
mov ebx,0 //sets ebx to 0
mov [eax+04],ebx // 04 is hp, of enemy probably
//you can do alternative mov [eax+04],0 ...
jmp exit //not really needed, just got used to do so
exit:
jmp returnhere
_________________
I'm rusty and getting older, help me re-learn lua. |
|
Back to top |
|
 |
Dark Byte Site Admin
Reputation: 470
Joined: 09 May 2003 Posts: 25788 Location: The netherlands
|
Posted: Sat Mar 09, 2013 2:08 pm Post subject: |
|
|
Perhaps the unit has a pointer to another structure that in it's turn has a pointer to the controller object, which may have a pointer to a string that contains your name, or just Player
_________________
Do not ask me about online cheats. I don't know any and wont help finding them.
Like my help? Join me on Patreon so i can keep helping |
|
Back to top |
|
 |
lp0 Advanced Cheater
Reputation: 2
Joined: 25 Feb 2013 Posts: 73
|
Posted: Sat Mar 09, 2013 2:23 pm Post subject: |
|
|
In that case, I have a large structure of just bytes that I "map" onto a location when I'm really stumped.
It can be tricky, but it pointed (haha CE pun) me in the right direction once or twice.
|
|
Back to top |
|
 |
++METHOS I post too much
Reputation: 92
Joined: 29 Oct 2010 Posts: 4197
|
Posted: Sat Mar 09, 2013 2:50 pm Post subject: |
|
|
Flashacking wrote: | GNIREENIGNE,
If you did not understood what the person above me wrote (very helpful), I'm willing to help you out .
Not far ago, decided to use the dissect structres (Well I made some teleport hack for some MMO game, some famous MMO game, told the admin, and helped him to patch it.. and got some great stuff inside the game ).
And you can always do
do
Code: |
alloc(check,1)
registersymbol(check)
db 00 //equals to 0.. lol
|
add an address named check
Add hotkeys to it (like hotkey F1 will set the value to 0 and hotkey F2 will set it to 1)
then do in the assembly script this
[/code]
...
newmem:
cmp [check],0 //useful ONLY when its turn-based. if its not, you'll be screwd, but I will help you out .
je enemy
jne player
jmp exit
player:
mov ebx,[eax+08] //08 is max health..
mov [eax+04],ebx //just example.. like 04 is min health
jmp exit //jmp to exit, to the rest of the original function, because if you don't it will do the enemy script part..
enemy:
mov ebx,0 //sets ebx to 0
mov [eax+04],ebx // 04 is hp, of enemy probably
//you can do alternative mov [eax+04],0 ...
jmp exit //not really needed, just got used to do so
exit:
jmp returnhere | Flashacking, please read my post above. I understand the basics, but this particular game is just an oddball of sorts.
For example, building a script around max health will not do anything more than what I already have. There are many troops for this game, half enemy, half friendly. Different troops have different levels of health. The higher ranking troops have more health, but are similar to enemy troops. The enemy leader health can be as high as, or higher, than the hero health. So, setting the hero health to an extremely high value (one that the game doesn't even use), is the only solid way that I can build a script around health (that I know of, so far).
Dark Byte wrote: | Perhaps the unit has a pointer to another structure that in it's turn has a pointer to the controller object, which may have a pointer to a string that contains your name, or just Player | That makes sense. I've looked at some of the strings in the current structures that I am analyzing, and none of them make sense. I have tried converting them to make sense of them, to no avail. In fact, many of the strings that I have found are dynamic and change during game play.
It would be interesting to learn how to determine if what you are saying is true. It would also be interesting to see how to go about working with a game that is like that. I wouldn't even know where to start.
Obviously, something is telling the game which characters are enemy and which are friendly. There are even color-coded health bars (cyan for friend and magenta for enemy). I've even considered trying to pull the pixel color data from that and searching those values in hex, but I really have doubts about whether or not that would work in the end.
Thank you all for your help.
|
|
Back to top |
|
 |
lp0 Advanced Cheater
Reputation: 2
Joined: 25 Feb 2013 Posts: 73
|
Posted: Sat Mar 09, 2013 2:57 pm Post subject: |
|
|
I'm interested; care to share the name of the game?
|
|
Back to top |
|
 |
Gniarf Grandmaster Cheater Supreme
Reputation: 43
Joined: 12 Mar 2012 Posts: 1285
|
Posted: Sat Mar 09, 2013 3:33 pm Post subject: |
|
|
Not sure it would work, but you can try the following crazy idea: assuming health is accessed by [eax+1234], copy every byte from the beginning of one friendly unit (eax+0) to eax+1234, freeze the game, paste those bytes over an enemy unit, and resume the game. If that enemy unit just switched sides or health bar color, you know your ID is somewhere in that.
If it does not work AND doesn't crash, you can venture past unit_begin+1234, problem is knowing where the unit's data ends, and where the next thing's data begins... You can try picking a random spot a few bytes further, "find[ing] out what access..." which will give you a result with [register+Offset]. As long as Offset keeps increasing you're still on that one unit's data.
Normally you should end up doing a clone of your unit, right? Riiight??
Let me know if it proves of any use. Also what game is it? Does it have a demo/trial version?
|
|
Back to top |
|
 |
daspamer Grandmaster Cheater Supreme
Reputation: 54
Joined: 13 Sep 2011 Posts: 1588
|
Posted: Sat Mar 09, 2013 3:47 pm Post subject: |
|
|
Well, what i wrote is just an suggestion.. I've tried making the same for a facebook game named marvel avengers alliance, I have faced the same issue as you..so decided to use hotkeys..because AI and players sharing the same IDs + theres 3 addresses for HP, and for 1 theres something different.. but for the second one theres nothing different...(and the second one being called first..)..
Anyway, good luck.
Give me the game name and I will check it out.
_________________
I'm rusty and getting older, help me re-learn lua. |
|
Back to top |
|
 |
++METHOS I post too much
Reputation: 92
Joined: 29 Oct 2010 Posts: 4197
|
Posted: Sat Mar 09, 2013 6:05 pm Post subject: |
|
|
lp0 wrote: | I'm interested; care to share the name of the game? | Hi. It's Dynasty Warriors 6; reloaded version...can be found online. The name of the file is: rld-dw6.iso
Gniarf wrote: | Not sure it would work, but you can try the following crazy idea: assuming health is accessed by [eax+1234], copy every byte from the beginning of one friendly unit (eax+0) to eax+1234, freeze the game, paste those bytes over an enemy unit, and resume the game. If that enemy unit just switched sides or health bar color, you know your ID is somewhere in that.
If it does not work AND doesn't crash, you can venture past unit_begin+1234, problem is knowing where the unit's data ends, and where the next thing's data begins... You can try picking a random spot a few bytes further, "find[ing] out what access..." which will give you a result with [register+Offset]. As long as Offset keeps increasing you're still on that one unit's data.
Normally you should end up doing a clone of your unit, right? Riiight??
Let me know if it proves of any use. Also what game is it? Does it have a demo/trial version? | Interesting suggestion. Unfortunately, I'm not sure that this will do any good, and I'll explain why. I have set 4 addresses, 2 groups when dissecting data structures. In one group, I have the hero address for health, which is a +4 offset. I also have a friendly officer, same as above. In the second group, I have placed 2 enemy officers, both at health +4 offset. The strange thing, is, I have set my structure size at 8096 (and) tried setting the addresses at -800...which, by doing so, should give me a pretty large chunk of code to analyze. However, in all of that code, there is not a single address that remains static and is indicated as purple (as it should be for player ID and/or health bar color etc.). The only thing I can attribute it to, is either as Darkbyte has described above (and/or) the characters are getting shuffled around (not just recycled) during game play - which is totally possible. For example, I can find the health address for a friendly unit, leave the area, come back, and the health address has been assigned to a different unit (meaning, the code is shifting) - even though the original unit has not been killed. Due to this fact, it may be more difficult to write out a script the way I would like. However, that being said, I have not seen the addresses being swapped between friend/foe...I have only seen this happen from one friendly unit to another friendly unit, or vice verca.
Flashacking wrote: | Well, what i wrote is just an suggestion.. I've tried making the same for a facebook game named marvel avengers alliance, I have faced the same issue as you..so decided to use hotkeys..because AI and players sharing the same IDs + theres 3 addresses for HP, and for 1 theres something different.. but for the second one theres nothing different...(and the second one being called first..)..
Anyway, good luck.
Give me the game name and I will check it out. | I understand. I appreciate your help. Thank you. The name of the game is Dynasty Warriors 6. It's the reloaded version...can be found online. The name of the file is: rld-dw6.iso
Members Psych and Wiccaan (ExTaLiA) compiled a trainer for this game a few years ago, but I have not attempted to contact them. Actually, by looking at the description of their trainer, I'd say they had a problem with Player ID as well.
Dark Byte wrote: | Perhaps the unit has a pointer to another structure that in it's turn has a pointer to the controller object, which may have a pointer to a string that contains your name, or just Player | Would I need to use the structure spider function for something like this? I've never used it before. Are there any tutorials for this feature? Thanks.
|
|
Back to top |
|
 |
Gniarf Grandmaster Cheater Supreme
Reputation: 43
Joined: 12 Mar 2012 Posts: 1285
|
Posted: Sun Mar 10, 2013 6:59 am Post subject: |
|
|
So far I've found that (in the demo):
-health is at PlayerStructure+104
-CharacterID is at PlayerStructure+C
-CharacterID for special generals is below 0x10, probably because there aren't much characters in the demo.
-CharacterID for generic generals is above 0x20, often above 0x30.
-Generic allied generals have PlayerStructure+D=1
Problem I can't sort between allied and enemy special generals. In the demo the only general I can play has CharacterID=6, some of my allies have 5 and 7 and one of the bosses has CharacterID=0. (edit: Sun Ce has ID 0x1C)
...hmm they probably might have used something like CharacterID=0 to 4 for blue (Wu?) generrals, and 5-7 for red ones (Shu?) and then would come the green (Wei) and independent ones. Gotta try that after lunch....
EDIT: that seems to work. The script below overwrites the health upon taking damage by 0 or 300k. That way you can easily tell who is invincible and who isn't. Let's hope that CharacterIDs don't change on every mission. Aside that I'd bet those IDs are NOT the same in the demo and in the full game.
Code: | define(FirstShuChar,5) //CharacterID of the first Shu (red) clan fighter
define(LastShuChar,1c) //CharacterID of the last Shu (red) clan fighter
[enable]
alloc(Cave,128)
label(ReturnHere)
label(Friendly)
label(GodMode_Hook)
label(Friendly)
label(Enemy)
label(Exit)
registersymbol(GodMode_Hook)
aobscan(GodMode_aob,80 7C 24 08 00 F3 0F 11 40 04 74 23)
//look for
/*
DW6_WIN_DEMO.EXE+F45FD - 80 7C 24 08 00 - cmp byte ptr [esp+08],00
DW6_WIN_DEMO.EXE+F4602 - F3 0F11 40 04 - movss [eax+04],xmm0 <-GodMode_Hook
DW6_WIN_DEMO.EXE+F4607 - 74 23 - je DW6_WIN_DEMO.EXE+F462C
*/
GodMode_aob+5:
GodMode_Hook:
jmp Cave
ReturnHere:
Cave:
pushfd
cmp byte [eax-100+D],1 //Am I an allied generic general/footsoldier
je Friendly
cmp byte [eax-100+C],FirstShuChar //if my CharacterID<FirstShuChar I'm not from shu->I'm your ennemy
jb short Enemy
cmp byte [eax-100+C],LastShuChar //if my CharacterID>FirstShuChar && CharacterID=<LastShuChar I'm an ally
jbe short Friendly
Enemy:
mov dword [eax+04],0 //set health to 0 for enemies (instant kill)
//movss [eax+04],xmm0 //original code
jmp short Exit
Friendly:
mov dword [eax+4],(float)300000 //300k hp for allies+self
Exit:
popfd
jmp ReturnHere
[disable]
GodMode_Hook:
movss [eax+04],xmm0
dealloc(Cave)
unregistersymbol(GodMode_Hook) |
|
|
Back to top |
|
 |
++METHOS I post too much
Reputation: 92
Joined: 29 Oct 2010 Posts: 4197
|
Posted: Sun Mar 10, 2013 1:58 pm Post subject: |
|
|
So, you're saying that there are different ID's being used based on the officer type (and) that these ID's may be located at different offsets? How did you determine this? How did you test it?
I haven't tested your script, but I wonder if you have tested the result of it. For example, whenever I try to mov 0 into health, the troops cannot be killed. I have yet to find which code/codes trigger death, and have yet to be able to create an 'automatic/instant' kill (e.g. a way to kill the troops without even hitting/interacting with them). There is an address that controls all actions/sprites, but manipulating that with the health address was not successful.
I'll take a look at your findings later to see if what you've found applies to the version that I am working with.
Thanks for your help.
|
|
Back to top |
|
 |
|
|
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
|
|