Core Warrior - Core Warrior

Core Warrior est un environnement de développement pour Core War écrit en Java (100 %, n'en déplaise à Bill), il peut donc fonctionner sur toute plateforme munie d'une machine virtuelle Java 1.1 (donc Linux, Windows, Macintosh, Solaris, etc...). Il comporte un éditeur, un compilateur et une machine virtuelle Core War. Le compilateur et la machine virtuelle peuvent être utilisés en mode graphique ou en ligne de commande.

Permet d'éditer le Red Code et de lancer, sans sortir de l'EDI, le compilateur et la machine virtuelle (le moteur Red Code).

Figure 2: Editeur

Permet de créer un nouveau document, d'ouvrir un programme existant, d'enregistrer le programme en cours d'édition, de l'enregistrer sous un autre nom et de quitter le programme. Les fichiers des programmes Red Code ont l'extension .src.

Permet de couper, copier, coller et rechercher une chaîne dans le code.

Permet de compiler le programme en cours d'édition et de l'exécuter dans le moteur. Les fichiers compilés ont le même nom que le fichier source du programme, avec une extension .bin. Les fichiers compilés sont indépendants de la plateforme et peuvent donc être copiés d'un ordinateur à un autre (même de système différent) sans avoir à les recompiler.

Permet d'afficher une aide rapide sur le langage Red Code (résumant les différentes instructions du langage et les modes d'adressage). Il permet aussi d'afficher la boite de configuration de la fonte et des couleurs de l'éditeur (désolé, je ne savais pas trop où caser cette option).

Les icônes de la barre sous le menu sont des raccourcis pour les principales fonctions de l'EDI.

Je pense que ces fonctions sont suffisamment explicites pour se passer d'explications plus poussées.

Le moteur de Core Warrior est l'arène des combats de programmes. On peut y tester des programmes en cours de développement dans l'éditeur (le moteur est alors invoqué à partir de l'éditeur et le programme en cours est automatiquement chargé). On peut aussi le lancer indépendemment de l'éditeur pour faire un combat entre deux programmes.

Figure 3: Moteur

Pour faire tourner des programmes, il faut commencer par les charger. Pour ce faire, cliquer sur le bouton [Charger] et sélectionner le programme désiré (les programmes chargés doivent être compilés, donc avec une extension .bin). Le programme est alors affiché dans la fenêtre de core dump. On peut enlever un programme chargé avec le bouton [Purger].

Lorsque les programmes ont été chargés, il faut les installer dans le core (l'arène de combat). Cliquer sur le bouton [Installer]. Il apparaît alors la fenêtre suivante :

Figure 4: Installer un programme

Cette boite de dialogue permet de choisir l'adresse où l'on doit installer chaque programme. On peut aussi les installer aléatoirement (c'est l'option à choisir pour des combats ordinaires).

La distance minimale est celle séparant deux programmes (utile lorsqu'on choisit une installation à des adresses aléatoires).

Cycles avant nul indique le nombre de cycles avant que la partie soit déclarée nulle si aucun programme n'a planté. Une valeur de 1.000.000 peut sembler démesurée, mais la puissance des machines actuelles le permet amplement.

Après avoir cliqué sur [OK], les programmes apparaissent dans la représentation graphique du core. Le programme vert est représenté par des cases vertes, et le rouge par des cases rouges (original, je sais...).

Pour exécuter les programmes, il y a 2 méthodes :

1. Pas à pas : Cliquer sur la flèche bleue dans la barre du haut. Une instruction du programme ayant le trait est exécutée. Cette instruction est surlignée en noir dans la barre de core dump. L'adresse de la prochaine instruction à exécuter est indiquée dans le champ de texte IP (pour "Instruction Pointer", un registre des processeurs x86). Le programme ayant le trait a un feu de couleur verte, celui ne l'ayant pas par un feu rouge.
2. En continu : Il faut alors cliquer sur la double flèche verte. On peut alors arrêter le programme en cliquant sur la double barre orange ou désinstaller les programmes du core par un clic sur le carré rouge. On peut lancer les programmes avec 3 modes (que l'on peut choisir avec les cases à cocher de la barre du haut) :
• Debug : les instructions sont alors tracées dans la fenêtre de core dump et sur le core. C'est le mode le plus lent, mais aussi le plus intéressant à suivre.
• Trace : les instructions ne sont tracées que sur le core.
• Turbo : aucune représentation graphique des programmes en cours d'exécution n'est proposée, mais ce mode est de loin le plus rapide.

Le champ de texte temps indique le temps entre chaque instruction. Il faut l'adapter à la vitesse de sa configuration de manière à ce que le rafraîchissement graphique de la fenêtre de core puisse se faire entre deux instructions. Si le temps est trop court, plusieurs instructions sont tracées en même temps sur le core, ce qui donne un affichage saccadé. N'est pas pris en compte pour le mode turbo.

Afin de satisfaire les Ayatollahs de la ligne de commande, le compilateur et le moteur peuvent être invoqués en ligne de commande. L'intérêt est d'automatiser des tournois pour lesquels un grand nombre de matchs est nécessaire.

Il faut se placer dans le répertoire du programme et taper en ligne de commande :

$ java casa.corewarrior.compilateur.Compilateur fichier.src

L'archive du programme (bin.jar) doit se trouver dans le CLASSPATH du programme.

Où fichier.src est le nom du fichier à compiler. Le programme compilé sera placé dans le fichier fichier.bin du même répertoire.

Il faut noter que si une erreur de compilation se produit, le fichier binaire est tout de même écrit (jusqu'à l'instruction ayant provoqué l'erreur de compilation).

On lance le moteur en mode texte en tapant sur la ligne de commande (dans le répertoire du programme) :

$ java casa.corewarrior.moteur.Moteur -option prog1.bin prog2.bin

L'archive du programme (bin.jar) doit se trouver dans le CLASSPATH du programme.

Les options disponibles sont :

• trace : trace l'exécution des programmes.
• état : affiche un core dump des programmes à l'issu du combat.

Les programmes sont chargés aléatoirement en mémoire et peuvent être plus de deux (on peut ainsi organiser des combats entre 10 programmes simultanément :).

Les fichiers binaires générés sont constitués d'une suite d'instructions de 4 octets chacune. Une instruction a le format suivant :

• Instruction : codée sur 4 bits (ce qui laisse 16 possibilités dont 9 sont utilisées). Les codes sont les suivants : DAT=0, MOV=1, ADD=2, SUB=3, JMP=4, JMZ=5, JMG=6, DJZ=7, CMP=8.
• Premier argument : composé
• du mode d'adressage sur 2 bits (immédiat=0, relatif=1 et indirect=2).
• de la valeur sur 12 bits (soit possibilité d'adresser 4096 cases mémoire).
• Deuxième argument : comme le premier.

J'ai choisi de coder la valeur de l'argument sur 12 bits de manière à avoir un terrain de jeu le plus vaste possible. De plus, 4096 cases sont représentables par un carré, ce qui colle mieux avec une représentation graphique du core.