Les jeux de Silmarils (Robinson's Requiem, Ishar, Transarctica, Targhan…) sont des programmes pour une machine virtuelle, ALIS. Chaque fichier .io d'un jeu est un script compilé : du code octet, les variables qu'il réserve et ses ressources (images, sons, modèles 3D). Ce document décrit le langage source dans lequel le port PHP écrit ces scripts, et que le moteur sait compiler et exécuter.
Le code source original de Silmarils n'a jamais été publié : on ne connaît ni sa syntaxe exacte ni le nom de ses variables. On connaît en revanche :
cput, cscmov, cfopen…) et de chaque élément d'expression (oimmb, olocw, oadd…), qui viennent de la machine elle-même ;si … alors … sinon et tant que toujours de la même façon.Le langage ci-dessous reprend ces noms et ces structures. Le but : un texte qu'un humain lit et modifie, et qui redonne octet pour octet le script d'origine quand on n'y touche pas. Les 109 scripts de Robinson's Requiem (46 886 lignes) font l'aller-retour à l'identique, et le jeu lancé depuis les sources affiche exactement les mêmes images que l'original.
| Commande | Rôle |
|---|---|
bin/jumphp php games/alis tools/lang/decompile.php <données> <sortie> | décompile tous les .io d'un jeu en <nom>.als (le source) + <nom>.res (les ressources), puis recompile chaque source et vérifie qu'on retrouve les mêmes octets |
bin/jumphp php games/alis tools/run.php <données> … --source | lance le jeu depuis <données>/src/*.als (partie sans fenêtre, images dans var/) |
bin/jumphp php games/alis tools/lang/check.php <run> | compare la grammaire à une vraie partie : la longueur de chaque instruction exécutée (trace de tools/run.php) |
bin/jumphp php games/alis tools/lang/reference.php | régénère les tables de référence en fin de ce document |
Le code : src/Alis/Lang/ — Grammar.php (les opérandes de chaque instruction, relevés dans les fonctions de la machine), Decoder.php (code octet → instructions), Printer.php (instructions → source), Assembler.php (source → code octet), Script.php (en-tête, code, ressources).
Quand un jeu a les sources de ses scripts (data/<jeu>/src/*.als + *.res, ou leur liste dans catalog/<jeu>.json), l'écran d'accueil propose, en plus du jeu original :
<jeu> - ALIS sources : chaque script est compilé depuis son source au moment où la machine le charge (sys_source_io() dans fn/sys.php). Modifier un .als change donc le jeu, sans autre outil ;<jeu> HD : la même chose, avec le rendu haute définition : l'image agrandie par le GPU en pixels nets, les textes du jeu redessinés avec une vraie police à la résolution de l'écran (fn/hd.php) et la 3D rendue une seconde fois à deux fois la résolution par le moteur 3D d'origine (fn/hd3d.php).Une erreur dans un source arrête le jeu avec un message qui donne le fichier et la ligne (ALIS source main.als, line 120: …). Dans le navigateur, les sources sont téléchargées à la demande, comme les films (fichiers privés lazy/<jeu>/<nom>.als), et compilées dans la page.
Les sources viennent des données du jeu : comme elles, elles restent privées (jamais dans le dépôt public).
Pour modifier un script sans outil extérieur, l'écran d'accueil propose aussi <jeu> - ALIS EDITOR : l'éditeur ALIS (coloration, recherche, compilation avec la ligne de l'erreur, lancement du jeu modifié par F5). Il est décrit dans editor.md. Les scripts modifiés sont gardés dans les fichiers du joueur et servent aux éditions « ALIS sources » et « HD ».
.als// commentaire jusqu'à la fin de la ligne
script "authors" // nom du script
id 0x0047 // numéro du script (cload, clive…)
class 0x00 0x1e // deux octets d'en-tête
memory 0x0020 0x3d02 0x0020 // tailles : variables, mémoire de l'entité, ...
pack 0xa0 // octet de compression du .io d'origine (0 = non compressé)
specs hex"…" // script principal seulement : les 16 octets de configuration de la machine
resources "authors.res" // les ressources (images, sons, 3D), en binaire, à côté du source
main L0018 // point d'entrée
before L023d // facultatif : code exécuté avant chaque tour du script
after L4b5f // facultatif : code exécuté après chaque tour
L0018: // une étiquette
screen 82
…
Une instruction par ligne, une étiquette (nom:) en début de ligne. Les étiquettes produites par le décompilateur s'appellent L + l'offset de l'instruction dans le script (L023d), mais n'importe quel nom convient.
La machine n'a pas de noms de variables, seulement des adresses. Un script réserve ses variables dans la mémoire de son entité (une instance du script) ; le script principal a les siennes, que tous voient.
| Écriture | Ce que c'est |
|---|---|
vb[0x52] vw[0x52] vs[0x52] | octet, mot (16 bits), chaîne de l'entité, à l'offset 0x52 |
tb[0x40](i) tw[…](i, j) ts[…](i) | case d'un tableau d'octets, de mots, de chaînes de l'entité (indices entre parenthèses) |
to[0x40](i) | l'adresse d'une case de tableau de chaînes |
mb[…] mw[…] ms[…] mtb[…](i) mtw[…](i) mts[…](i) | les mêmes, dans les variables du script principal |
hb[0x54, 0x4c] hw[…] hs[…] hts[…](i) | variable d'une autre entité : son numéro est dans le mot vw[0x54], la variable est à l'offset 0x4c chez elle |
&v[0xe5e] &m[0xe5e] | une adresse (de l'entité, du script principal), pour les instructions qui reçoivent un tableau entier |
Les offsets de 0 à 255 de l'entité s'adressent sur un octet (odir…), les autres sur deux (oloc…) : le compilateur choisissait seul, le langage aussi. vb:loc[0x12] force la forme longue (jamais vue dans Robinson).
Les tableaux se déclarent par dim (offset, compteur de dimensions, taille d'une case, puis les tailles) :
dim 0xe5e, 0xc1, 0x02, [512, 262144]
Une expression est une suite de valeurs et d'opérateurs évalués de gauche à droite, sans priorité, comme la machine les calcule :
vw[0xb6] = mw[0xe82] - 15 / 30 * 2 // ((mw[0xe82] - 15) / 30) * 2
| Écriture | Sens |
|---|---|
12, -3, 0x40 | nombres (sur 8, 16 ou 32 bits selon leur taille ; 5:16 force 16 bits) |
"TEXTE" | chaîne (les lettres accentuées sont celles de la page de code 437 du DOS : "ÜBERLEBENSKÜNSTLER") |
+ - * / % | opérations sur les nombres |
& | ^ eqv | et, ou, ou exclusif, équivalence (bit à bit) |
== != < > <= >= | comparaisons (vrai = -1, faux = 0) |
$+ $== $!= $< $> $<= $>= | concaténation et comparaisons de chaînes |
abs(x) neg(x) rnd(n) not(x) left(…) … | fonctions de la valeur courante |
inkey() shiftkey() scan() getkey() config() … | fonctions qui donnent une valeur (clavier, machine) |
( … ) | une sous-expression (l'élément oeval de la machine) |
a op [b] | a op b quand b est elle-même une expression : le compilateur range a sur la pile, calcule b, puis combine |
L'opérateur de droite d'une opération est une seule valeur : a + b * c vaut (a + b) * c. Pour un calcul à droite, le compilateur d'origine écrivait la pile, que le langage note entre crochets :
if mw[0xe82] > 5 & [mw[0xe84] < 198] & [mw[0xe82] < 83] { // (x > 5) et (y < 198) et (x < 83)
vb[0x65] = 17 + [hw[0x56, 0x10] - vw[0x10]] // 17 + (hw - vw)
La pile elle-même s'écrit aussi en clair quand le code ne suit pas ce modèle : push y range la valeur courante, pile() la reprend, ; sépare deux valeurs qui se suivent, et une virgule entre parenthèses vaut push (tw[0x40](i, j) = i, push, j, puis la case).
Affectations
vw[0x10] = 0
vw[0x10] += 1 // cadd
vw[0x10] -= vb[0x52] // csub
tb[0x40](vw[0x10] % 4) = rnd(16)
eval inkey() // calcule sans ranger (la valeur sert à l'instruction suivante)
Blocs — le décompilateur les reconnaît dans les sauts du compilateur, et ils se recompilent en ces mêmes sauts :
if vb[0x3c9f] > 0 {
vb[0x3c9f] -= 1
} else {
protect -1
}
while hb[0x52, 0x4d] != 98 & [hb[0x52, 0x4d] != 99] {
…
}
Sauts (les étiquettes peuvent être n'importe où, même dans un bloc)
| Écriture | Sens |
|---|---|
goto L | aller à L |
if expr goto L / ifnot expr goto L | si l'expression est vraie / fausse |
ifz goto L ifnz goto L | selon la dernière valeur calculée (nulle / non nulle) |
ifeq goto L ifne goto L | si les deux dernières valeurs calculées (registres d7 et d6) sont égales / différentes |
call L … ret | sous-programme |
start L | démarre une séquence (le script y reprend au tour suivant) |
loop vb[0x30] goto L | retire 1 à la variable et va à L tant qu'elle n'est pas nulle |
stop | fin du tour du script : il reprend à la ligne suivante au prochain tour |
switch expr … case 3 goto L … end | aiguillage sur des valeurs |
table expr, base … goto L … end | aiguillage par index (expr + base = 0, 1, 2…) |
Le compilateur d'origine donnait 24 bits aux sauts vers l'avant (il ne connaissait pas encore leur cible) et la plus petite taille possible aux sauts vers l'arrière. Le langage fait de même ; un saut qui s'en écarte porte sa taille (goto.16 L), ce qui n'arrive dans aucun script de Robinson.
Les autres instructions s'écrivent avec le nom de la machine sans son c initial, suivi de leurs opérandes : put 3, scmov 0, 0, 10, openfilm 8, "death.dat", 300, 4, vw[0x3ce0], walkmap &m[0xe5e], 4, 0, 0, mw[0x1a92]. La table complète est plus bas. Celles qui ont une forme à elles :
load 18, "foret.io" // charge un script (son numéro, son fichier)
load vs[0x5c] // … ou un nom calculé
fopen z"save.sav", 3 // ouvre un fichier (nom littéral, mode) …
fopen vs[0x40], 3 // … ou calculé
send vw[0x54], 1, 2 // envoie des valeurs à une entité
defvect hex"…" // table de vecteurs (3 octets chacun)
defsc 82, 64, hex"…" // définit un écran (32 octets de description)
data hex"0a200000" // octets bruts (ce que le décompilateur n'a pas su lire comme du code)
// dead code marque le code qu'aucun chemin n'atteint (un saut laissé par le compilateur après une boucle) : il est gardé tel quel.
<nom>.res contient tout ce qui suit le code dans le script : le répertoire des ressources (offset 0x0e de l'en-tête) puis les images, palettes, sons et modèles 3D, tels que la machine les lit. Le fichier est binaire ; le remplacer change les ressources du script (attention : les offsets internes du répertoire doivent rester justes).
La grammaire (Grammar.php) vient de la lecture de chaque fonction de la machine : ce qu'elle lit après son code d'instruction. Elle a été vérifiée de trois façons :
1. l'aller-retour : les 109 scripts de Robinson's Requiem décompilés puis recompilés donnent les mêmes octets ; 2. la trace d'une vraie partie (tools/lang/check.php) : pour chaque instruction exécutée, la longueur que prévoit la grammaire est celle que la machine a lue ; 3. le jeu depuis les sources : mêmes images que le jeu original (test testTheSourceEditionPlaysLikeTheOriginalScripts).
Quelques instructions de la machine lisent un nombre d'opérandes qui dépend de l'exécution (par exemple czap saute son 5e opérande quand la durée est nulle) : le décompilateur suit ce que le compilateur écrivait (pas de 5e opérande après la constante 0). Le langage décrit ici est celui des scripts des versions 2x et 3x de la machine, au format PC (petit-boutiste) ; les versions 1.0 et 6 (Deus, Robinson 3DO) ont d'autres en-têtes et quelques instructions différentes.
Le langage décrit plus haut reprend les mots de la machine (putnat, vb[0x52]) : exact, mais personne n'a jamais écrit Robinson's Requiem ainsi. Le format 90 est le même script tel qu'un développeur de Silmarils aurait pu l'écrire au milieu des années 90 dans un langage maison : des mots français, des variables déclarées et nommées, des blocs si … alors … sinon … finsi, les nombres hexadécimaux en $52 (comme sur Atari et Amiga), := pour ranger une valeur, = et <> pour comparer.
module "flags"
numero $0081
ressources "flags.res"
depart proc_0018
apres proc_01e8
variables
global octet langue @ $e68
local mot mot_54 @ $54
local octet vague @ $52
fin_variables
proc_0018:
bascule_ecrans
forme_souris 1
place_naturel 0, 10, 0, 3, 0
fin_tour
vers_palette 0, 30
et_0049:
place_naturel 108, 0, 137, 5 + vague, 1
si mot_54 alors
appel proc_010d
finsi
table touche(), -187
aller et_00b0
…
fin
et_00b0:
langue := 0
Les deux formats sont le même programme. La traduction se fait mot pour mot dans les deux sens (App\Alis\Lang\Human) : chaque instruction, fonction, mot de contrôle et variable a un seul équivalent, donc un script passé au format 90 puis revenu au format machine est identique, caractère pour caractère, et se compile en les mêmes octets. C'est vérifié sur les 109 scripts de Robinson's Requiem (bin/jumphp php games/alis tools/lang/human.php <sources> [dossier de sortie]). Le moteur compile les deux formats (un fichier qui commence par module est au format 90) ; une erreur donne la ligne du fichier tel qu'il est écrit. L'éditeur montre le format 90 et passe à l'autre par F2 (editor.md).
Les variables se déclarent entre variables et fin_variables, une par ligne : <portée> <type> <nom> @ <adresse>.
| Déclaration | Format machine |
|---|---|
local octet nom @ $52 / local mot … / local texte … | vb[0x52] / vw[…] / vs[…] |
local tableau octets nom @ $40, puis nom(i) | tb[0x40](i) (de même tableau mots, tableau textes) |
local adresses textes nom @ $40 | to[0x40] |
global octet nom @ $e82 … | mb[0xe82] … (les variables du script principal) |
champ octet nom @ $4c, puis entite->nom | hb[0x54, 0x4c] quand entite est le mot vw[0x54] |
local zone nom @ $e5e, puis @nom | &v[0xe5e] (global zone : &m[…]) |
Le décompilateur ne connaît pas les noms d'origine : il nomme chaque variable par son type et son adresse (octet_52, g_mot_e82), sauf celles dont la lecture des scripts a montré le rôle (souris_x, souris_y, touche_lue, etat_manette, bouton, allure, objet_tenu, langue, direction…, table KNOWN de Human.php). Renommer une variable dans sa déclaration et partout où elle sert garde le même programme.
Les étiquettes s'appellent proc_0049 (un sous-programme : appelé, lancé ou point d'entrée) ou et_0049. Les opérateurs : := (ranger), += -=, = <> < > <= >=, + - * /, mod, et ou oux equ (bit à bit), $+ $= $<> … sur les chaînes ; les crochets [ … ] et ( … ) gardent leur sens.
| Format 90 | Machine | Format 90 | Machine | Format 90 | Machine |
|---|---|---|---|---|---|
si | if | boucle | loop | si_egal | ifeq |
saufsi | ifnot | selon | switch | si_different | ifne |
tantque | while | cas | case | retour | ret |
aller | goto | fin | end | donnees | data |
appel | call | si_nul | ifz | alors … finsi / faire … fintantque | { … } |
sequence | start | si_non_nul | ifnz | sinon | } else { |
| Format 90 | Machine | Format 90 | Machine | Format 90 | Machine |
|---|---|---|---|---|---|
module | script | compression | pack | avant | before |
numero | id | controle | check | apres | after |
classe | class | ressources | resources | ||
memoire | memory | depart | main |
| Format 90 | Machine | Format 90 | Machine | Format 90 | Machine |
|---|---|---|---|---|---|
touche | inkey | memoire_libre | free | fichier_existe | existf |
touches_mode | shiftkey | modele | model | changement | change |
attend_touche | getkey | gauche | left | pays | country |
manette | joy | droite | right | lit_texte | gettext |
touche_enfoncee | keyon | milieu | mid | empile | push |
manette_touche | joykey | longueur | len | depile | pile |
hasard | rnd | code | asc | empile_texte | spush |
hasard_p | prnd | caractere | chr | depile_texte | spile |
signe | sgn | en_texte | str | rien_v | pnul |
non | not | en_nombre | val | fin_calcul | fin |
| Format 90 | Machine | Format 90 | Machine | Format 90 | Machine |
|---|---|---|---|---|---|
rien | nul | lit_valeur | freadv | bouge_couleur | movcolor |
point_arret | breakpt | ecrit_valeur | fwritev | vers_palette | topalet |
calcule | eval | ecrit_entier | fwritei | place_numero | numput |
multiplie | mul | lit_bloc | freadb | ecran_centre | scheart |
divise | div | ecrit_bloc | fwriteb | ecran_position | scpos |
affiche_valeur | vprint | point | plot | ecran_taille | scsize |
affiche_texte_i | sprinti | trace | draw | ecran_horizontal | schoriz |
affiche_texte | sprinta | cadre | box | ecran_vertical | scvertic |
position_texte | locate | cadre_plein | boxf | ecran_reduit | screduce |
tabulation | tab | encre | ink | ecran_echelle | scscale |
dimension | dim | crayon_place | pset | reduction | reducing |
graine_hasard | random | crayon_deplace | pmove | ecran_carte | scmap |
quitte | leave | crayon_mode | pmode | ecran_copie | scdump |
protege | protect | image | picture | cherche_classe | findcla |
endors | asleep | defilement | xyscroll | classe_proche | nearcla |
horloge | clock | lie | linking | classe_vue | viewcla |
anime | anim | souris_on | mouson | instrument | instru |
ecran_deplace | scmov | souris_off | mousoff | instrument_m | minstru |
ecran_place | scset | lit_souris | mouse | ordre_sprites | ordspr |
decoupe | clipping | forme_souris | defmouse | aligne | align |
bascule_ecrans | switching | place_souris | setmouse | fond_etoiles | backstar |
lance_attend | wlive | definit_vecteurs | defvect | etoiles | starring |
decharge | unload | vecteurs | setvect | moteur | engine |
reveille | wakeup | rien2 | nul2 | base_auto | autobase |
dort | sleep | approche | approach | qualite | quality |
lance | live | echappe | escape | sprite_h | hsprite |
tue | kill | teste_deplace_v | vtstmov | choisit_palette | selpalet |
fin_tour | stop | teste_deplace_vf | vftstmov | palette_ligne | linepalet |
fin_tour_retour | stopret | deplace_v | vmov | mode_auto | automode |
termine | exit | definit_monde | defworld | fichier_auto | autofile |
charge | load | monde | world | annule | cancel |
definit_ecran | defsc | cherche_matiere | findmat | annule_tout | cancall |
ecran | screen | cherche_type | findtyp | annule_entite | cancen |
place | put | musique | music | souffle | blast |
place_naturel | putnat | coupe_musique | delmusic | ecran_fond | scback |
efface | erase | tempo | cadence | defile_page | scrolpage |
efface_num | erasen | volume | setvolum | matiere_entite | matent |
positionne | set | inverse_x | xinv | retrecit | shrink |
deplace | mov | inverse_x_on | xinvon | definit_carte | defmap |
ouvre_ecran | opensc | inverse_x_off | xinvoff | regle_carte | setmap |
ferme_ecran | closesc | liste_entites | listent | place_carte | putmap |
efface_tout | erasall | son | sound | garde_palette | savepal |
supprime_forme | delforme | son_m | msound | ecran_zoom | sczoom |
teste_deplace | tstmov | reduction_on | redon | texture | texmap |
teste_position | tstset | reduction_off | redoff | alloue_tableau | alloctab |
teste_deplace_f | ftstmov | coupe_son | delsound | libere_tableau | freetab |
teste_position_f | ftstset | deplace_w | wmov | parcourt_tableau | scantab |
entite_suivante | succent | teste_deplace_w | wtstmov | tableau_proche | neartab |
entite_precedente | predent | teste_deplace_wf | wftstmov | ecran_soleil | scsun |
entite_proche | nearent | teste_forme | tstform | palette_sombre | darkpal |
type_proche | neartyp | place_x | xput | ecran_sombre | scdark |
matiere_proche | nearmat | place_x_en | xputat | place_a | aset |
entite_vue | viewent | place_m | mput | deplace_a | amov |
type_vu | viewtyp | place_m_en | mputat | ecran_place_a | scaset |
matiere_vue | viewmat | place_mx | mxput | ecran_deplace_a | scamov |
oriente | orient | place_mx_en | mxputat | ecran_suit | scfollow |
reinit_entite | rstent | musique_m | mmusic | ecran_vue | scview |
envoie | send | forme_m | mforme | marche_carte | walkmap |
clavier_on | scanon | regle_heure | settime | teste_carte | atstmap |
clavier_off | scanoff | lit_heure | gettime | teste_avance | avtstmov |
interruptions_on | interon | saisie_valeur | vinput | avance | avmov |
interruptions_off | interoff | saisie_texte | sinput | vise | aim |
clavier_vide | scanclr | endors_loin | asleepfar | point_pixel | pointpix |
toutes_entites | allentity | endors_on | asleepon | charte_carte | chartmap |
definit_couleur | defcolor | endors_off | asleepoff | ecran_ciel | scsky |
cadence_vm | timing | joue_film | runfilm | echap1 | esc1 |
explose | explode | imprime_valeur | vpicprint | son_on | soundon |
bruit | noise | imprime_texte | spicprint | son_off | soundoff |
init_tableau | initab | ecrit_nombre | vputprint | musique_on | musicon |
ouvre_fichier | fopen | ecrit_texte | sputprint | musique_off | musicoff |
ferme_fichier | fclose | police | font | coupe_film | delfilm |
cree_fichier | fcreat | papier | paper | ouvre_film | openfilm |
supprime_fichier | fdel | au_noir | toblack |
Le format 90 imagine un langage maison. ALIS BASIC part, lui, de ce que la machine dit de ses auteurs. Les noms d'origine des instructions, ceux des tables d'opcodes livrées sur le CD Silmarils Collection, sont pour beaucoup des mots de BASIC : locate, tab, dim, random, loop, plot, draw, box, boxf, ink, picture, mouse, print (vprint, sprint). Et ce ne sont pas ceux de n'importe quel BASIC : ce sont ceux du GFA BASIC, le langage roi de l'Atari ST en France à la fin des années 80. Or c'est sur Atari ST que Silmarils développait ses jeux. Le langage, créé par le fondateur Louis-Marie Rocques, ne servait qu'à eux. L'interview de Fabrice Hautecloque (atarilegend.com) le dit, et ajoute que la machine s'appelait Actor Language Integrated System. Le nom dit l'essentiel : un BASIC d'acteurs qui vivent en même temps (LIVE, KILL, SLEEP, WAKEUP, SEND, START, STOP), et dont les expressions s'écrivent en clair puis sont compilées (ceval, cstore).
ALIS BASIC est donc une reconstitution vraisemblable de leur texte source, faute de l'original :
PUTNAT, TOPALET, MOUSON, SWITCHING, LIVE, KILL… Ce sont les vrais noms ;IF … ELSE … ENDIF, WHILE … WEND ;GOSUB / RETURN, SELECT … CASE … ENDSELECT ;ADD x, n / SUB x, n ;&H52, les commentaires en ' ;| octet, & mot, $ texte, % adresse. Elles sont déclarées avec leur adresse dans l'acteur (LOCAL), dans le script principal (GLOBAL) ou chez une autre entité (FIELD) ;= pour ranger et pour comparer (BASIC les distingue par la place : en tête de ligne, c'est un rangement), <>, AND / OR / XOR / MOD / EQV, V:nom pour l'adresse d'une zone (le V: du GFA).' ALIS script "flags" — Robinson's Requiem
ACTOR "flags"
ID &H0081
RESOURCES "flags.res"
MAIN sp_0018
AFTER sp_01e8
LOCAL v_54& AT &H54
LOCAL vague| AT &H52
GLOBAL langue| AT &HE68
sp_0018:
SWITCHING
DEFMOUSE 1
PUTNAT 0, 10, 0, 3, 0
STOP
TOPALET 0, 30
et_0049:
PUTNAT 108, 0, 137, 5 + vague|, 1
IF v_54&
GOSUB sp_010d
ENDIF
TABLE INKEY(), -187
GOTO et_00b0
…
ENDTABLE
et_00b0:
langue| = 0
…
ADD vague|, 1
IF vague| <= 9 THEN GOTO et_0049
C'est encore le même programme. La traduction est faite mot pour mot dans les deux sens (App\Alis\Lang\Basic), comme pour le format 90. Les 109 scripts de Robinson's Requiem font l'aller-retour à l'identique (bin/jumphp php games/alis tools/lang/basic.php <sources> [dossier de sortie]) et se compilent en les mêmes octets. Le moteur reconnaît un fichier ALIS BASIC à sa ligne ACTOR "…" (App\Alis\Lang\Forms passe d'un format à l'autre). Dans l'éditeur, F2 fait défiler format 90 → ALIS BASIC → format machine.
| ALIS BASIC | Format machine | ALIS BASIC | Format machine | |||
|---|---|---|---|---|---|---|
ACTOR "x", ID, CLASS, MEMORY, PACK, RESOURCES, MAIN, BEFORE, AFTER | script "x", id… | PUTNAT, TOPALET… (tous les mots en majuscules) | putnat, topalet… | |||
IF x … ELSE … ENDIF | if x { … } else { … } | WHILE x … WEND | while x { … } | |||
IF x THEN GOTO l | if x goto L… | UNLESS x THEN GOTO l | ifnot x goto L… | |||
GOTO, GOSUB, RETURN, START, LOOP, DATA | goto, call, ret, start, loop, data | SELECT x / CASE n GOTO l / ENDSELECT | switch x / case n goto L… / end | |||
TABLE x, n … ENDTABLE | table x, n … end | ADD x, n / SUB x, n | x += n / x -= n | |||
x = y (en tête), a = b, a <> b | x = y, a == b, a != b | AND, OR, XOR, MOD, EQV | &, ` | , ^, %, eqv` | ||
&H52, ' commentaire | 0x52, // commentaire | sp_0049: (sous-programme), et_0049: | L0049: | |||
| `LOCAL n | AT &H52 / n& / n$` | vb[0x52] / vw[…] / vs[…] | `LOCAL DIM t | () AT &H40, puis t | (i)` | tb[0x40](i) (& : tw, $ : ts, % : to) |
| `GLOBAL n | AT &HE82` … | mb[0xe82] … | `FIELD c | AT &H4C, puis e&.c | ` | hb[0x54, 0x4c] (e& = vw[0x54]) |
LOCAL ZONE z AT &HE5E, puis V:z | &v[0xe5e] (GLOBAL ZONE : &m[…]) | [ … ] | [ … ] (regroupement, inchangé) |
Les noms par défaut disent la portée et l'adresse : v_52| (acteur), g_e82& (principal), t_40|() (tableau), c_4c| (champ), z_… (zone). Les noms trouvés en lisant les scripts restent : souris_x&, touche_lue&, langue|, vague|… Une variable utilisée sans être déclarée est une erreur, avec sa ligne.
La documentation technique de la machine décrit, pour chaque instruction, ce que l'exécutable d'origine en fait.
| Code | Instruction | Opérandes |
|---|---|---|
| 0x00 | cnul | nul |
| 0x01 | cesc1 | esc1 (voir les échappements) |
| 0x02 | cesc2 | esc2 octet |
| 0x03 | cesc3 | esc3 octet |
| 0x04 | cbreakpt | breakpt |
| 0x05 | cjsr8 | call étiquette |
| 0x06 | cjsr16 | call étiquette |
| 0x07 | cjsr24 | call étiquette |
| 0x08 | cjmp8 | goto étiquette |
| 0x09 | cjmp16 | goto étiquette |
| 0x0a | cjmp24 | goto étiquette |
Warning: Uninitialized string offset 0 in /workspace/games/alis/tools/lang/reference.php on line 24 Warning: Uninitialized string offset 0 in /workspace/games/alis/tools/lang/reference.php on line 23 Warning: Uninitialized string offset 0 in /workspace/games/alis/tools/lang/reference.php on line 24 Warning: Uninitialized string offset 0 in /workspace/games/alis/tools/lang/reference.php on line 24 Warning: Uninitialized string offset 0 in /workspace/games/alis/tools/lang/reference.php on line 23 Warning: Uninitialized string offset 0 in /workspace/games/alis/tools/lang/reference.php on line 23
| 0x0b | cjsrabs | jsrabs | |
|---|---|---|---|
| 0x0d | cjsrind16 | jsrind16 | |
| 0x0e | cjsrind24 | jsrind24 | |
| 0x0f | cjmpind16 | jmpind16 | |
| 0x10 | cjmpind24 | jmpind24 | |
| 0x11 | cret | ret | |
| 0x12 | cbz8 | ifz goto étiquette, ou ifnot expr goto étiquette | |
| 0x13 | cbz16 | ifz goto étiquette, ou ifnot expr goto étiquette | |
| 0x14 | cbz24 | ifz goto étiquette, ou ifnot expr goto étiquette | |
| 0x15 | cbnz8 | ifnz goto étiquette, ou if expr goto étiquette | |
| 0x16 | cbnz16 | ifnz goto étiquette, ou if expr goto étiquette | |
| 0x17 | cbnz24 | ifnz goto étiquette, ou if expr goto étiquette | |
| 0x18 | cbeq8 | ifeq goto étiquette | |
| 0x19 | cbeq16 | ifeq goto étiquette | |
| 0x1a | cbeq24 | ifeq goto étiquette | |
| 0x1b | cbne8 | ifne goto étiquette | |
| 0x1c | cbne16 | ifne goto étiquette | |
| 0x1d | cbne24 | ifne goto étiquette | |
| 0x1e | cstore | cible = expr | |
| 0x1f | ceval | eval expr | |
| 0x20 | cadd | cible += expr | |
| 0x21 | csub | cible -= expr | |
| 0x22 | cmul | mul | |
| 0x23 | cdiv | div | |
| 0x24 | cvprint | vprint expr | |
| 0x25 | csprinti | sprinti "texte" | |
| 0x26 | csprinta | sprinta expr | |
| 0x27 | clocate | locate expr, expr | |
| 0x28 | ctab | tab expr | |
| 0x29 | cdim | dim offset, compteur, taille, [valeurs] | |
| 0x2a | crandom | random expr | |
| 0x2b | cloop8 | loop cible goto étiquette | |
| 0x2c | cloop16 | loop cible goto étiquette | |
| 0x2d | cloop24 | loop cible goto étiquette | |
| 0x2e | cswitch1 | switch expr … end | |
| 0x2f | cswitch2 | table expr, base … end | |
| 0x30 | cstart8 | start étiquette | |
| 0x31 | cstart16 | start étiquette | |
| 0x32 | cstart24 | start étiquette | |
| 0x33 | cleave | leave | |
| 0x34 | cprotect | protect expr | |
| 0x35 | casleep | asleep expr | |
| 0x36 | cclock | clock expr | |
| 0x37 | canim | anim | |
| 0x38 | cscmov | scmov expr, expr, expr | |
| 0x39 | cscset | scset expr, expr, expr | |
| 0x3a | cclipping | clipping | |
| 0x3b | cswitching | switching | |
| 0x3c | cwlive | wlive expr, mot, cible | |
| 0x3d | cunload | unload mot | |
| 0x3e | cwakeup | wakeup expr | |
| 0x3f | csleep | sleep | |
| 0x40 | clive | live mot, cible | |
| 0x41 | ckill | kill expr | |
| 0x42 | cstop | stop | |
| 0x43 | cstopret | stopret | |
| 0x44 | cexit | exit | |
| 0x45 | cload | load id, "fichier" | expr |
| 0x46 | cdefsc | defsc mot, octet, hex"(32 octets)" | |
| 0x47 | cscreen | screen mot | |
| 0x48 | cput | put expr | |
| 0x49 | cputnat | putnat expr, expr, expr, expr, expr | |
| 0x4a | cerase | erase | |
| 0x4b | cerasen | erasen expr | |
| 0x4c | cset | set expr, expr, expr | |
| 0x4d | cmov | mov expr, expr, expr | |
| 0x4e | copensc | opensc mot | |
| 0x4f | cclosesc | closesc mot | |
| 0x50 | cerasall | erasall | |
| 0x51 | cforme | forme expr | |
| 0x52 | cdelforme | delforme | |
| 0x53 | ctstmov | tstmov expr, expr, expr, expr, cible | |
| 0x54 | ctstset | tstset | |
| 0x55 | cftstmov | ftstmov expr, expr, expr, expr, expr, cible | |
| 0x56 | cftstset | ftstset expr, expr, expr, expr, expr, cible | |
| 0x57 | csuccent | succent cible | |
| 0x58 | cpredent | predent cible | |
| 0x59 | cnearent | nearent expr, expr, cible | |
| 0x5a | cneartyp | neartyp expr, mot, cible | |
| 0x5b | cnearmat | nearmat expr, expr, cible | |
| 0x5c | cviewent | viewent expr, expr, expr, cible | |
| 0x5d | cviewtyp | viewtyp expr, expr, mot, cible | |
| 0x5e | cviewmat | viewmat expr, expr, expr, cible | |
| 0x5f | corient | orient expr | |
| 0x60 | crstent | rstent cible | |
| 0x61 | csend | send entité, valeur, … | |
| 0x62 | cscanon | scanon | |
| 0x63 | cscanoff | scanoff | |
| 0x64 | cinteron | interon | |
| 0x65 | cinteroff | interoff | |
| 0x66 | cscanclr | scanclr | |
| 0x67 | callentity | allentity | |
| 0x68 | cpalette | palette expr | |
| 0x69 | cdefcolor | defcolor expr, expr | |
| 0x6a | ctiming | timing expr | |
| 0x6b | czap | zap expr ×4 (×5 si la durée n'est pas la constante 0) | |
| 0x6c | cexplode | explode expr, expr, expr, expr | |
| 0x6d | cding | ding expr, expr, expr, expr | |
| 0x6e | cnoise | noise expr, expr, expr, expr | |
| 0x6f | cinitab | initab | |
| 0x70 | cfopen | fopen z"fichier", mode | expr, expr |
| 0x71 | cfclose | fclose | |
| 0x72 | cfcreat | fcreat | |
| 0x73 | cfdel | fdel | |
| 0x74 | cfreadv | freadv cible | |
| 0x75 | cfwritev | fwritev expr | |
| 0x76 | cfwritei | fwritei | |
| 0x77 | cfreadb | freadb &adresse, long | |
| 0x78 | cfwriteb | fwriteb &adresse, long | |
| 0x79 | cplot | plot expr, expr | |
| 0x7a | cdraw | draw expr, expr | |
| 0x7b | cbox | box expr, expr | |
| 0x7c | cboxf | boxf expr, expr | |
| 0x7d | cink | ink expr | |
| 0x7e | cpset | pset expr, expr | |
| 0x7f | cpmove | pmove expr, expr | |
| 0x80 | cpmode | pmode expr | |
| 0x81 | cpicture | picture | |
| 0x82 | cxyscroll | xyscroll expr, expr | |
| 0x83 | clinking | linking expr | |
| 0x84 | cmouson | mouson | |
| 0x85 | cmousoff | mousoff | |
| 0x86 | cmouse | mouse cible, cible, cible | |
| 0x87 | cdefmouse | defmouse expr | |
| 0x88 | csetmouse | setmouse expr, expr | |
| 0x89 | cdefvect | defvect hex"…" | |
| 0x8a | csetvect | setvect mot | |
| 0x8b | cnul2 | nul2 | |
| 0x8c | capproach | approach expr | |
| 0x8d | cescape | escape expr | |
| 0x8e | cvtstmov | vtstmov expr, cible | |
| 0x8f | cvftstmov | vftstmov expr, expr, cible | |
| 0x90 | cvmov | vmov | |
| 0x91 | cdefworld | defworld mot, hex"(6 octets)" | |
| 0x92 | cworld | world octet, octet | |
| 0x93 | cfindmat | findmat | |
| 0x94 | cfindtyp | findtyp mot, cible | |
| 0x95 | cmusic | music expr, expr, expr, expr, expr, expr | |
| 0x96 | cdelmusic | delmusic expr | |
| 0x97 | ccadence | cadence expr | |
| 0x98 | csetvolum | setvolum expr | |
| 0x99 | cxinv | xinv | |
| 0x9a | cxinvon | xinvon | |
| 0x9b | cxinvoff | xinvoff | |
| 0x9c | clistent | listent cible | |
| 0x9d | csound | sound expr, expr, expr, expr, expr | |
| 0x9e | cmsound | msound expr, expr, expr, expr, expr | |
| 0x9f | credon | redon | |
| 0xa0 | credoff | redoff | |
| 0xa1 | cdelsound | delsound | |
| 0xa2 | cwmov | wmov expr | |
| 0xa3 | cwtstmov | wtstmov | |
| 0xa4 | cwftstmov | wftstmov | |
| 0xa5 | ctstform | tstform expr, expr, cible | |
| 0xa6 | cxput | xput expr | |
| 0xa7 | cxputat | xputat expr, expr, expr, expr, expr | |
| 0xa8 | cmput | mput expr | |
| 0xa9 | cmputat | mputat expr, expr, expr, expr, expr | |
| 0xaa | cmxput | mxput expr | |
| 0xab | cmxputat | mxputat expr, expr, expr, expr, expr | |
| 0xac | cmmusic | mmusic expr, expr, expr, expr, expr, expr | |
| 0xad | cmforme | mforme expr | |
| 0xae | csettime | settime expr, expr, expr | |
| 0xaf | cgettime | gettime cible, cible, cible | |
| 0xb0 | cvinput | vinput cible | |
| 0xb1 | csinput | sinput cible | |
| 0xb2 | casleepfar | asleepfar expr | |
| 0xb3 | casleepon | asleepon | |
| 0xb4 | casleepoff | asleepoff | |
| 0xb5 | crunfilm | runfilm expr, cible, cible | |
| 0xb6 | cvpicprint | vpicprint expr | |
| 0xb7 | cspicprint | spicprint expr | |
| 0xb8 | cvputprint | vputprint expr | |
| 0xb9 | csputprint | sputprint expr | |
| 0xba | cfont | font expr, expr, expr, expr, expr | |
| 0xbb | cpaper | paper expr | |
| 0xbc | ctoblack | toblack expr | |
| 0xbd | cmovcolor | movcolor expr, expr | |
| 0xbe | ctopalet | topalet expr, expr | |
| 0xbf | cnumput | numput expr, expr, expr, expr | |
| 0xc0 | cscheart | scheart expr, expr | |
| 0xc1 | cscpos | scpos expr, expr | |
| 0xc2 | cscsize | scsize expr, expr | |
| 0xc3 | cschoriz | schoriz expr, expr, expr | |
| 0xc4 | cscvertic | scvertic expr, expr, expr | |
| 0xc5 | cscreduce | screduce expr, expr, expr | |
| 0xc6 | cscscale | scscale expr | |
| 0xc7 | creducing | reducing expr, expr | |
| 0xc8 | cscmap | scmap expr, &adresse | |
| 0xc9 | cscdump | scdump | |
| 0xca | cfindcla | findcla expr, cible | |
| 0xcb | cnearcla | nearcla | |
| 0xcc | cviewcla | viewcla | |
| 0xcd | cinstru | instru expr, expr, expr | |
| 0xce | cminstru | minstru expr, expr, expr | |
| 0xcf | cordspr | ordspr expr | |
| 0xd0 | calign | align expr, expr | |
| 0xd1 | cbackstar | backstar expr, expr, expr, expr, expr, expr | |
| 0xd2 | cstarring | starring expr, expr, expr, expr, expr, expr, expr, expr | |
| 0xd3 | cengine | engine | |
| 0xd4 | cautobase | autobase | |
| 0xd5 | cquality | quality expr | |
| 0xd6 | chsprite | hsprite expr, expr, expr, expr | |
| 0xd7 | cselpalet | selpalet expr | |
| 0xd8 | clinepalet | linepalet expr, expr | |
| 0xd9 | cautomode | automode | |
| 0xda | cautofile | autofile expr | |
| 0xdb | ccancel | cancel | |
| 0xdc | ccancall | cancall | |
| 0xdd | ccancen | cancen expr | |
| 0xde | cblast | blast expr | |
| 0xdf | cscback | scback expr, expr, expr, expr, expr, expr | |
| 0xe0 | cscrolpage | scrolpage expr, expr, expr, expr | |
| 0xe1 | cmatent | matent cible | |
| 0xe2 | cshrink | shrink expr, expr | |
| 0xe3 | cdefmap | defmap &adresse, expr, expr, expr, expr, expr, expr, expr | |
| 0xe4 | csetmap | setmap &adresse, expr, expr, expr, expr, expr, expr | |
| 0xe5 | cputmap | putmap &adresse, expr, expr, expr, expr | |
| 0xe6 | csavepal | savepal expr | |
| 0xe7 | csczoom | sczoom | |
| 0xe8 | ctexmap | texmap &adresse, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr | |
| 0xe9 | calloctab | alloctab &adresse | |
| 0xea | cfreetab | freetab &adresse | |
| 0xeb | cscantab | scantab | |
| 0xec | cneartab | neartab | |
| 0xed | cscsun | scsun | |
| 0xee | cdarkpal | darkpal expr, expr, expr, expr, expr | |
| 0xef | cscdark | scdark expr, expr, expr | |
| 0xf0 | caset | aset expr, expr, expr | |
| 0xf1 | camov | amov expr, expr, expr | |
| 0xf2 | cscaset | scaset | |
| 0xf3 | cscamov | scamov | |
| 0xf4 | cscfollow | scfollow expr, expr, expr, expr, expr, expr, expr, expr | |
| 0xf5 | cscview | scview expr, expr, expr, expr, expr, expr | |
| 0xf6 | cfilm | film expr, expr, expr, cible | |
| 0xf7 | cwalkmap | walkmap &adresse, expr, expr, expr, cible | |
| 0xf8 | catstmap | atstmap &adresse, expr, expr, expr, cible | |
| 0xf9 | cavtstmov | avtstmov expr, cible | |
| 0xfa | cavmov | avmov | |
| 0xfb | caim | aim expr, expr, expr, expr, cible, cible, cible | |
| 0xfc | cpointpix | pointpix expr, expr, cible, cible, cible, cible, cible, cible | |
| 0xfd | cchartmap | chartmap &adresse, mode, (&adresse si mode = 0 ou 1 | expr) |
| 0xfe | cscsky | scsky expr, expr, expr | |
| 0xff | czoom | zoom expr, expr |
cesc1 + un octet)| Échappement | Instruction | Opérandes |
|---|---|---|
| 0x01 0x00 | cnul | esc1 nul |
| 0x01 0x01 | csoundon | soundon |
| 0x01 0x02 | csoundoff | soundoff |
| 0x01 0x03 | cmusicon | musicon |
| 0x01 0x04 | cmusicoff | musicoff |
| 0x01 0x05 | cdelfilm | delfilm |
| 0x01 0x06 | copenfilm | openfilm expr, expr, expr, expr, cible |
Les cibles d'affectation (storenames, addnames) suivent la même table avec s… / a… au lieu de o….
| Code | Élément | Écriture | |
|---|---|---|---|
| 0x00 | oimmb | nombre de -128 à 127 | |
| 0x02 | oimmw | nombre de -32768 à 32767 | |
| 0x04 | oimmp | "texte" | |
| 0x06 | olocb | vb[offset] (autres offsets) | |
| 0x08 | olocw | vw[offset] (autres offsets) | |
| 0x0a | olocp | vs[offset] (autres offsets) | |
| 0x0c | oloctp | ts[offset](index…) (autres offsets) | |
| 0x0e | oloctc | tb[offset](index…) (autres offsets) | |
| 0x10 | olocti | tw[offset](index…) (autres offsets) | |
| 0x12 | odirb | vb[offset] (offset 0 à 255) | |
| 0x14 | odirw | vw[offset] (offset 0 à 255) | |
| 0x16 | odirp | vs[offset] (offset 0 à 255) | |
| 0x18 | odirtp | ts[offset](index…) (offset 0 à 255) | |
| 0x1a | odirtc | tb[offset](index…) (offset 0 à 255) | |
| 0x1c | odirti | tw[offset](index…) (offset 0 à 255) | |
| 0x1e | omainb | mb[offset] | |
| 0x20 | omainw | mw[offset] | |
| 0x22 | omainp | ms[offset] | |
| 0x24 | omaintp | mts[offset](index…) | |
| 0x26 | omaintc | mtb[offset](index…) | |
| 0x28 | omainti | mtw[offset](index…) | |
| 0x2a | ohimb | hb[var, offset] | |
| 0x2c | ohimw | hw[var, offset] | |
| 0x2e | ohimp | hs[var, offset] | |
| 0x30 | ohimtp | himtp(…) | |
| 0x32 | ohimtc | himtc(…) | |
| 0x34 | ohimti | himti(…) | |
| 0x36 | opile | pile(…) | |
| 0x38 | oeval | ( … ) | |
| 0x3a | ofin | fin(…) | |
| 0x3c | oimml | autre nombre | |
| 0x3e | olocto | to[offset](index…) (autres offsets) | |
| 0x40 | opushacc | push(…) | |
| 0x42 | oand | a & b | |
| 0x44 | oor | a ` | ` b |
| 0x46 | oxor | a ^ b | |
| 0x48 | oeqv | a eqv b | |
| 0x4a | oegal | a == b | |
| 0x4c | odiff | a != b | |
| 0x4e | oinfeg | a <= b | |
| 0x50 | osupeg | a >= b | |
| 0x52 | oinf | a < b | |
| 0x54 | osup | a > b | |
| 0x56 | oadd | a + b | |
| 0x58 | osub | a - b | |
| 0x5a | omod | a % b | |
| 0x5c | odiv | a / b | |
| 0x5e | omul | a * b | |
| 0x60 | oneg | neg(…) | |
| 0x62 | oabs | abs(…) | |
| 0x64 | ornd | rnd(…) | |
| 0x66 | osgn | sgn(…) | |
| 0x68 | onot | not(…) | |
| 0x6a | oinkey | inkey(…) | |
| 0x6c | okeyon | keyon(…) | |
| 0x6e | ojoy | joy(…) | |
| 0x70 | oprnd | prnd(…) | |
| 0x72 | oscan | scan(…) | |
| 0x74 | oshiftkey | shiftkey(…) | |
| 0x76 | ofree | free(…) | |
| 0x78 | omodel | model(…) | |
| 0x7a | ogetkey | getkey(…) | |
| 0x7c | oleft | left(…) | |
| 0x7e | oright | right(…) | |
| 0x80 | omid | mid(…) | |
| 0x82 | olen | len(…) | |
| 0x84 | oasc | asc(…) | |
| 0x86 | ostr | str(…) | |
| 0x88 | osadd | a $+ b | |
| 0x8a | osequal | a $== b | |
| 0x8c | osdiff | a $!= b | |
| 0x8e | osinfeg | a $<= b | |
| 0x90 | ossupeg | a $>= b | |
| 0x92 | osinf | a $< b | |
| 0x94 | ossup | a $> b | |
| 0x96 | ospushacc | spush(…) | |
| 0x98 | ospile | spile(…) | |
| 0x9a | oval | val(…) | |
| 0x9c | oexistf | existf(…) | |
| 0x9e | ochr | chr(…) | |
| 0xa0 | ochange | change(…) | |
| 0xa2 | ocountry | country(…) | |
| 0xa4 | omip | mip(…) | |
| 0xa6 | ojoykey | joykey(…) | |
| 0xa8 | oconfig | config(…) | |
| 0xaa | ogettext | gettext(…) | |
| 0xac | oips | ips(…) |