Documentation

Tutorial

ADRESSAGE DAT MOV ADD SUB MUL DIV MOD MIN JMP JMZ JMG DJZ CMP FORK KILL RND

Comment comprendre le tutorial ?

Tout d'abord, pour bien comprendre les instructions, il faut déjà apprendre tout les modes d'adressages.
Pour cela, nous avons essayons de vous rendre le plus clair possible toutes les instructions possibles. Dans tout le long du tutorial, nous avons utilisé la syntaxe suivante :
En bleu, tout ce qui a été modifié par l'instruction en cours.
-> indique la position de l'instruction courante.
*a* indique l'état de la case mémoire 'a' après l'exécution de l'instruction courante.
Et très important, la case de destination sera toujours la case pointée par le second argument.

Rq: seule la première instruction est testé. Toutes les autres ne servent qu'à illustrer son action.

Adressage

Relatif : ($)

Cela désigne une adresse relative à l'adresse courante. Exemple: 1 représente l'adresse qui suit l'adresse courante et -1 l'adresse qui précède l'adresse courante. Généralisons ce résultat, nous obtenons ainsi :

Relatif indirect : (@)

Désigne une case contenant une adresse. Exemple: @1 indique que la case suivant (1) contient l'adresse relative désirée. Généralisons ce cas comme précédemment :
Ici, @b pointe la case d'adresse a+b+c.

Rq: ici le % doit être remplacé un mode d'adressage quelconque, soit :#, $ ou @ .
De plus, pour la case contenant l'adresse désirée (dans l'exemple ci-dessus: la case a+b), on se sert toujours du second argument pour trouver l'adresse désirée.
Par exemple :

Dat (1 coup d'horloge)

Rq: ces cases peuvent egalement servir à stocker des variables.

MOV (1 coup d'horloge)

L'instruction MOV a deux significations :
1/ Si le type du premier argument est immédiat (#), l'instruction MOV crée un DAT (ce qui peut tué un processus). Par exemple :

2/ Si le type du premier argument n'est pas immédiat (relatif ou relatif indirect), l'instruction MOV recopie la case pointée par le premier argument sur la case pointée par le deuxième argument. Par exemple :

ADD (1 coup d'horloge)

L'instruction ADD a également deux significations :
1/ Si le type du premier argument est immédiat (#), l'instruction ADD ajoute aux 2 arguments de la case de destination (case pointée par le second argument) la valeur du premier argument. Par exemple :

2/ Si le type du premier argument n'est pas immédiat (relatif ou relatif indirect), l'instruction ADD ajoute à la case de destination la case pointée par le premier argument terme à terme. Par exemple :

SUB (1 coup d'horloge)

L'instruction SUB marche de la même manière que ADD, donc on ne va pas s'attarder dessus. La seule différence c'est que celle ci soustraie au lieu d'ajouter.

MUL (1 coup d'horloge)

L'instruction MUL marche de la même manière que ADD, donc on ne va pas s'attarder dessus. La seule différence c'est que celle ci multiplie au lieu d'ajouter.

DIV (1 coup d'horloge)

L'instruction DIV marche de la même manière que ADD, donc on ne va pas s'attarder dessus. Les différences sont que celle ci divise au lieu d'ajouter et que en cas de division par 0 le programme est tué.

MOD (1 coup d'horloge)

L'instruction MOD marche de la même manière que ADD, donc on ne va pas s'attarder dessus. La seule différence c'est que celle ci fait le modulo (reste de la division euclidienne).

MIN (1 coup d'horloge)

Cette instruction retourne l'opposé de chaque argument de la case pointée par le premier argument. Par exemple :

JMP (1 coup d'horloge)

Cette instruction indique au processus de sauter sur la case pointée par le premier argument, au lieu que le processus n'exécute la prochaine instruction. Par exemple :

JMZ (1 coup d'horloge)

L'instruction JMZ permet de faire sauter le processus comme l'instruction JMP mais celle-ci ajoute une condition pour sauter. Plus exactement, le processus sautera sur la case pointée par le second argument seulement si la case pointée par le premier a ses deux arguments nuls. Prenons deux exemples pour illustrer cette instruction :

JMG (1 coup d'horloge)

L'instruction JMG permet de faire sauter le processus comme l'instruction JMP mais celle-ci ajoute une condition pour sauter. Plus exactement, le processus sautera sur la case pointée par le second argument seulement si la case pointée par le premier a ses deux arguments > 0. Prenons deux exemples pour illustrer cette instruction :

DJZ (2 coups d'horloge)

Cette instruction décrémente les deux arguments de la case pointée par le premier argument. Puis si le résultat est nul, alors on saute sur la case pointée par le deuxième argument. C'est donc pourquoi cette instruction prend deux coups d'horloge. Illustrons cette instruction par deux exemples :

CMP (1 coup d'horloge)

Cette instruction s'utilise de deux manières différentes :
1/ Si le type du premier argument est immédiat (#), l'instruction CMP compare le premier argument avec les deux arguments de la case pointée par le deuxième arguments. Si ceux-ci sont égaux alors le processus continu son train train habituelle sinon il saute la case suivante pour se trouver sur la case 2. Par exemple :

2/ Si le type du premier argument est n'est pas immédiat (relatif ou relatif indirect), l'instruction CMP compare la case pointée par le premier argument avec la case pointée par le deuxième arguments. Si ceux-ci sont égaux (type d'adressage inclus) alors le processus continu son train train habituelle sinon il saute la case suivante pour se trouver sur la case 2. Par exemple :

FORK (12 coups d'horloge)

Pour moi, cette instruction est sans doute la plus importante de toute car celle ci permet au guerrier de se multiplié et donc de prendre un grand avantage sur d'autres. Plus exactement cette instruction crée un nouveau processus sur la case 1 et l'ancien saute sur la case pointée par le premier argument. Par contre, cette instruction met 12 coups d'horloge ce qui compense bien son efficacité. Prenons l'exemple ci-dessous :

Remarque : le simulateur n'accepte que 64 processus au maximum donc les instructions qui suivront ne feront que perdre du temps au processus. Cette limitation est importante car on est vite débordé par le nombre de processus.

KILL (36 coups d'horloge)

Cette instruction est la deuxième plus importante de toutes car celle-ci tue au bout de 36 coups d'horloge un processus au hasard sauf lui-même. Donc, rien n'empêche à cette instruction de tuer un processus appartenant au même joueur.

RND (1 coup d'horloge)

Cette instruction envoie un DAT #a,#a sur la case pointée par le deuxième argument. De plus, a est un nombre choisi aléatoirement entre 0 et la valeur du premier argument - 1. Par exemple :

Remarque : le type d'adressage du premier argument peut être quelconque.