# Tutorial Read/write Memory Arma3

**URL:** <https://forum.gmstemple.com/t/tutorial-read-write-memory-arma3/13044>\
**Category:** Autres jeux\
**Created:** [Février 27, 2014, 4:52 UTC](https://forum.gmstemple.com/t/tutorial-read-write-memory-arma3/13044 "2014-02-27T04:52:31Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![erwannludovic](https://forum.gmstemple.com/user_avatar/forum.gmstemple.com/erwannludovic/32/4473_2.png) [@erwannludovic](https://forum.gmstemple.com/u/erwannludovic)\
**Post date:** [Février 27, 2014, 4:52 UTC](https://forum.gmstemple.com/t/tutorial-read-write-memory-arma3/13044/1 "2014-02-27T04:52:31Z")

</div>

**Itération des entités**   
  
  
Tout comme arma 2, arma 3 à une façon bien particulière de stocker les entités,  
Il faudra parcourir 3 "master" table qui contiennent les offsets de chacune des "Slave" table qui contiennent a leur tour les Offsets des entités.  
  
Il y a en tout 3 Master table et 4 Slave pour chacune d'entre elle, la 3émes master table comporte 2 slaves de plus   
  
La place d'une entité dans l'une ou l'autre slave/master dépends essentiellement de la distance de cette entité par rapport a vous, elles sont donc amené a être  
modifié en permanence selon vos déplacement ig.  
Cas particulier pour la master 3, qui contient des slaves qui sont réservé pour certain type d’entité, comme les "Constructions" et les entités de type nature (Bâtiment, tente, abeille, serpent etc...) mais aussi les loots générer au sol par les joueurs (qui aurait par exemple jeté leur arme)  
  
  
Offset de décalage pour atteindre les Master Table & slave table:  

```
int[] MasterTableArray = { 0x46c, 0x710, 0x9b4 };
int[] SlaveTableArray = { 0x8, 0xb0, 0x158, 0x200, 0x2a8, 0x350 } //Les deux dernières slave sont utilisée uniquement pour la master 3 

```

  
Comme pour tous les jeux, il existe une offset de base, qui nous permet d'atteindre toute les structures qui nous intéresse, en l’occurrence l’itération de nos entités, ici nous l’appelleront "GameBase".  

```
int GameBase = 0x160ED88 //Cette valeur peut varier à chaque update du jeux

```

  
Maintenant mettons en utilisations Notre GameBase Pour atteindre nos Master Table :  

```
 int MasterArray = GameBase] +0x7c4] +0x0]

```

  
Appliquons maintenant les decallages contenut dans MasterTableArray  

```
for(int i=0; i < MasterTableArray.Lenght; i++){
	CurrentMasterptr = MasterArray + MasterTableArray[i]]
}

```

  
CurrentMasterptr contient donc l'adresse de debut de chaque master.  
Nous pouvons donc maintenant nous attaquer au Slave Table de chaque master.  
Rapellez vous, les slaves table sont lié a chaque master, il faudra donc iterer chaque slave dans la boucle  
d'iteration des masters.  
Cependant je vous rapelle que nous avons declarer 6 slave, les deux derniere sont utilisé uniquement pour la master 3, il  
faudra donc sauter les deux derniere iteration des slave si l'on itere la master 1 et 2  
  

```
for(int y=0; y < SlaveTableArray.Lenght; y++)
{

	if(i < 2 && y > 3 ) continue; //Si on itere la master 1 & 2 et que l'on itere la slave 5 et 6 on saute

	CurrentSlavePtr = CurrentMasterptr + SlaveTableArray[y]]
	CurrentSlaveCount = CurrentMasterptr + SlaveTableArray[y] + 0x4]

}

```

  
Nous avons donc récupéré le CurrentslavePtr, point d'entré de notre listing d’entité ainsi que CurrentSlaveCount qui définit le nombre d'enregistrement à l’intérieur de notre CurrentSlavePtr.  
  
une fois dans notre slave nous faisons comme suit pour recuperer l'ofs de nos entitiés  

```
for(int z=0; z < CurrentSlaveCount; z++){
	EntOfs = CurrentSlavePtr + z*0x4] 
}

```

  
Et Voila on récupère un à un les Ofs de toute nos entités  
  
  
**Local entités**   
  
L’entité qui représente notre joueurs est présente dans les Master/slave mais il existe un chemin plus court pour obtenir son adresse  

```
SelfEntOfs = 0x160ED88] +0x1704] +0x4]

```

  
  
**La Struct de l'entité**   
  

> **Spoiler**
>
> ```
> int VecPosPtr; //0x68                 
> int ModelPtr; //0xd0                  
> int ModelPtr2; //0xd4                 
> int PartPtr; //0x168                  
> int PartCount; //0x16c                
> int SideId; //0x204                   
> bool IsDead; //0x2fc                  
> int ItemOlderPtr; //0x32c 
> int WeaponPtr; // 0x574
> int BackPackPtr; //0x580
> int WeaponId; // 0x5bc
> int NamePtr; //0xa10                  
> int NameId; //0xac4                   
> int DriverPtr; //0xb24
> int PassengerPtr; //0xb9c
> int PassengerCount; //0xba0
> 
> ```

  
  
VecPos Struct :  

> **Spoiler**
>
> ```
> float unkQuatA; //0x0004 
> float unkQuatB; //0x0008 
> float unkQuatC; //0x000C 
> Vec3 Up; //0x0010
> Vec3 Dir; // 0x001c
> Vec3 posA; //0x0028 
> float N1C7F0BCF; //0x0044 
> Vec3 ScriptVelocityXZY; //0x0048 
> Vec3 ScriptVelRelated; //0x0054 
> Vec3 N1C7F0BD6; //0x0060 
> Vec3 velocity; //0x007C 
> Vec3 accel; //0x0088 
> Vec3 derivaccel; //0x0094 
> Vec3 posStrange; //0x00A0 
> float fuel; //0x00AC 
> Vec3 posB; //0x0114 
> Vec3 posC; //0x0120
> Vec3 N1C843D88; //0x0228
> Vec3 posD; //0x0284
> 
> ```
> 
>   
> **Vec3 Dir** : représente la direction de l'entité  
> **Vec3 posA** : représente la position des pieds  
> **Vec3 posB** : représente la position de la tête (Uniquement valide pour les Joueurs et les AI)  
> **float fuel** : représente la quantité de fuel (uniquement pour les entités de type "véhicule")

  
  
**int ModelPtr** : Pointeur qui nous donne accé au model1name et model2name  
string model1name = ModelPtr + 0x38] + 0x8  
String model2name = ModelPtr + 0x30] + 0x8  
Pour le moment vous devrez utilisez le model1name pour déduire le type de l'entité (Humain/Ai, véhicule, lootable etc...)  
  
**"int PartPtr" et "int PartCount"** : nous donne accès a un array de float qui decrive l'état des différentes partit d'une entité cassable (ex: vehicule), si = 1 -\> complètement détruit, si 0 -\> complètement neuf (un petit coup de Write et votre véhicule est tout neuf !)  
  
**int SideId** : Représente l'id du camp de l'entité, Cette valeur change en fonction des serveurs, vous pouvez quand même l'utilisé pour retrouver les membres de votre équipe ou les membres de l'équipe adverse.  
  
**bool IsDead** : Définit si l'entité est en vie ou non.  
  
**ItemOlderPtr** : Nous donne accès au Older de l’entité (utile uniquement si l'entité peut contenir des items) (nous y reviendront)  
  
**WeaponPtr** : Nous donne accès a l'array de struct weapon (munition infinie, balle plus rapide que l’éclair, c'est ici) (nous y reviendront)  
  
**BackPackPtr** : Nous donne accès a l'ofs de l'entité qui représente notre sac a dos (même si il est sur le dos de quelqu’un le sac existe comme entité, cela nous permet donc de faire la liaison entre une entité et son sac)  
  
**WeaponId** : Nous permet de retrouver dans WeaponPtr notre arme actuelle (nous y reviendront)  
  
**NameId** : Nous permet de retrouver le Pseudo ou RealName d'une entité Joueur (nous y reviendront)  
  
**DriverPtr** : Nous donne l'ofs de l'entité qui conduit  
  
**PassengerPtr** et **PassengerCount** : Permet d'obtenir la liste des entités qui sont passager dans un véhicule  
  
  
  
**Réparé un Véhicule**   
  
vous ne pourrez réparer un véhicule uniquement que si vous êtes a la place conducteurs, et que ce dernier n'a pas explosé ;D  
La technique est relativement simple :  
- Récupérer l'ofs de votre entité  
- Itérer les entités jusqu’à ce que **DriverPtr** soit égale a l'ofs de votre self entité.  
  
Une fois cela fait, vous avez trouvé l'adresse de votre véhicule, a partir de la il vous suffit de lire **PartPtr** et **PartCount**.  
**PartPtr** est un array de float de **PartCount** éléments  

```
entOfs //Ofs de votre véhicule

int PartPtr = entOfs + 0x168]
int PartCount = entOfs + 0x16c]

for(int i=0; i < PartCount){
     Write(Part + i*0x4, 1f)
}

```

  
Et voila votre véhicule est tout neuf !!!!  
  
  
**Itération des olders**   
  
Un older est un conteneur, une entité qui peut contenir un ou plusieurs item (par exemple un véhicule a un Older car il peut contenir des items)  
Toute entités pouvant contenir des items peut être définit comme possédant un Older  
  
Un Older est une structure qui contient 8 informations dont nous avons besoin, 4 pointer qui nous permette d'obtenir le nom des objets classé par type, ainsi que le count respectif de chaqu'un d'entre eux  
  
Pour l'instant, nous avons recensé 4 type d'item :  
- Arme  
- Consommable (Ammo, food, water etc...)  
- Tool (GPS, map, toolbox etc)  
- BackPack (sac a dos)  
  
Chaque type d'item est regroupé et est stocké dans un tableau d'item différent, dans un older nous avons donc 4 tableau et leur count associé  
  
  
**OlderWeapon** :  

```
ItemOlderPtr //Valeur de L'ItemOlderPtr de la current entité

WeaponOlderPtr = ItemOlderPtr + 0x28]
WeaponOlderCount = ItemOlderPtr + 0x2c] 

for(int i=0; i < WeaponOlderCount; i++){
  CurrentWeaponOlder = WeaponOlderPtr + 0x4 * i] + 0x28] + 0x1c]
  string CurrentWeaponName = CurrentWeaponOlder + 0x8]
}

```

  
**OlderConsomable** :  

```
ItemOlderPtr //Valeur de L'ItemOlderPtr de la current entité

ConsomableOlderPtr = ItemOlderPtr + 0x44]
ConsomableOlderCount = ItemOlderPtr + 0x48] 

for(int i=0; i < ConsomableOlderCount; i++){
  CurrentConsomableOlder = ConsomableOlderPtr + 0x4 * i] + 0x28]
  string CurrentConsomableName = CurrentConsomableOlder + 0x8]
}

```

  
**OlderTool** :  

```
ItemOlderPtr //Valeur de L'ItemOlderPtr de la current entité

ToolOlderPtr = ItemOlderPtr + 0x34]
ToolOlderCount = ItemOlderPtr + 0x38] 

for(int i=0; i < ToolOlderCount; i++){
  CurrentToolOlder = ToolOlderPtr + 0x4 * i] + 0x20] +0x18]
  string CurrentToolName = CurrentToolOlder + 0x8]
}

```

  
**OlderBackPack** :  

```
ItemOlderPtr //Valeur de L'ItemOlderPtr de la current entité

OlderBackPackOlderPtr = ItemOlderPtr + 0x70]
OlderBackPackOlderCount = ItemOlderPtr + 0x74] 

for(int i=0; i < BackPackOlderCount; i++){
  CurrentBackPackOlder = BackPackOlderPtr + 0x4 * i] + 0xD0] +0x30]
  string CurrentBackPackName = CurrentBackPackOlder + 0x8]
}

```

  
  
**Munition Infinie & Vélocité**   
  
Cette opération s'effectue sur notre entité, il faut avoir une arme, et avoir ou déjà posséder des balles depuis que l'arme est en main.  
Nous allons intervenir sur la quantité de balle se trouvant dans le chargeur en cours d'utilisation, si vous ramassez une arme sans balle, le chargeur de l'arme ne sera pas initialiser en mémoire, il nous sera donc impossible d’écrire la quantité de balle que nous souhaitons.  
La quantité de balle est gérer par un système de XOR entre deux valeur, si l'une d'elle ne correspond pas a la deuxième valeur vous vous retrouverez sans munition ;D  
  
Pour récupérer l'offset qui nous intéresse nous allons avoir besoin de **WeaponPtr** et **WeaponID** de l'entité qui représente notre joueur  
  
Nous allons dans un premier temps récupérer le maximum de munition que peut accueillir notre chargeur puis l’écrire en mémoire dans notre chargeur  

```

int WeaponPtr = WeaponPtr + (WeaponID * 0x30) + 0c]
int MaxMagCap = WeaponPtr + 0x34] + 0x40]

int garbadge1Ofs = WeaponPtr + 0x38
int garbadge2Ofs = WeaponPtr + 0x58
int VelocityOfs = WeaponPtr + 0x34] + 0x48

int Garbadge1 = (int)(MaxMagCap ^ 0xBABAC8B6) << 1
int Garbadge2 = (int)(MaxMagCap ^ 0xBABAC8B6) - Garbadge1

Write(garbadge1Ofs, Garbadge1)
Write(garbadge2Ofs, Garbadge2)
Write(VelocityOfs, 99999f) //Vélocité à 99999 

```

  
  
**RealName / Pseudo**   
  
Lorsque vous itérer une entité de type joueur, vous n'avez pas dans la structure les informations nécessaire pour savoir comment ce dernier s’appelle.  
Il existe un système de scoreboard qui contient les pseudo ainsi qu'un identifiant unique lié, le nameId, nous allons donc utiliser le nameID contenus dans l'entité pour la lié a un pseudo  
  
La struct de type ScoreBoard contient :  

```
int NameId; //0x4
int ptrSteamId; //0xc
int ptrName; //0xa8

```

  
Itérer le ScoreBoardArray:  

```
ScoreBoardArrayPtr = 0x15FD8B4] + 0x18]
ScoreBoardArrayCount = 0x15FD8B4] + 0x1c]

for(int i=0; i < ScoreBoardArrayCount; i++){

String NickName = ScoreBoardArrayPtr + (i*0x120)] + 0xa8] + 0x8]
int NameID = ScoreBoardArrayPtr + (i*0x120)] + 0x4]

}

```

  
  
**A venir**   
  
- World to Screen
