La machine virtuelle ALIS : documentation technique

Robinson's Requiem est un ensemble de programmes pour la machine virtuelle ALIS de Silmarils. Cette page décrit chaque élément de cette machine tel que l'exécutable DOS d'origine l'exécute (START.EXE du CD, décompilé avec Ghidra), pour qui veut lire ou écrire des scripts (le langage, l'éditeur).

Chaque traitement de l'original a été comparé à celui du moteur PHP : 405 éléments, 353 conformes, 17 dont seule la plateforme diffère (carte son, ports VGA…), 35 corrigés après l'audit (la colonne « état » le dit, la note dit ce qui différait). « Utilisations » = combien de fois les 109 scripts du jeu s'en servent.

L'exécutable : un extenseur DOS (Doug Huffman) puis un programme 32 bits à plat, écrit en assembleur ; la boucle de la machine lit un octet de code et appelle son traitement, le pointeur de programme est ESI, les variables du script courant sont en ES:EBP (adresses négatives : vb[], vw[]…). Détails : docs/vm/original-binary.md du dépôt.

Les instructions

Un octet de code par instruction, lu par la boucle de la machine (0x7b73 : lodsb ; call [eax*4+0x18432]).

CodeNomOpérandesEffetUtilisationsÉtat
0x00cnulaucunInstruction nulle : un simple RET d'un octet, l'exécution continue à l'octet suivant. Le même handler sert aux opcodes 0x37, 0x8b et esc1[0]. Dans les scripts, « nul » apparaît 53 fois, toujours après « exit » (code mort).53conforme
0x01cesc1un octet : indice dans la table d'échappement (7 entrées)Lit un octet puis saute via la table d'échappement esc1, sans contrôle de bornes ni test de version.0conforme
0x02cesc2aucunRET d'un octet, no-op qui ne lit aucun opérande.0conforme
0x03cesc3aucunRET d'un octet, no-op sans opérande. Avant la correction : Le port consommait un octet de plus (table [cnul] seule) : arrêt ou erreur fatale, désynchronisation d'un octet.0corrigé
0x04cbreakptaucunPoint d'arrêt de debug : no-op, ne fait rien.0conforme
0x05cjsr8un octet : décalage signé 8 bitsAppel de sous-routine : empile l'adresse de retour (après l'opérande) sur la pile du script (vacc_off diminue de 4), puis saute de l'offset signé.1555conforme
0x06cjsr16un mot : décalage signé 16 bitsAppel de sous-routine : empile l'adresse suivant l'opérande sur la pile du script puis ajoute l'offset signé 16 bits au pointeur d'exécution.0conforme
0x07cjsr243 octets : décalage signé 16 bits, le 3e octet est ignoréAppel de sous-routine avec offset « 24 bits » : seul le mot signé 16 bits est utilisé, le 3e octet est sauté. L'adresse de retour (après les 3 octets) est empilée.0conforme
0x08cjmp8un octet : décalage signé 8 bitsSaut relatif inconditionnel (depuis la fin de l'opérande).7285conforme
0x09cjmp16un mot : décalage signé 16 bitsSaut relatif inconditionnel de l'offset signé 16 bits.0conforme
0x0acjmp243 octets : décalage signé 16 bits + 1 octet ignoréSaut relatif ; seul le mot signé 16 bits compte, le 3e octet est ignoré.0conforme
0x0bcjsrabsaucunNo-op (RET), non utilisé en DOS.0conforme
0x0ccjmpabsaucunNo-op (RET), non utilisé en DOS.0conforme
0x0dcjsrind16aucunNo-op (RET), non utilisé en DOS.0conforme
0x0ecjsrind24aucunNo-op (RET), non utilisé en DOS.0conforme
0x0fcjmpind16aucunNo-op (RET), non utilisé en DOS.0conforme
0x10cjmpind24aucunNo-op (RET), non utilisé en DOS.0conforme
0x11cretaucunRetour de sous-routine. Si fseq vaut 0 et que vacc_off (s16) >= saversp, quitte la boucle d'exécution comme cstop. Sinon dépile l'adresse de retour, remet à 0 le mot 0x0c s'il égalait le sommet de pile, et incrémente vacc_off de 4.635conforme
0x12cbz8un octet : décalage signé 8 bitsBranchement si zéro : teste la valeur 16 bits de la dernière expression (D7). Si nulle, saute de l'offset s8 ; sinon saute l'opérande.0conforme
0x13cbz16un mot : décalage signé 16 bitsBranchement si D7 (16 bits) est nul, avec offset s16 ; sinon saute les 2 octets d'opérande.0conforme
0x14cbz243 octets : offset s16 + 1 octet ignoréBranchement si D7 (16 bits) est nul ; offset s16, 3e octet ignoré ; sinon saute les 3 octets.0conforme
0x15cbnz8un octet : décalage signé 8 bitsBranchement si non zéro : si D7 (16 bits) est différent de 0, saute de l'offset s8 ; sinon saute l'opérande d'un octet.0conforme
0x16cbnz16un mot signé 16 bits : décalage de saut (relatif à la fin de l'opérande)Si le résultat 16 bits de la dernière expression (D7) est non nul, saute de ce décalage ; sinon passe les 2 octets d'opérande.34conforme
0x17cbnz24un mot signé 16 bits suivi d'un octet ignoré (3 octets)Si D7 (16 bits) est non nul, saute du décalage signé (relatif à la fin des 3 octets) ; sinon saute les 3 octets.0conforme
0x18cbeq8un octet signé : décalage de sautSi D7 == D6 (16 bits), saute du décalage ; sinon passe l'octet.0conforme
0x19cbeq16un mot signé 16 bits : décalage de sautSi D7 == D6, saute du décalage (relatif à la fin de l'opérande) ; sinon passe 2 octets.0conforme
0x1acbeq24un mot signé 16 bits plus un octet ignoréSi D7 == D6, saute du décalage 16 bits (relatif à la fin des 3 octets) ; sinon passe 3 octets.0conforme
0x1bcbne8un octet signé : décalage de sautSi D7 != D6, saute du décalage ; sinon passe l'octet.0conforme
0x1ccbne16un mot signé 16 bits : décalage de sautSi D7 != D6, saute du décalage ; sinon passe 2 octets.0conforme
0x1dcbne24un mot signé 16 bits plus un octet ignoréSi D7 != D6, saute du décalage 16 bits (relatif à la fin des 3 octets) ; sinon passe 3 octets.0conforme
0x1ecstoreune expression (opername), puis un octet de code storenameSi le drapeau de sortie est levé, quitte vers le DOS. Sinon réinitialise la pile d'expression, copie D7 dans D6, évalue l'opername, échange les buffers sd7/oldsd7, lit l'octet de code et saute au storename correspondant.9806conforme
0x1fcevalun opername (flux d'expression), évalué jusqu'à sa finAprès test du drapeau de sortie, réinitialise la pile d'expression, copie D7 dans D6 et évalue l'opername (résultat dans D7).4149conforme
0x20caddun opername, puis un octet de code addnameAprès test du drapeau de sortie, réinitialise la pile, copie D7 dans D6, évalue l'opername, échange sd7/oldsd7, lit l'octet et saute à la cible addname (ajout à une variable).931conforme
0x21csubun opérande de stockage (cible addname) puis une expression (valeur)Soustrait : D7 est évalué puis nié sur 16 bits, et le résultat est ajouté à la cible désignée (addname avec échange des tampons). Le cas limite -(-32768) donne le même résultat car les additions sont masquées sur 8/16 bits.207conforme
0x22cmulaucunHandler vide (simple RET) : aucun opérande consommé, aucun effet.0conforme
0x23op_cdivaucunHandler vide (simple RET) : aucun opérande consommé, aucun effet.0conforme
0x24cvprintune expression (valeur à afficher)Met charmode à 0, évalue D7 et l'affiche en décimal signé (signe '-', 5 chiffres, zéros de tête supprimés, dernier chiffre toujours écrit) via le tampon sd7, caractère par caractère, sur la console texte au curseur BIOS (texte de débogage).0plateforme
0x25csprintiune chaîne littérale terminée par 0 dans le scriptAffiche la chaîne en ligne caractère par caractère, avec charmode remis à 0 avant chaque caractère, sur la console texte au curseur BIOS.0plateforme
0x26csprintaune expression de chaîne (évaluée dans sd7)Met charmode à 0, évalue une chaîne dans le tampon sd7 puis l'affiche jusqu'au 0 sur la console texte au curseur défini par clocate. Utilisé uniquement pour des écrans de debug/triche et l'invite 'PASSWORD:'.34plateforme
0x27clocatedeux expressions : x (colonne), y (ligne)Met charmode à 0 et positionne le curseur texte : xlocate = x, ylocate = y (octets), et fixe le curseur BIOS (int10 ah=2). D7 reçoit x et D6 reçoit y.20conforme
0x28ctabune expression : colonneMet charmode à 0 et fixe la colonne du curseur texte (xlocate = octet bas de D7) en gardant la ligne courante.0conforme
0x29cdimun mot (offset dans vram), un octet compteur, un octet, puis selon le signe du compteur n mots ou n dwords, plus une valeur finaleInitialise un tableau dans la zone de variables de l'entité : écrit le compteur et l'octet à l'offset donné, puis n = compteur & 0xf valeurs vers les adresses basses (mots si compteur >= 0, dwords 32 bits si compteur < 0), puis une dernière valeur. En cas positif, la valeur finale lit 4 octets mais seuls les 16 bits bas sont écrits, à offset-4-2n.70conforme
0x2acrandomune expression : graineÉvalue D7 (D6 = D7) et stocke ses 16 bits comme graine du générateur aléatoire, 0 compris (aucun cas spécial). orandom calcule ensuite seed = seed*0x7ab7 + 0xf881 sur 16 bits, donc la graine 0 est déterministe (première valeur 0xf881). Avant la correction : Le port remplace une graine 0 par sys_random() (LCG ANSI-C) et ne met pas D6 à jour : la suite des tirages diffère de l'original (le jeu n'appelle que 'random 0'). Correction prévue : graine = D7 & 0xffff, sans remplacement.1corrigé
0x2bcloop8un octet signé : décalage de saut relatifBoucle : mémorise la position, évalue une addname avec D7 = -1 (décrément de la cible), puis si le résultat n'est pas nul saute en arrière du décalage (relatif à l'octet suivant le décalage), sinon continue.49conforme
0x2ccloop16un décalage signé 16 bits, puis la cible addname (variable à décrémenter)Boucle compteur : échange sd7/oldsd7, ajoute -1 à la variable cible ; si le résultat est nul, continue après l'instruction, sinon saute au décalage relatif (par rapport à l'octet suivant le décalage).4conforme
0x2dcloop24un décalage sur 3 octets (le 3e est ignoré), puis la cible addnameIdentique à cloop16 mais le champ de décalage occupe 3 octets ; le saut est relatif à l'octet suivant le champ.0conforme
0x2ecswitch1une expression, un octet n, puis n+1 paires (valeur s16, décalage s16) alignées sur un motÉvalue l'expression et la compare, en signé 16 bits, aux valeurs de la table triée : égalité = saut au décalage de la paire ; valeur inférieure = abandon de la recherche et suite après la table ; sinon entrée suivante. Sans correspondance, le script continue après la table.79conforme
0x2fcswitch2une expression, un octet n, une base s16, puis n+1 décalages s16 alignés sur un motSwitch indexé : D7 = expr + base (16 bits). Si D7 est dans [0, n], saute via la table de décalages à l'indice D7 ; sinon passe la table. D7 conserve la valeur calculée.327conforme
0x30cstart8un décalage signé sur 1 octetDémarre une sous-séquence : empile l'adresse de reprise du script (pile interne via les champs -8/-0xa/-0xc selon fseq) et positionne l'adresse de reprise à la cible, marque l'entité active (octets -4 et -1 à 1, délai -0x3e à 0). Le flux courant n'est pas déplacé en mode fseq=0.0conforme
0x31cstart16un décalage signé 16 bitsComme cstart8 avec un décalage sur 16 bits.4conforme
0x32cstart24un décalage sur 3 octets (le 3e est ignoré)Comme cstart8 avec un champ de 3 octets dont seuls 16 bits sont utilisés.151conforme
0x33cleaveaucunQuitte une sous-séquence lancée par cstart : si le champ -0xc est non nul, le remet à 0 et restaure l'adresse de reprise absolue sauvegardée (fseq=0 : champ -8 ; fseq!=0 : ESI), puis ajuste le pointeur de pile. Si -0xc est nul, se comporte comme cret sans toucher à -0xa.0conforme
0x34cprotectune expressionStocke la valeur comme mot dans une variable de protection. Une routine périodique ne réagit que si elle est > 0, appelle une vérification de protection qui est un stub renvoyant 0 : aucun sabotage ne survient jamais.1conforme
0x35casleepune expression (handle d'entité)Si la valeur (16 bits signée) est >= 0 et que l'entrée correspondante de la table des entités est non nulle, met l'octet vram-4 à 0 : l'entité visée est endormie.21conforme
0x36cclockune expression (durée)Écrit la durée dans le mot vram-0x3a et, dans le dword vram-0x3e, l'heure de réveil = timeclock + durée étendue sans signe sur 16 bits.104conforme
0x37canimaucunSimple retour, sans effet (instruction nulle).0conforme
0x38cscmovtrois expressions (x, y, z)Déplacement relatif d'un écran : pour z, y puis x, si la valeur est non nulle, l'ajoute aux mots +0x1a, +0x18, +0x16 de l'écran (basemain + id) et met le bit 7 de son état.0conforme
0x39cscsettrois expressions (x, y, z)Positionnement absolu d'un écran : pour z, y, x, si la valeur diffère du mot courant (+0x1a/+0x18/+0x16), la stocke et met le bit 7 de l'état de l'écran.0conforme
0x3acclippingaucunMet à 0 l'octet d'indicateur de clipping. Dans cette version DOS l'indicateur est inerte : ses lecteurs prennent le même chemin dans les deux cas. Avant la correction : Le port met fswitch à 0, ce qui change réellement son chemin de rendu (dessin direct au lieu du double tampon) jusqu'au prochain cswitching. Visible seulement sur l'écran du mot de passe de debug ; comportement jugé acceptable.7corrigé
0x3bcswitchingaucunSimple retour : instruction non implémentée dans cette version DOS (no-op).10conforme
0x3ccwliveun index de forme (get_vector), puis le corps de cliveCalcule une position d'apparition à partir d'une forme : type 0 = octets signés +4/+5/+6 plus (octets +7/+8/+9) >> 1 ; type 1 = mots +4/+6/+8 plus (mots +0xa/+0xc/+0xe) >> 1 ; type >= 2 = mots +2/+4/+6 ; type négatif = erreur fatale 0x14. Les coordonnées sont niées si l'octet vram-0x2e >= 0x15 et vram-3 non nul, stockées en 0x16028..2c, puis exécute le corps de clive.0conforme
0x3dcunloadun mot (id de programme)Décharge un programme : ignore -1 et l'id du script courant ; trouve le programme par id, calcule sa longueur jusqu'au programme suivant (ou finprog), appelle une routine son (qui arrête un canal ou tous les 4 si le bit 7 de la longueur est posé, quand le son est actif), met un indicateur à 1, puis shrinkprog déplace la mémoire et tue les entités du script. Avant la correction : Le port fait shrinkprog et relocalise les samples en lecture (audio_relocate) mais n'imite pas l'arrêt des canaux sonores de la routine d'origine. Fidélité optionnelle.154corrigé
0x3ecwakeupune expression (handle d'entité)Si la valeur est >= 0 et que atent[valeur] est non nul, met l'octet vram-4 à 1 : réveille l'entité.33conforme
0x3fcsleepaucunMet l'octet vram-4 à 0 (endort l'entité courante) ; si fseq est non nul, quitte aussitôt la boucle d'opcodes du script.128conforme
0x40cliveun mot (id de programme)Crée une entité à partir d'un programme : remet à 0 les coordonnées 0x16028..2c, cherche le programme (introuvable = erreur fatale 0x15 et D7 = -1), lie une nouvelle entité (erreurs fatales si trop d'entités ou vram saturée), copie dwords/mots de position et de contexte du script courant, ajoute wcx/wcy/wcz aux positions, copie -0x16 et -0x22, puis stocke l'index via sd7/oldsd7 et storename.703conforme
0x41ckillune expression (handle d'entité)Ignore les valeurs négatives et 0 (l'entité 0, script principal, ne peut pas être tuée). Sinon killent : efface les sprites de l'entité, comprime la vram, décale les pointeurs, libère le slot ; si l'entité tuée est la courante, passe à l'entité suivante. Avant la correction : Pour la version < 60, le port ne rejette que les valeurs négatives : la valeur 0 tue l'entité principale. Correction prévue (tester <= 0).112corrigé
0x42cstopaucunTermine l'exécution de l'entité pour cette passe : abandonne la boucle d'opcodes et rend la main à l'ordonnanceur, qui sauvegarde le PC (juste après l'opcode) et vacc dans la vram de l'entité.1415conforme
0x43cstopretaucunEn passe principale (fseq non nul) exécute cret (dépile l'adresse de retour du script, efface le décalage vacc si égal) puis arrête l'entité. Pour un vecteur d'interruption/before/after (fseq = 0), arrête seulement, sans toucher à la pile. Avant la correction : Le port appelle aussi cret() quand fseq = 0, ce qui peut dépiler une adresse ou effacer vram-0xc à tort. Correction prévue : si fseq == 0, cstop() puis retour, pour toutes les versions.74corrigé
0x44cexitaucunSi l'entité courante est l'entité 0, termine le programme (démontage et sortie DOS). Sinon l'entité se tue (killent) : l'entité précédente devient courante et toutes les étapes restantes de l'ordonnanceur pour elle sont sautées, dans n'importe quelle phase, avant de passer à l'entité suivante. Avant la correction : Le planificateur v3 du port ne saute pas updtcoord ni les phases main/after après un 'before' quand l'entité s'est tuée. Correction prévue dans Machine.php : si restart_loop, aller directement à l'entité suivante.252corrigé
0x45cloadun mot (id) puis un nom de fichier terminé par 0 ; si id = 0, une expression de chaîneSi id est non nul : charge le programme nommé (si cet id n'est pas déjà chargé ; vérifie l'id du fichier). Si id = 0 : évalue une chaîne, change de répertoire de base, recharge main.io avec id 0 et relance l'ordonnanceur à l'entité 0. Une capture PCX de débogage est prise avant si une touche est tenue.201conforme
0x46cdefscun mot (index de l'écran), un octet, puis 32 octets de descripteurDéfinit un écran (scène) : active le drapeau 0x40, copie 0x20 octets dans le descripteur, lui attribue un sprite de la bibliothèque (libsprit) et initialise ses coordonnées d'écran (newx masqué à 0xfff0, newy, newd = 0x7fff, depx = (x+largeur)|0xf, depy = y+hauteur). Efface des champs, ajoute l'écran (scadd) et calcule le vectoriel.2conforme
0x47cscreenun motÉcrit le mot dans vram-0x16 : identifiant d'écran de l'entité, utilisé par les opcodes d'affichage.101conforme
0x48cputune expression : index d'élémentMet flagmain à 0, copie xinv, remet à 0 depx/depy/depz et numelem, puis affiche l'élément d'index donné de l'entité (routine de put partagée).525conforme
0x49cputnatcinq expressions : depx, depy, depz, index, numelemComme cput, mais avec décalages explicites depx, depy, depz et un numéro d'élément numelem (octet) ; routine de put partagée. (Version 1.0 : sans depz.)775conforme
0x4aceraseaucunCherche la tête des éléments de l'entité (searchtete) et supprime en boucle les éléments dont l'id d'écran est celui de l'entité (killelem), puis ferase = 0.0conforme
0x4bcerasenune expression : numéro d'élémentFixe numelem puis supprime tous les éléments portant ce numéro (searchelem/killelem en boucle), puis ferase = 0.236conforme
0x4ccsettrois expressions : x, y, zÉcrit les trois valeurs comme mots 16 bits dans les coordonnées monde de l'entité (vram+0, +8, +0x10).106conforme
0x4dcmovtrois expressions : dx, dy, dzAjoute les trois valeurs (16 bits) aux coordonnées monde de l'entité (vram+0, +8, +0x10).0conforme
0x4ecopenscun mot : index de l'écranOuvre l'écran : efface le bit 0x40 et pose le bit 0x80 de son drapeau, recalcule (scbreak, scadd) ; si le bit 1 de l'octet suivant est posé, ouvre aussi la zone (openland).8conforme
0x4fcclosescun mot : index de l'écranFerme l'écran : pose le bit 0x40 de son drapeau.11conforme
0x50cerasallaucunSupprime tous les éléments de la liste de l'entité (killelem en boucle depuis la tête vram-0x18), puis ferase = 0.105conforme
0x51cformeune expressionFixe la forme de collision de l'entité : écrit la valeur (mot) à vram-0x1a.57conforme
0x52cdelformeaucunSupprime la forme de l'entité : écrit 0xffff à vram-0x1a (cforme < 0 = pas de forme).24conforme
0x53ctstmovquatre expressions (dx, dy, dz, matmask), puis un opérande de stockageTeste un déplacement : position testée = coordonnées + (dx, dy, dz), avec xinv, matmask et la forme courante. Cherche les entités du même groupe (mot +0x30), avec forme, hors elle-même, dont la forme en collision correspond (une seule sauf fallent) ; liste terminée par 0xffff. Puis crstent réinitialise la liste et stocke la première entrée.0conforme
0x54ctstset4 expressions (wcx, wcy, wcz, matmask) puis 1 cible de stockage (S)Fixe la position absolue de test (wcx, wcy, wcz) et le masque matmask. La forme de test est la forme courante du script (cforme). Lance tstform (clipform) puis réinitialise la liste et stocke la première entité trouvée dans la cible.0conforme
0x55cftstmov5 expressions (x, y, z relatifs, matmask, forme) puis 1 cible STeste une forme à une position relative à la position courante du script (wcx, wcy, wcz). Les deux dernières expressions donnent matmask et la forme. Après tstform, la liste est réinitialisée et la première entité trouvée est stockée dans la cible.0conforme
0x56cftstset5 expressions (x, y, z absolus, matmask, forme) puis 1 cible SComme cftstmov mais avec une position absolue. Après tstform, la première entité trouvée est stockée dans la cible.0conforme
0x57csuccent1 cible de stockage (S)Lit l'entrée courante de la liste tablent. Si elle est >= 0, le pointeur de liste avance d'une entrée. La valeur est stockée dans la cible qui suit.85conforme
0x58cpredentaucun (suivi de la cible de stockage)Recule le curseur dans la liste d'entités tablent et place l'entité précédente dans D7 (0xFFFF si au début), puis échange les buffers sd7/oldsd7 et exécute le storename suivant.0conforme
0x59cnearentdeux expressions : rayon (valnorme = u16*u16), filtre d'entité (forcé à -1 si fallent)Parcourt la chaîne d'entités du script courant et retient celles dont le filtre correspond, du même groupe, différentes de soi et à portée (calcnear). Sans fallent, garde la plus proche ; avec fallent, ajoute toutes les correspondantes puis trie en ordre croissant de distance (tri à bulles répété, tablent suivi). Stocke ensuite via crstent/csuccent.1conforme
0x5acneartypune expression (rayon), puis un mot 16 bits brut inline : identifiant de typeComme cnearent mais filtre sur l'identifiant de type brut (mot en vram-0x10), même groupe, hors soi, à portée ; mêmes modes plus proche / toutes avec tri complet, puis stockage.60conforme
0x5bcnearmatdeux expressions : rayon, masque de matière (stocké sur un octet)Pour chaque entité du même groupe, applique le test clipmat (la forme doit être valide et distincte de soi, sinon l'entité est ignorée) avec le masque de matière sur les tables de formes (mono ou multi), puis calcnear ; mêmes modes plus proche / toutes.0conforme
0x5ccviewenttrois expressions : rayon, champ de vision (valchamp), filtre d'entitéComme cnearent en mode vue (fview=1) : en plus de la distance, l'entité doit être dans le champ, via le produit scalaire de la direction (octets signés +0x34/38/3c) par le delta, comparé au rayon fois champ.0conforme
0x5dcviewtypdeux expressions (rayon, champ), puis un mot 16 bits brut inline : identifiant de typeVersion vue de cneartyp : filtre sur l'identifiant de type brut avec test de champ de vision.0conforme
0x5ecviewmattrois expressions : rayon, champ, masque de matière (octet)Version vue de cnearmat : test clipmat/traitmat sur les formes, puis calcnear avec champ de vision.0conforme
0x5fcorientune expression (index de vecteur)Prend le vecteur d'orientation d'indice D7 dans la table setvect de l'entité (ou la table standard si absente), index*3, et copie 3 octets dans les composantes de direction (+0x34, +0x38, +0x3c).0conforme
0x60crstentaucun (suivi de la cible de stockage)Remet le curseur de la liste tablent au début puis enchaîne sur csuccent : lit l'entité suivante (curseur avancé si >= 0) et la stocke.0conforme
0x61csendun octet n, puis n+1 expressions, puis une expression d'entitéEnvoie n+1 valeurs dans la file de messages de l'entité cible (tampon circulaire head/tail). Si l'entité est -1, absente, ou a le bit 0 de l'octet d'état à 1, les valeurs sont évaluées puis jetées. Si la file est pleine, le reste est ignoré ; sinon à la fin le bit 0x80 de l'état est positionné.162conforme
0x62cscanonaucunActive la réception de messages : efface le bit 0 de l'octet d'état de l'entité (&= 0xfe).49conforme
0x63cscanoffaucunDésactive la réception (bit 0 à 1) puis vide la file de messages (scanclr).55conforme
0x64cinteronaucunEfface le bit 1 de l'octet d'état de l'entité (&= 0xfd).55conforme
0x65cinteroffaucunPositionne le bit 1 de l'octet d'état de l'entité (|= 2).62conforme
0x66cscanclraucunVide la file de messages (tête = queue) et efface le bit 0x80 de l'état.66conforme
0x67callentityaucunPositionne fallent=1 : la prochaine recherche near/view retiendra toutes les entités correspondantes (liste triée) au lieu de la plus proche.67conforme
0x68cpaletteune expression (index de palette ou ressource)Met flagmain à 0. Si l'index est entre -2 et -1, restaure la palette sauvegardée sans fondu. Si l'index est >= 0 et que le saut selpalet n'est pas actif, résout la ressource du script courant ; si son premier octet vaut 0xfe, charge immédiatement la palette (topalette, couleurs 6 bits). Remet toujours le saut selpalet à 0.27conforme
0x69cdefcolordeux expressionsÉvalue deux expressions puis retourne : aucun effet dans la version DOS de Robinson's Requiem.0conforme
0x6actimingune expressionStocke l'octet bas de D7 comme valeur de timing (consommée ailleurs).8conforme
0x6bczapquatre expressions (prior, vol, freq, long), plus une cinquième (dfreq) si long != 0Mémorise les paramètres d'un effet sonore « zap » ; mais le lecteur appelé est un simple RET : la version DOS ne joue aucun son.0conforme
0x6ccexplodequatre expressions (prior, vol, freq, long)Mémorise les paramètres d'une explosion, mais le code de lancement est du code mort : aucun son en DOS.0conforme
0x6dcdingquatre expressions (prior, vol, freq, long)Calcule les paramètres d'un « ding » (dfreq=0, dvol négatif d'après vol et long) quand long != 0, puis appelle un lecteur qui est un simple RET : silencieux en DOS. Avant la correction : Le port synthétise un ton OPL sur l'écran du logo (avec freq>>1, absent de l'original). Correction : lire les 4 opérandes et retourner sans runson.1corrigé
0x6ecnoisequatre expressionsÉvalue quatre expressions puis retourne. En DOS v31 aucun son n'est produit et aucune variable n'est écrite.0conforme
0x6fcinitabun mot : offset (signé), un mot : nombre d'octets, puis count-1 octets inlineCopie count-1 octets du script (inline) vers vars[offset] et avance le pointeur d'exécution après eux. Avec count=0 la copie déborde (bug de l'original).0conforme
0x70cfopennom : chaîne inline terminée par NUL puis un mot (mode), ou forme 0xff : expression de chaîne (nom) puis expression (mode)Ouvre un fichier. Mode 0x100 : crée s'il n'existe pas. 0x200 : crée/tronque s'il existe. Sinon ouverture en lecture/écriture. 0x800 : lit 12 octets d'en-tête ; 'PB60' donne typepack=0xa0, longpack big-endian ; 'PW60' donne wordpack=1 ; sinon rembobine à l'offset 0. 0x400 : positionne en fin de fichier. Échec : erreur 1. Avant la correction : Écart réel : sans en-tête PB60/PW60 le port ne rembobine pas ; canyon.dat (mode 2050, non compressé) est lu décalé de 12 octets. Aussi : mode 2 ouvert en lecture seule, 0x200 sur fichier absent crée le fichier au lieu d'une erreur, 0x400 en 'ab'. Seul le rembobinage est44corrigé
0x71cfcloseaucunFerme le fichier courant ; erreur 0xe en cas d'échec.35conforme
0x72cfcreatnom inline terminé par NUL, puis un mot (ignoré)Crée ou tronque un fichier vide du nom donné, puis le referme. Erreur 8 en cas d'échec de création.0conforme
0x73cfdelnom inline terminé par NULSupprime le fichier du nom donné. Erreur 9 en cas d'échec. Pas de forme à expression en DOS.0conforme
0x74cfreadvaucun (cible de stockage via la suite de cstore)Lit 2 octets du fichier courant, valeur 16 bits big-endian dans D7, puis continue comme cstore (échange des tampons de chaînes et écriture dans la cible). Erreur 0xd seulement en cas d'erreur de lecture.400conforme
0x75cfwritevune expression (valeur 16 bits)Évalue une expression et écrit le mot 16 bits obtenu, en gros-boutiste (octets D7 inversés), dans le fichier ouvert. Une erreur d'écriture déclenche l'erreur 7.400conforme
0x76cfwriteiune chaîne immédiate terminée par NUL, lue dans le scriptÉcrit dans le fichier ouvert la chaîne inline, NUL final compris, puis avance le pointeur de script après la chaîne.0conforme
0x77cfreadbun mot : offset de la cellule (si 0, il est relu et basemain sert de base), puis un dword : longueurLit dans le fichier ouvert un bloc de la longueur donnée vers la cellule désignée (directe ou table indirecte). Dépaquète si typepack, avec unmixword si wordpack, sinon lecture par blocs de 0xFA00. Si la cellule est de taille 2, les mots sont inversés en place. Une cellule indirecte nulle ou négative provoque l'erreur 0x1a sans lire la longueur.96conforme
0x78cfwritebun mot : offset de la cellule (même résolution que cfreadb), puis un dword : longueurÉcrit dans le fichier ouvert un bloc de la longueur donnée depuis la cellule désignée. Si la cellule est de taille 2, les mots sont inversés avant l'écriture puis restaurés. Une cellule indirecte nulle ou négative donne l'erreur 0x1a, longueur non consommée.95conforme
0x79cplotdeux expressions (x, y)Évalue deux expressions et ne fait rien d'autre : aucun tracé sur la version DOS v31.0conforme
0x7acdrawdeux expressions (la seconde évaluée avec D7 sauvegardé)Évalue deux expressions sans rien dessiner ni modifier d'état.0conforme
0x7bcboxdeux expressionsÉvalue deux expressions, aucun effet (pas de tracé).0conforme
0x7ccboxfdeux expressionsÉvalue deux expressions, aucun effet (pas de rectangle plein).0conforme
0x7dcinkune expression (couleur d'encre)Stocke l'octet bas de la valeur dans une globale d'encre qu'aucun autre code ne lit : écriture sans effet.1conforme
0x7ecpsetdeux expressions (x, y)Évalue deux expressions, sans effet visible sur la version DOS v31.0conforme
0x7fcpmovedeux expressions (dx, dy)Évalue deux expressions, sans effet visible sur la version DOS v31.0conforme
0x80cpmodeune expression (mode de tracé)Stocke l'octet bas de la valeur dans une globale que nul autre code ne référence : écriture sans effet.0conforme
0x81cpictureune expressionSur DOS v31, évalue une expression et ne fait rien d'autre.0conforme
0x82cxyscrolldeux expressions (x, y)Évalue deux expressions, sans autre effet.0conforme
0x83clinkingune expressionÉcrit la valeur (16 bits) dans le champ clinking du script courant (vram - 0x2a).27conforme
0x84cmousonaucunActive le curseur souris : sans effet si aucun pilote souris ; si le curseur est caché, relit la position, dessine le sprite curseur et le marque affiché (compteur de masquage remis à 0xff). Le descripteur de curseur (desmouse) n'est pas modifié. Avant la correction : Le port active la souris, mais comme cmousoff y efface desmouse, un mouson après un mousoff n'affiche plus de curseur. Rien à changer ici, la correction est dans cmousoff.8corrigé
0x85cmousoffaucunCache le curseur souris : si une souris existe et que le curseur est affiché, le marque caché et efface son sprite. Le descripteur de curseur (desmouse, fixé seulement par defmouse) est conservé. Avant la correction : Le port efface aussi desmouse (versions < 60), donc le curseur disparaît définitivement après le premier mousoff/film. Correction prévue : ne pas effacer desmouse, basculer seulement enabled et le marquage dirty.8corrigé
0x86cmousetrois opérandes de stockage : x, y, boutons (dans cet ordre)Lit la souris et stocke x, y et l'état des boutons. Sans souris : -1, -1, 0. Sinon position brute + décalage posé par csetmouse, bornée à l'écran, et boutons = bits bruts & 3 (1 gauche, 2 droit, 3 les deux). Avant la correction : Le port ne renvoie jamais 3 (deux boutons), utilisé par souris.als, et ignore le décalage de csetmouse. Correction prévue : boutons = (g?1:0)|(d?2:0) et ajout des décalages persistants avec bornage.21corrigé
0x87cdefmouseune expression : index du descripteur de curseurMet flagmain à 0, résout le descripteur dans la table de sprites du script (erreur si l'index dépasse le nombre d'entrées) et le fixe comme descripteur de curseur (desmouse) ; l'entrée est aussi inscrite dans l'emplacement sprite du curseur de la liste de sprites de la VM. Aucun contrôle du type d'octet du descripteur.2conforme
0x88csetmousedeux expressions : x, ySi x < 0 remet à zéro le décalage de la souris ; sinon règle un décalage persistant (x - x brut, y - y brut) que cmouse ajoute, de sorte que la position rapportée devient (x, y) puis suit les mouvements réels. Ne déplace jamais la souris matérielle. Avant la correction : Le port lit y dans D6 (au lieu de D7) et écrit directement la position de la souris, aussitôt écrasée par la souris hôte à chaque frame : aucun effet. Correction prévue : x = s16(D7) puis y = s16(D7), avec un système de décalage.4corrigé
0x89cdefvectun octet n, suivi de n+1 vecteurs de 3 octets (sautés)Saute la table de n+1 vecteurs de 3 octets dans le script (n*3+3 octets) ; les vecteurs eux-mêmes sont lus ailleurs par capproach/cescape.0conforme
0x8acsetvectun motStocke le mot dans vram-0x20 : offset de la table de vecteurs courante de l'entité (0 = table standard vstandard).0conforme
0x8bcnulaucunNo-op : simple RET, la VM passe à l'opcode suivant.0conforme
0x8ccapproachune expression (offset de l'entité cible), puis un opérande de stockageCalcule la différence de coordonnées monde (x, y, z) entre la cible et l'entité, puis parmi les n+1 vecteurs de la table courante choisit celui au produit scalaire (octets signés par mots 16 bits) strictement maximal. Stocke l'indice du meilleur vecteur et ses 3 octets dans les registres de direction. Retourne si l'offset vaut -1.0conforme
0x8dcescapeune expression (offset de l'entité cible), puis un opérande de stockageComme capproach mais retient le produit scalaire strictement minimal (départ 0x7fffffff), comparé sur 32 bits : choisit la direction la plus éloignée de la cible.0conforme
0x8ecvtstmovune expression (matmask), puis un opérande de stockageTeste un déplacement par vecteur : position testée = coordonnées + s8 des registres de vecteur (0x34/0x38/0x3c), avec xinv, matmask (expression) et forme courante ; lance le test de collision de formes (clipform) puis crstent (réinitialise la liste d'entités et stocke la première entrée dans l'opérande de stockage).0conforme
0x8fcvftstmovdeux expressions (matmask, forme), puis un opérande de stockageComme cvtstmov, mais la forme testée est donnée par la seconde expression au lieu de la forme de l'entité ; clipform puis crstent avec stockage.0conforme
0x90cvmovaucunDéplace l'entité selon son vecteur : ajoute les octets signés des registres 0x34/0x38/0x3c aux mots de coordonnées x, y, z de l'entité (vram+0, +8, +0x10).3conforme
0x91cdefworldun mot (offset dans vram) puis 5 octets de donnéesCopie 5 octets du script vers vram+offset .. vram+offset+4 (7 octets consommés au total) : définition du monde de l'entité.0conforme
0x92cworldun mot (2 octets)Écrit les deux octets lus à vram-0x22 et vram-0x21 (paramètre de monde de l'entité).0conforme
0x93cfindmatune expression (matmask), puis un opérande de stockageParcourt la liste d'entités depuis l'offset 0, en sautant l'entité elle-même et celles sans forme (cforme < 0), et retient celles dont la forme a un matériau & matmask non nul (formes composites : première sous-forme qui correspond). Seul l'octet bas de matmask est mis à jour. Les résultats vont dans tablent, puis crstent et stockage.0conforme
0x94cfindtypun mot (identifiant de script), puis un opérande de stockageParcourt les entités depuis l'offset 0 et retient celles dont l'id de script vaut le mot (comparaison brute 16 bits), hors l'entité elle-même ; s'arrête à la première sauf si fallent est actif. Liste terminée par 0xffff, fallent remis à 0, puis crstent avec stockage.215conforme
0x95cmusicune expression (index de musique) puis, selon le type, 5 expressions : volume, tempo, attaque, chute, duréeRetrouve la musique dans la table du script (sans contrôle de bornes). Si le type n'est pas 0, 3 ou 4, lit 5 expressions et les ignore. Sinon les stocke brutes (volume, tempo, attaque, chute, durée, sans ajustement) et, si musique et carte son sont actifs, lance le tracker DOS (liste d'ordre de 128 octets, patterns de 1024 octets, volume = volume>>1).4plateforme
0x96cdelmusicune expression : durée du fonduArrête la musique : durée 0 = arrêt immédiat (voix du tracker coupées) ; sinon fondu sortant sur la durée donnée. Sans effet sans carte son ou si aucune musique ne joue.6plateforme
0x97ccadenceune expressionConsomme son opérande puis appelle un RET vide : sans effet dans la version DOS (la cadence n'est pas modifiée).0conforme
0x98csetvolumune expression : volumeMémorise l'octet bas du volume (pour le prochain cmusic, qui le passera au tracker). N'agit pas sur la musique en cours.0conforme
0x99cxinvaucunInverse le drapeau xinv de l'entité (bascule du bit à vram-3) : retournement horizontal.0conforme
0x9acxinvonaucunMet à 1 l'octet xinv de l'entité courante (miroir horizontal activé).0conforme
0x9bcxinvoffaucunMet à 0 l'octet xinv de l'entité courante (miroir désactivé).0conforme
0x9cclistent1 cible de stockage (S)Parcourt la chaîne des entités à partir de atent, en sautant l'entrée 0. Remplit tablent avec chaque entité, met matent à 0 pour chacune, termine la liste par 0xffff et met fallent à 0. Il fait ensuite l'équivalent de crstent : la première entité est stockée dans la cible. L'original ne vérifie aucune borne.17conforme
0x9dcsound5 expressions : index du son, priorité, volume, nombre de boucles, vitesse (multipliée par 1000 pour la fréquence)Joue un échantillon sur l'une des 4 voix. Si la priorité est négative, il réutilise la voie de même priorité. Sinon il réutilise une voie ACTIVE de même propriétaire (entité du script) et de même priorité, puis la première voie libre, puis la plus basse priorité. Sans voie, les expressions restantes sont lues et ignorées. Le volume est (vol&0xff)>>1. Le compteur de boucles est sur 16 bits : à 0 ou négatif, l'échantillon boucle indéfiniment. Le type de l'échantillon n'est pas vérifié. Les données vont de addr+0xe à addr+[addr+2]-8. Avant la correction : Le port diffère : pour une priorité positive il ne compare pas le propriétaire, donc deux entités de même priorité se coupent mutuellement. Le compteur de boucles est tronqué à 8 bits, donc -1 joue 255 fois puis s'arrête, et 0 joue une seule fois. Seuls les types 1 et 2 sont joués. Une vitesse de 0 prend l'octet d'en-tête, et la fréquence est bornée entre 1 et 20 kHz. La fenêtre de données diffère (addr+0x10). Correction en cours.254corrigé
0x9ecmsoundidentiques à csound (5 expressions)Comme csound, mais l'échantillon est cherché dans les ressources du script main (flagmain=1). Le propriétaire de la voie reste l'entité du script courant.0conforme
0x9fcredonaucunMet à 0 l'octet credon/credoff de l'entité courante.2conforme
0xa0credoffaucunMet l'octet credon/credoff de l'entité courante à 0x80.9conforme
0xa1cdelsoundaucunSi le son est activé, remet à zéro l'état des 4 voix d'échantillons, ce qui coupe les effets sonores. La priorité et le propriétaire sont conservés. Les voix de musique et les autres périphériques sonores ne sont pas touchés.16conforme
0xa2cwmov1 expression (index de forme)Calcule le vecteur du centre d'une forme (get_vector) et l'ajoute aux coordonnées du script : ax à wcx, bx à wcy, cx à wcz. Type 0 : moyenne de deux jeux d'octets SIGNÉS (+4/+7, +5/+8, +6/+9). Type 1 : moyenne de mots (+4/+a, +6/+c, +8/+e). Type >= 2 : mots +2, +4, +6. Un type négatif déclenche l'erreur 0x14. ax est inversé si l'octet 0x2e est >= 0x15 et xinv != 0.0conforme
0xa3cwtstmov2 expressions (index de forme pour le vecteur, matmask) puis 1 cible SPlace wcx, wcy, wcz à la position du script plus le vecteur de la forme (get_vector). Lit matmask, prend la forme courante (cforme) comme wforme, puis clipform. La première entité trouvée est stockée dans la cible.0conforme
0xa4cwftstmov3 expressions (index de forme, matmask, forme de test) puis 1 cible SComme cwtstmov, mais une expression supplémentaire donne la forme testée (wforme) à la place de la forme courante. Puis clipform et stockage de la première entité trouvée.0conforme
0xa5ctstform2 expressions (matmask, forme) puis 1 cible SFixe wcx, wcy, wcz à la position du script, lit matmask et wforme, puis clipform. La première entité trouvée est stockée dans la cible.1conforme
0xa6cxput1 expression (index du sprite)Dessine un sprite du script courant avec le miroir inversé (invert = xinv xor 1). Les décalages depx, depy, depz et numelem sont mis à 0.3conforme
0xa7cxputat5 expressions (depx, depy, depz, index du sprite, numelem)Comme cxput mais avec décalages explicites. numelem est un mot de 16 bits.12conforme
0xa8cmput1 expression (index du sprite)Dessine un sprite depuis les ressources du main (flagmain=1), avec invert = xinv. Les décalages et numelem sont à 0.0conforme
0xa9cmputat5 expressions (depx, depy, depz, index du sprite, numelem)Comme cmput avec décalages explicites. numelem est un mot de 16 bits.0conforme
0xaacmxput1 expression (index du sprite)Comme cmput. Un bug de l'original applique le xor sur BX et non sur AL : l'octet invert reste xinv, et il n'y a donc aucune inversion supplémentaire. Décalages et numelem à 0.0conforme
0xabcmxputat5 expressions (depx, depy, depz, index du sprite, numelem)Dessin depuis les ressources du main avec invert = xinv xor 1 et décalages explicites. numelem est un mot de 16 bits.0conforme
0xaccmmusic6 expressions : index, volume, tempo, attaque, durée, chuteLance une musique depuis les ressources du main (flagmain=1). Si le type de la ressource n'est pas 0, 3 ou 4, les 5 expressions suivantes sont lues puis ignorées. Sinon volume et tempo sont des octets, attaque, durée et chute des mots bruts transmis au pilote de musique DOS.0plateforme
0xadcmforme1 expression (forme)Écrit la forme courante (cforme) du script MAIN, pas du script appelant. Le préfixe 'm' désigne le main, comme pour cmput et cmsound.0conforme
0xaecsettime3 expressions (heures, minutes, secondes)Évalue les 3 expressions puis appelle une routine qui ne fait que retourner : aucun effet sous DOS.0conforme
0xafcgettime3 cibles de stockage (S S S)Ne lit aucune horloge : l'appel est un simple retour. Les trois cibles reçoivent les valeurs résiduelles des registres (ax=0x00af, cx et bx laissés par le code précédent).0conforme
0xb0cvinput1 cible de stockage (S)Met charmode à 0 et lit un nombre au clavier. Chaque touche est attendue (appui puis relâchement), les codes avec le bit 7 sont ignorés. Seuls '-' et '0' à '9' sont acceptés. BS efface (écho BS, espace, BS). CR termine. Le tampon est converti en valeur (strtoval) et stocké dans la cible.8conforme
0xb1csinput1 cible de stockage (S)Met charmode à 0 et lit une chaîne au clavier. Les touches de code >= 0x80 (octet signé négatif) ne sont jamais prises. BS ne fait rien si le tampon est vide. CR termine la chaîne par un NUL. La chaîne est stockée dans la cible.0conforme
0xb2casleepfar1 expression (distance)Calcule seuil = val*val (32 bits non signé). Parcourt la liste atent en ignorant les entités dont le bit 2 de [vram-0x24] est levé. La somme des carrés des différences de coordonnées (chacune sur 16 bits, multiplication signée) est comparée au seuil, sans signe. Dedans : si [vram-4]==0, il passe à 1 et envoie le message 0x8001. Dehors : s'il est non nul, il passe à 0 et envoie 0x8000. Le message part avec le numéro d'entité script de l'entité CIBLE ([vram-0xe] de la cible).2conforme
0xb3casleeponaucunEfface le bit 2 de l'octet de flags [vram-0x24] de l'entité courante (scan inter activé).26conforme
0xb4casleepoffaucunMet à 1 le bit 2 de l'octet de flags [vram-0x24] de l'entité courante (scan inter désactivé).52conforme
0xb5crunfilm1 expression (batchframes) puis 2 cibles de stockage (S S)Fixe batchframes (nombre d'images du lot), exécute le lecteur de film (runfilm), puis stocke dans l'ordre le numéro de frame du film et son résultat.5conforme
0xb6cvpicprint1 expressionMet charmode à 1 et convertit la valeur en texte, mais le putchar en mode 1 retourne aussitôt : rien n'est affiché sous DOS.0conforme
0xb7cspicprint1 expression de chaîneMet charmode à 1, évalue la chaîne dans le tampon 0x16008 et la parcourt avec putchar, qui est sans effet en mode 1 : rien n'est affiché.0conforme
0xb8cvputprint1 expressionMet charmode à 2 et imprime la valeur comme entier signé 16 bits (signe, zéros de tête supprimés, dernier chiffre toujours présent) avec putchar pour chaque caractère.349conforme
0xb9csputprint1 expression de chaîneMet charmode à 2 et imprime la chaîne octet par octet jusqu'au NUL avec putchar.932conforme
0xbacfont5 expressions (a, b, c, d, e)Si a >= 0 : foasc=a, fonum=b, folarg=(u8)c, fohaut=(u8)d, fomax=e. Si a == -16 : seul l'octet de COULEUR DU TEXTE vaut (u8)b ; c, d, e sont lus et ignorés, et la police est conservée. Les glyphes non nuls sont alors dessinés dans cette couleur. Si a < 0 et a != -16 : foasc=0xffff, fonum=0, b ignoré, puis folarg=c, fohaut=d, fomax=e. Avant la correction : Le port n'a pas de cas spécial : 'font -16,4,0,0,0' écrase la police (fomax=0) et le curseur ne bouge plus. La ligne de sous-titre en couleur de baratin.als est invisible, et 'font -16,0,...' (playfilm.als) efface la police. La couleur n'existe pas dans le port. Écarts mineurs : fonum tronqué à 16 bits (test signé impossible), put_char utilise un octet signé donc les caractères >= 0x80 ne sont pas dessinés. Correction en cours.*93corrigé
0xbbcpaper1 expressionEnregistre l'octet (u8) de la valeur dans une variable que rien d'autre ne lit : sans effet visible.0conforme
0xbcctoblack1 expression (durée)Fondu de la palette vers le noir. Pour 0 < durée < 63, pas = 63/durée + 1 et compteurs initialisés ; sinon compteur 63 et pas durée/63 (division 8 bits, erreur si le quotient dépasse 255). La palette cible est mise à zéro. Si la machine est lente (benchmark <= 200) ou durée == 0, le fondu est instantané. Puis verrouillage, chase, ftopal=1 et skip=0.5plateforme
0xbdcmovcolor2 expressionsLit deux expressions et ne fait rien d'autre (sans effet en VGA 8 bits).0conforme
0xbectopalet2 expressions (index de palette, durée)Fondu vers une palette. Si skip == 0 : un index -1 ou -2 restaure la sauvegarde sav1 ou sav2 en fondu ; un index >= 0 résout la ressource et, si son premier octet vaut 0xfe, lance topalette(durée) (pas = 63/durée+1 sous 63, sinon durée/63+1). Fondu instantané sur machine lente. Puis skip=0.4conforme
0xbfcnumput4 expressions (depx, depy, depz, numelem)Enregistre les décalages depx, depy, depz (mots) et numelem (octet) utilisés par les prochains put.477conforme
0xc0cscheart2 expressions (a, b)Si le mot [vram-0x16] de l'entité est non nul, repère l'écran basemain+id et écrit a en +0x0a et b en +0x0c, puis lève le bit 0x80 de l'état de l'écran. Les 2 opérandes sont toujours lus.0conforme
0xc1cscpos2 expressions (x, y)Si l'écran existe, écrit x en +0x0e et y en +0x10, puis met à jour le sprite de l'écran : +0xc = x&0xfff0, +0xe = y, dword +0x10 = 0x7fff, +0x16 = (x+w)|0xf, +0x18 = y+h. Lève ensuite le bit 0x80 de l'état.2conforme
0xc2cscsize2 expressions (largeur, hauteur)Si l'écran existe, écrit w-1 en +0x12 et h-1 en +0x14, met à jour le sprite de l'écran (aligne newx = x&0xfff0 et depx = (x+w)|0xf pour toutes les versions, n'écrit pas numelem) et lève le bit 0x80 de l'état.2conforme
0xc3cschoriz3 expressions (e1, e2, e3), lues seulement si l'id d'écran est non nulTeste d'abord le mot [vram-0x16]. À 0, aucun opérande n'est lu. Sinon écrit les octets +0x20, +0x21, +0x22 de l'écran (vecteur horizontal) et lève le bit 0x80 de l'état.0conforme
0xc4cscvertic3 expressions (v0, v1, v2)Si l'écran existe, écrit les octets +0x23, +0x24, +0x25 (vecteur vertical), puis calcule la normale : produit vectoriel du vecteur horizontal (0x20-0x22) et du vertical, avec multiplications signées 8 bits. Les mots +0x26, +0x27, +0x28 reçoivent h1*v2-v1*h2, h2*v0-v2*h0, h0*v1-v0*h1 (écritures qui se recouvrent). Lève ensuite le bit 0x80 de l'état.0conforme
0xc5cscreduce3 expressions (a, b, c), la 3e lue seulement si l'écran existeSi l'écran existe, écrit l'octet +0x1d = a, +0x1e = b-1, lit une 3e expression dans +0x1f et lève le bit 0x80 de l'état. Si l'id d'écran est 0, la 3e expression n'est pas lue.0conforme
0xc6cscscaleune expression (valeur d'échelle)Si l'identifiant d'écran (vw[0x16]) est non nul : écrit le résultat (DL) à l'octet +0x1c de l'écran, écrit CL (reliquat de l'évaluation, octet bas de D7 précédent) à l'octet d'état +0, puis y positionne le bit 0x80. Le reliquat écrase donc l'état de l'écran (bizarrerie de l'original).0conforme
0xc7creducingdeux expressionsRange la première expression dans l'octet vram-0x26 et la seconde dans l'octet vram-0x27.96conforme
0xc8cscmapune expression (ignorée), un mot, et un second mot si le premier vaut 0Évalue une expression dont le résultat est jeté. Lit un mot ; s'il vaut 0, cx=0 et lit un second mot. Si l'identifiant d'écran est non nul, écrit le mot dans l'écran à +0x42 et cx (entité courante ou 0) à +0x40.1conforme
0xc9cscdumpaucunNo-op (RET).0conforme
0xcacfindclaune expression : classe recherchée (DL)Parcourt la chaîne d'entités depuis l'indice 0 et retient celles dont l'octet de classe (+0x4c) vaut DL, hors entité courante. Remplit la table des entités trouvées (matent à 0, indices), s'arrête à la première sauf si fallent est non nul, termine par 0xffff, remet fallent à 0 puis exécute crstent (stocke la première trouvée via la table de stockage).0conforme
0xcbcnearclaune expression (distance), un mot immédiat (classe), puis la cible de stockageRecherche de l'entité la plus proche d'une classe : fview=0, distance mise au carré (mul 16x16 non signé) en valnorme ; même parcours trié que cneartyp mais test sur l'octet de classe +0x4c. Même monde, hors soi, test distance/vue, insertion triée, puis crstent et stockage. Bizarrerie : le mot de classe dans DX est écrasé par l'adresse du tampon, donc la comparaison porte en pratique sur 0x30 (classe 48) quand fallent==0.0conforme
0xcccviewcladeux expressions (distance, champ de vue), un mot (classe), puis la cible de stockageComme cnearcla avec fview=1 : distance au carré en valnorme, deuxième expression dans valchamp, puis même boucle de recherche (test de classe +0x4c avec la même bizarrerie du registre DL), crstent et stockage.0conforme
0xcdcinstrutrois expressions : emplacement (slot), indice de ressource, valeur d'instrumentRésout l'adresse de la ressource instrument immédiatement, sans contrôle. Si l'octet à cette adresse vaut 1, 2 ou 6 : slot &= 0x1f, enregistre dans la table des instruments l'adresse+0x10 et la valeur (étendue en signe) pour ce slot.4conforme
0xcecminstrutrois expressions : slot, indice de ressource, valeur d'instrumentIdentique à cinstru mais la table de ressources est celle du script principal (main) au lieu du script courant.0conforme
0xcfcordsprune expressionRange le résultat dans l'octet vram-0x2b (ordre des sprites).9conforme
0xd0caligndeux expressionsPremière expression : encode un alignement selon le bit le plus fort de DL (0x10 donne 4, 8 donne 3, 4 donne 2, 2 donne 1, sinon 0), écrit à vram-0x2c. Seconde expression : écrite à vram-0x2d.0conforme
0xd1cbackstarsix expressionsRange les six valeurs dans des mots globaux (seul le premier est relu), mot final à 0. Si l'identifiant d'écran est >= 0 (signé) : octet d'écran +1 &= 0xe7 ; si la première valeur est non nulle, +1 |= 0x18.0conforme
0xd2cstarringhuit expressionsRange huit expressions dans des mots globaux consécutifs, sans autre effet ; ces valeurs ne sont jamais relues.0conforme
0xd3cengineaucunNo-op (RET).0conforme
0xd4cautobaseaucunNo-op (RET).0conforme
0xd5cqualityune expression (résultat jeté)Évalue une expression et jette le résultat ; aucun effet.4conforme
0xd6chspritequatre expressionsLa première est rangée dans l'octet vram-0x2f ; les trois suivantes sont évaluées puis jetées.0conforme
0xd7cselpaletune expressionÉcrit la valeur (sans masque) dans le drapeau global « skip » de palette, utilisé une fois par le chargeur de palette : à 0 avec une ressource commençant par 0xfe, la palette est appliquée ; le drapeau est ensuite remis à 0.0plateforme
0xd8clinepaletdeux expressionsÉvalue deux expressions sans aucun effet en DOS (palette par ligne non gérée).0conforme
0xd9cautomodeune expression (résultat jeté)Évalue une expression et jette le résultat ; aucun effet.0conforme
0xdacautofileune expression de type chaîneÉchange les pointeurs des tampons de chaînes (sd7/sd6), sans les restaurer, puis évalue une expression de chaîne. Rien d'autre.0conforme
0xdbccancelaucunActive ferase, puis exécute le handler cerase (opcode 0x4a) : les éléments d'écran de l'entité courante sont rendus à la liste libre et détachés de l'écran immédiatement, au lieu d'être marqués pour un effacement différé ; ferase est ensuite remis à 0.0conforme
0xdcccancallaucunMet ferase à 1 puis exécute cerasall : parcourt la liste des éléments d'écran du script, les détache et les met dans la liste libre, puis remet ferase à 0.0conforme
0xddccancenune expression (numéro d'élément, octet bas)Met ferase à 1 puis exécute cerasen : stocke numelem, boucle searchelem/killelem sur l'écran courant jusqu'à ce qu'il n'y ait plus d'élément correspondant, puis ferase = 0.2conforme
0xdecblastune expression (handle d'entité)Met ferase à 1 puis exécute ckill : ignore les valeurs négatives ou nulles (ferase reste alors à 1), sinon tue l'entité (killent efface ses éléments, ferase remis à 0). Avant la correction : Même défaut que ckill : le port ne rejette que les valeurs négatives, donc 0 tue l'entité principale. Correction prévue.68corrigé
0xdfcscbacksix expressions (sback, backprof, x1, y1, x2, y2)Dans cette version DOS, stocke simplement les six valeurs dans des globales (octet sback, mots backprof, x1, y1, x2, y2) et rend la main. Rien n'est initialisé : la fonction est inutilisée ailleurs dans l'exécutable.0conforme
0xe0cscrolpagequatre expressions (spag, pagdx, pagdy, pagcount)Stocke spag (octet), pagdx, pagdy, pagcount (mots) dans les globales de défilement de page ; si spag != 0, met le bit 0x20 de l'octet 0 de l'écran (basemain + id).0conforme
0xe1cmatentaucunMet dans D7 le mot matent de la dernière entrée de tablent (pointée par ptrent) puis continue comme cstore (échange sd7/oldsd7 et storename).2conforme
0xe2cshrinkdeux expressions (index de bitmap, second inutilisé)Réduit un bitmap en mémoire : flagmain = 0, résout le bitmap via adresdes ; seuls les formats 0x00/0x02/0x10/0x12 et 0x14/0x16 sont traités (les autres : retour immédiat). Taille = ((w+1)>>1)*(h+1), doublée pour 0x14/0x16 ; retour si h == 0. Relocalise les offsets de ressources situés au-dessus, retranche la taille des champs +6 et +0xc, met w = 0xf et h = 0, puis déplace la mémoire jusqu'à finprog et réduit finprog.9conforme
0xe3cdefmapune adresse de variable (mot, 0 = main + mot), puis sept expressionsDéfinit une carte : [m-0x400] = e1 ; e2 stocké octets inversés (-0x3fe = poids fort, -0x3fd = poids faible) ; e3/e4 donnent les bornes (-0x3fa, -0x3f8 += e4-1) ; e5..e7 vont en -0x3f4/-0x3f2/-0x3f0 sans bornage à 1. Calcule ensuite par division (diviseur 32 bits complet si l'octet [m-1] est négatif, sinon 16 bits) les champs -0x3c6/-0x3cc/-0x3c4/-0x3ca, met le mot -0x3b6 du SCRIPT appelant à 0, et déduit les compteurs de bits -0x3c0/-0x3be/-0x3bc.2conforme
0xe4csetmapune adresse de variable, puis six expressionsPositionne la fenêtre de carte : -0x3ee, -0x3ec, -0x3ea, -0x3e8 = e1..e4 ; -0x3d6 = e4-1 et -0x3ee += (e4-1)>>1 ; -0x3e6, -0x3e4 = e5, e6 ; -0x3d4 = e6-1 et -0x3ea += (e6-1)>>1 (décalages 16 bits).4conforme
0xe5cputmapune adresse de variable, puis quatre expressionsPlace la carte à l'écran : -0x3e2, -0x3e0, -0x3de = e1..e3 ; e4 = numelem (mot) ; reste de (-0x3de) / (-0x3f0) (division 16 bits non signée) en -0x3d2 ; fmuldes = 0 ; searchelem, sinon createlem (état 2). Effectue le put commun, puis cherche à nouveau l'élément et, s'il existe, met +0x1c = 0xff, +0x23 = +0x21 = 0 et depx/depy/depz depuis -0x3ee/-0x3ec/-0x3ea.1conforme
0xe6csavepalune expressionPour -2 <= v <= -1 uniquement, copie les 0x180 mots (768 octets) de la palette cible vers la palette de sauvegarde 1 (v = -1) ou 2 (v = -2). Toute autre valeur ne fait rien.3conforme
0xe7csczoomtrois expressions (e1, e2, e3)Écrit e1, e2, e3 dans les mots +0x3a, +0x3c, +0x3e de l'écran (basemain + id) puis met le bit 7 de l'octet 0 de l'écran.0conforme
0xe8ctexmapune adresse de variable, puis deux expressions (puis les suivantes selon le type)Configure une texture de carte : la table des entrées est indexée par slot (0x20 octets par entrée). Type 0 : l'entrée est remise à zéro ; type > 0 : résout le bitmap via adresdes (flagmain courant, non effacé), stocke le nombre de bits de la largeur, balaie les lignes opaques (compteur 8 bits par ligne), calcule yorigin et ajuste le masque y avec la table 0,1,3,7,0xf,0x1f,3,0x7f,0xff…0x3fff. Avant la correction : Le port ne partage pas le chemin du type positif pour le type 0 et lit/écrit les champs suivants différemment (+0x10, +0x16, +0x15, +0x1a, +0x1c). Correction prévue.393corrigé
0xe9calloctabune adresse de variable (cellule)Si l'octet [cell-1] est négatif, alloue taille + 0x800 octets (taille = [cell-6-4*(flag&0xf)]), aligne le pointeur de données du handle sur 2 Ko (+4 garde le pointeur brut pour mfree) et met le handle dans [cell]. Ne teste pas si la cellule est déjà non nulle : un second appel fuit l'ancien bloc.3conforme
0xeacfreetabune adresse de variable (cellule)Si l'octet [cell-1] est négatif et [cell] non nul : met [cell] à 0 puis libère le handle (mfree : annule le handle, et récupère la place si le bloc est le plus bas).0conforme
0xebcscantabaucunSimple retour : aucune opérande, aucun effet.0conforme
0xeccneartabaucunSimple retour : aucune opérande, aucun effet.0conforme
0xedcscsunquatre expressions (e1..e4)Écrit e1..e4 dans les mots +0x7c, +0x7e, +0x80, +0x82 de l'écran (basemain + id) puis met le bit 7 de l'octet 0 de l'écran (paramètres du soleil).0conforme
0xeecdarkpalcinq expressions (R, G, B, première couleur, nombre)Stocke R, G, B, first, count en globales et remplit count triplets RGB de dkpalet à partir de first, sans bornage ; dkpalet[0..2] = 0 et fdarkpal = 1. Balaie ensuite les 0x2fd mots à partir de dkpalet[3] (les 256 couleurs) et efface fdarkpal seulement si tous valent 0x100. Avant la correction : Le port ne balaie que dkpalet[3..0xb5] (couleurs 1..60) et ne recalcule que si first < 0x100 : après un assombrissement des couleurs 112..127, fdarkpal peut être remis à 0 à tort. Correction prévue (balayage complet).52corrigé
0xefcscdarktrois expressions (e1, e2, e3)Sur l'écran (basemain + id) : +0x98 = e1 ; e2 résolu par adresdes (flagmain courant, non effacé) dans +0x9a ; +0x9e = e3 et basedark = e3 ; +0xa0 = [[+0x9a]+4]+1 ; si +0x9e < 0, +0x9e = +0xa0 >> 1 (basedark suit). Fixe la base du sélecteur de table sombre sur [+0x9a]+8 et met le bit 7 de l'écran.10conforme
0xf0casettrois expressionsÉcrit les trois valeurs (16 bits) dans les mots +0x18, +0x20, +0x28 de la vram du script courant.2conforme
0xf1camovtrois expressionsAjoute (16 bits) chacune des trois valeurs aux mots +0x18, +0x20, +0x28 de la vram du script courant.0conforme
0xf2cscasettrois expressions (a, b, c)Sur l'écran courant (basemain + identifiant d'écran de la vram) : écrit c en +0x38 et a en +0x34 ; en +0x36 il écrit aussi a en pratique (l'évaluation de c écrase CX par DX, donc b est perdu). Active ensuite le bit « sale » 0x80 de l'octet 0 de l'écran.0conforme
0xf3cscamovtrois expressions (a, b, c)Sur l'écran courant, ajoute (avec bouclage 16 bits) a au mot +0x34, b au mot +0x36 et c au mot +0x38 : déplacement relatif de la caméra. Active le bit « sale » 0x80 de l'écran.0conforme
0xf4cscfollowhuit expressions (e1 à e8)Configure le suivi de caméra sur l'écran courant : mot +0x60 = e1, octet +0x84 = e2, mots +0x86 à +0x8e = e3 à e7, mot +0x90 = e8. Active ensuite le bit « sale » 0x80 de l'octet 0 de l'écran. Avant la correction : Le port écrit les mêmes champs mais n'active jamais le bit 0x80 (contrairement à cscview). Correction : ajouter l'écriture du bit 0x80 en fin de fonction. La subtilité AX/DX sur le 8e opérande est sans effet pour le jeu.14corrigé
0xf5cscviewsix expressionsÉcrit les six valeurs, dans l'ordre, dans les mots +0x64, +0x66, +0x68, +0x6a, +0x6c, +0x6e de l'écran courant (paramètres de vue), puis active le bit « sale » 0x80.5conforme
0xf6cfilmtrois expressions : identifiant de film, ressource, waitclockDémarre un film : la première expression est l'identifiant (stocké), la seconde est résolue vers les données de la ressource elle-même ; addr1 et addr2 pointent à ressource+0x20, le mot bfilm+0x4e est mis à 0, waitclock = troisième expression, et bfilm+0x4a reçoit l'adresse de l'écran. Puis inifilm et enregistrement du nombre de trames (mot bfilm+6). Seul le mot +0x4e est réinitialisé.0conforme
0xf7cwalkmapun décalage de carte (0 = carte main), puis trois expressions (walkhaut, walktete, walkdim)Fait marcher l'entité sur une carte d'altitudes : walkhaut (+0x1aad8, hauteur de marche max), walktete (+0x1aada, tangage / balancement de tête) et walkdim (inutilisé) sont écrits, puis la routine de marche déplace la position selon le vecteur de pas tourné. Elle lance toujours cinq sondes d'altitude anticipées (devant, côtés, 2x) : toute altitude >= 0xff est un mur et bloque le déplacement. Si |walkcz - ocz| > walkhaut, le déplacement est refusé et rien n'est écrit. Résultat stocké : walkcz - walkocz. Pour le flag matériau == 1 avec dword non nul et matmask != 0, landalti ajoute 0xff à l'altitude. Le balancement (walktete > 0) somme 4*(s1-oz) + 2*(s2-oz) + (s4-oz), multiplie la valeur absolue par l'octet haut signé de walktete et compare à son octet bas. Avant la correction : Écarts importants. (1) Les cinq sondes ne sont lancées que si matmask != 0 et avec des vecteurs basés sur la dimension de carte : avec walktete = 0 il n'y a aucune anticipation contre les cellules mur. (2) Sur déplacement refusé, le port appelle landalti et écrit WCZ au lieu de ne rien écrire. (3) Le +0xff d'altitude est ignoré, donc les cellules matériau ne bloquent pas avec walktete = -1. (4) Balancement : l'échantillon 2x est omis et le seuil utilise walkmap3. Correction prévue : vecteurs de pas tournés (cos/sin décalage) << 7, sondes inconditionnelles, aucune écriture au rejet, +0xff réintroduit. Le balancement n'est pas utilisé par le jeu.*61corrigé
0xf8catstmapun décalage de carte (0 = carte main), puis trois expressions x, y, zTeste une position sur la carte : calcule un vecteur polaire (polarmov avec les angles de l'entité), obtient X = (WCX32 + vx) >> 16 et Y = (WCY32 + vy) >> 16, met matmask à 0, appelle landalti et stocke le mot de la cellule (cellule redirigée en cas de surplomb). Hors limites, stocke le mot bas du vecteur polaire Y.10conforme
0xf9cavtstmovaucun opérande de script direct ; une expression (matmask)Teste un déplacement avant de l'appliquer : polarmov avec les vitesses signées (+0x34, +0x38, +0x3c) et les angles de l'entité, positions candidates X, Y, Z (mots hauts de WC32 + vecteur) écrites en 0x16028/2a/2c. matmask = expression, cforme de l'entité, puis clipform et succent avec stockage. Ne positionne pas 0x1602e.67conforme
0xfacavmovaucunAvance l'entité : polarmov avec les vitesses signées (+0x34, +0x38, +0x3c) et les angles ; la partie entière du vecteur est ajoutée (16 bits) aux coordonnées WCX, WCY, WCZ. Les fractions ne sont pas modifiées.7conforme
0xfbcaimquatre expressions : x, y, z et tour maximal par appelOriente l'entité vers un point : polarang donne azimut, élévation et distance. Si la distance est 0, l'azimut reste WCAZ. Quand le tour maximal est < 180, l'écart est borné par rapport à WCAZ avec gestion du bouclage (±360), le résultat étant normalisé à ±359. Stocke S1 = élévation (toujours), S2 = nouvel azimut, S3 = distance.52conforme
0xfccpointpixdeux expressions (x, y)Convertit un point écran (x, y) en coordonnées de scène (cx, cy, cz) via pixtoland, avec le contexte de rendu dérivé de l'entité courante (atent, repli basemain). Sur l'écran : sauvegarde le mot de flags, met le bit 7 si le bit 6 est nul, appelle affiland, puis restaure les flags. Écrit cx, cy, cz, d, n, e dans cet ordre.14conforme
0xfdcchartmapun sous-code, puis selon le cas des expressions de position/rayonOpère sur la carte (map) : sous-codes 0/1 remplissent le bitmap avec 0 ou 0xffff puis lisent un offset de carte ; 2 et 3 écrivent le champ -0x3b6 ; 4 écrit -0x3ae ; 5 écrit -0x3b0 ; toute autre valeur efface un rectangle autour de la position courante (centre = mots WCX/WCY du script courant). Le nombre de mots remplis utilise un décalage logique. Avant la correction : Le port prend le centre dans Alis::$wcx/$wcy (globaux du dernier tstmov, possiblement périmés) au lieu des WCX/WCY du script courant, et utilise un décalage arithmétique signé pour le comptage de remplissage. Correction prévue.9corrigé
0xfecscskytrois expressions (e1, e2, e3)Configure le ciel d'un écran : +0xa2 = e1, +0xa4 = adresse de l'entrée de table de e2 (respecte flagmain sans l'effacer), +0xa8 = e3 puis recalculé à partir de h6c et de la largeur du sprite (division par 0x168, masque 0xff00), et met le bit 7 de l'écran.6conforme
0xffczoomdeux expressionsStocke les deux valeurs dans les mots vram-0x36 et vram-0x38 du script courant, dans cet ordre.16conforme

Les échappements (cesc1 + un octet)

L'instruction 0x01 lit un second octet et saute dans cette table (0x18832).

CodeNomOpérandesEffetUtilisationsÉtat
0x00cnulaucunSimple ret : ne fait rien et ne lit aucun opérande.0conforme
0x01csoundonaucunPositionne l'indicateur son à 1 : autorise le démarrage des effets sonores et leur mixage dans la boucle de tick.4conforme
0x02csoundoffaucunPositionne l'indicateur son à 0 : plus de démarrage ni de mixage des effets sonores.4conforme
0x03cmusiconaucunPositionne l'indicateur musique à 1 : autorise le démarrage de la musique et le mixage de ses voix à chaque tick ; une musique coupée reprend. Avant la correction : Le port ne lit l'indicateur qu'au démarrage d'une musique v2 :1corrigé
0x04cmusicoffaucunPositionne l'indicateur musique à 0 : le mixage des voix de musique cesse aussitôt, la musique devient silencieuse (interrupteur « musique » des préférences). Avant la correction : Le port n'empêchait que le démarrage de la prochaine musique : couper la musique restait sans effet.1corrigé
0x05cdelfilmaucunFerme la vidéo (structure film) : arrête le film en cours, libère le tampon de flux et ferme le fichier ouvert, en remettant les champs à zéro.11conforme
0x06copenfilmune expression (id/flags), une expression chaîne (nom du fichier), une expression (taille du tampon de flux, x1000, min 0x23a50), une expression (cadence), puis une cible de stockageFerme d'abord un film déjà ouvert, ouvre le fichier, règle taille de tampon et cadence, associe l'enregistrement d'écran du script courant (basemain + mot de vram_org-0x16), démarre le film et stocke le mot d'état à la cible. Avant la correction : Le port lit les mêmes opérandes mais ne calcule pas l'enregistrement d'écran du script courant à partir de vram_org ; en cours de correction.9corrigé

Les éléments d'expression

Les expressions sont des suites d'éléments de code pair (jmp [eax*2+0x1884e]) : valeurs, variables, opérateurs, fonctions.

CodeNomOpérandesEffetUtilisationsÉtat
0x00oimmbun octet : constante immédiate signéeCharge l'octet immédiat dans D7 avec extension de signe (-128..127).30455conforme
0x02oimmwun mot 16 bits : constante immédiateCharge le mot immédiat signé dans D7.2838conforme
0x04oimmpune chaîne inline terminée par zéroCopie la chaîne inline du script, terminateur compris, dans le tampon sd7. D7 n'est pas modifié.4125conforme
0x06olocbun mot signé : décalage dans la vramLit l'octet signé à vram + décalage et l'étend sur 16 bits dans D7.381conforme
0x08olocwun mot signé : décalage dans la vramLit le mot à vram + décalage (signé) et le place dans D7.1391conforme
0x0aolocpun mot signé : décalage dans la vramCopie la chaîne située à vram + décalage dans sd7 (strcpy).83conforme
0x0coloctpun mot signé : décalage du tableau de chaînes dans la vramDésigne une cellule de tableau de chaînes (premier indice = D7, autres indices dépéilés de la pile d'expression), puis copie la chaîne dans sd7. Les bornes sont vérifiées (erreurs 0x17, 0x18, 0x1a). La taille d'élément vient de l'octet base-2, y compris pour les tableaux indirects.0conforme
0x0eoloctcun mot signé : décalage du tableau d'octets dans la vramLit une cellule d'un tableau d'octets (premier indice D7, indices supplémentaires dépilés ; foulées 16 bits en direct, dwords et double déréférencement en indirect), étend l'octet signé dans D7. Chaque produit indice*foulée est tronqué à 16 bits ; bornes vérifiées.1conforme
0x10oloctiun mot signé : décalage du tableau de mots dans la vramLit une cellule d'un tableau de mots (DX*2 calculé sur 16 bits, dimensions supplémentaires comme pour oloctc) et place le mot dans D7.28conforme
0x12odirbun octet : décalage dans la vram (non signé)Lit l'octet signé à vram + décalage et l'étend dans D7.4396conforme
0x14odirwun octet : décalage dans la vram (non signé)Lit le mot à vram + décalage et le place dans D7.4884conforme
0x16odirpun octet : décalage dans la vram (non signé)Copie la chaîne située à vram + décalage dans sd7.1362conforme
0x18odirtpun octet : décalage du tableau de chaînes dans la vram (non signé)Désigne une cellule de tableau de chaînes (indice D7 + pile) et copie la chaîne dans sd7, avec vérification des bornes. Entrée très utilisée. Avant la correction : Les opérandes sont identiques, mais tabstring lit la taille d'élément des tableaux indirects à l'octet base-1 au lieu de base-2 : mauvaise cellule pour tout tableau de chaînes indirect. Pas de contrôle de bornes. Correction : xread8($addr) au lieu de xread8($addr+1).1864corrigé
0x1aodirtcun octet : décalage du tableau d'octets dans la vramLit une cellule d'un tableau d'octets (même mécanisme qu'oloctc) et étend l'octet signé dans D7.264conforme
0x1codirtiun octet : décalage du tableau de mots dans la vramLit une cellule d'un tableau de mots (même mécanisme qu'olocti) et place le mot dans D7.12conforme
0x1eomainbun mot signé : décalage dans basemainLit l'octet signé à basemain + décalage et le place dans D7.2595conforme
0x20omainwun mot signé : décalage dans basemainLit le mot à basemain + décalage et le place dans D7.2427conforme
0x22omainpun mot signé : décalage dans basemainCopie la chaîne située à basemain + décalage dans sd7.70conforme
0x24omaintpun mot signé : décalage du tableau de chaînes dans basemainComme oloctp, mais le tableau est dans basemain : cellule de tableau de chaînes (indice D7 + pile), copiée dans sd7.40conforme
0x26omaintcun mot signé : décalage du tableau d'octets dans basemainLit une cellule d'un tableau d'octets de basemain (même mécanisme qu'oloctc) et étend l'octet signé dans D7.323conforme
0x28omaintiun mot signé : décalage du tableau de mots dans basemainLit une cellule d'un tableau de mots de basemain (même mécanisme qu'olocti) et place le mot dans D7.2924conforme
0x2aohimbdeux mots : variable d'entité (décalage dans la vram), puis décalage signé dans la vram de l'autre entitéLe premier mot désigne une entrée d'entité (négative : erreur fatale 0x1b) ; on obtient la vram de l'autre entité via atent. Si cette vram est <= 0 (entité morte ou vide), l'opérande s'arrête sans toucher à D7. Sinon D7 = octet signé à vram_autre + décalage. Avant la correction : Dans la branche v3 (version < 60), le port ne teste pas la vram <= 0 : il lit la mémoire basse et met une valeur parasite dans D7. Correction : tester vram <= 0 pour toutes les versions, et garder le décalage signé.848corrigé
0x2cohimwdeux mots : variable d'entité, puis décalage signé dans la vram de l'autre entitéComme ohimb mais lit un mot (erreur 0x1d si l'entrée est négative). Si la vram cible est <= 0, D7 reste inchangé. Avant la correction : Dans la branche v3 le port lit le mot même pour une entité morte, sans test vram <= 0. Correction : ajouter ce test pour toutes les versions.311corrigé
0x2eohimpdeux mots : variable d'entité, puis décalage signéRetrouve la vram de l'autre entité (sans contrôle de validité) et copie la chaîne à vram_autre + décalage dans sd7.0conforme
0x30ohimtpdeux mots : d'abord le décalage du tableau, puis la variable d'entitéRetrouve la vram de l'entité cible via la variable d'entité (sans contrôle), puis désigne une cellule de tableau de chaînes dans cette vram (indice D7 + pile) et copie la chaîne dans sd7.0conforme
0x32ohimtcdeux mots : d'abord le décalage du tableau, puis la variable d'entitéRetrouve la vram de l'entité cible, lit une cellule d'un tableau d'octets de cette vram et étend l'octet signé dans D7.0conforme
0x34ohimtideux mots : d'abord le décalage du tableau, puis la variable d'entitéComme ohimtc mais lit une cellule d'un tableau de mots de la vram de l'entité cible et place le mot dans D7.0conforme
0x36opileaucunDépile la valeur de la pile d'expression 16 bits : D7 reçoit l'ancien D6 (CX) et D6 reçoit la valeur dépilée.2018conforme
0x38oevalune suite d'opérandes d'expression, terminée par ofinBoucle : évalue les opérandes suivants un par un (sans copier DX dans CX) jusqu'à rencontrer ofin. Les oeval imbriqués fonctionnent grâce à la pile CPU.9316conforme
0x3aofinaucunTermine la boucle d'un oeval. N'apparaît que comme terminateur d'oeval/seval.9316conforme
0x3coimmlsans objet en v31 (entrée nulle dans la table d'origine)Cette entrée n'existe pas dans la version 31 : la table contient 0 et un saut y planterait. Elle n'est jamais utilisée par le jeu.0conforme
0x3eoloctosans objet en v31 (entrée nulle dans la table d'origine)Entrée absente de la version 31 (valeur 0 dans la table). Jamais utilisée.0conforme
0x40opushaccaucunEmpile D7 (mot de 16 bits) sur la pile d'expression. Cette pile est réinitialisée à chaque entrée dans une expression.4530conforme
0x42oandun opérande d'expression (opérande droit)Copie D7 dans D6, évalue l'opérande suivant dans D7, puis D7 = D7 & D6 (ET binaire 16 bits).1148conforme
0x44oorun opérande d'expressionÉvalue l'opérande suivant (D6 = ancien D7) puis D7 = D7 | D6.402conforme
0x46oxorun opérande d'expressionÉvalue l'opérande suivant puis D7 = D7 ^ D6 (OU exclusif).0conforme
0x48oeqvun opérande d'expressionÉvalue l'opérande suivant puis D7 = NON(D7 XOR D6), sur 16 bits (équivalence logique).0conforme
0x4aoegalun opérande d'expressionCompare : D7 vaut 0xffff (-1) si les deux valeurs sont égales, 0 sinon.1888conforme
0x4codiffun opérande d'expressionD7 = -1 si les deux valeurs sont différentes, 0 sinon.727conforme
0x4eoinfegun opérande d'expressionD7 = -1 si gauche (D6) <= droite (D7), comparaison signée 16 bits, sinon 0.432conforme
0x50osupegun opérande d'expressionD7 = -1 si gauche (D6) >= droite (D7), comparaison signée 16 bits, sinon 0.130conforme
0x52oinfun opérande d'expressionD7 = -1 si gauche (D6) < droite (D7), comparaison signée, sinon 0.726conforme
0x54osupun opérande d'expressionD7 = -1 si gauche (D6) > droite (D7), comparaison signée, sinon 0.862conforme
0x56oaddopérande suivant de l'expression (valeur de droite)Addition 16 bits : lit l'opérande suivant dans D7 et fait D7 = gauche + D7, avec repli modulo 16 bits.0conforme
0x58osubopérande suivant de l'expression (valeur de droite)Soustraction 16 bits : D7 = gauche - droite (gauche lu avant, droite est l'opérande suivant).544conforme
0x5aomodopérande suivant de l'expression (diviseur)Modulo signé 16 bits : D7 = gauche mod droite, le reste a le signe du dividende. Un diviseur nul est remplacé par 1, donc x % 0 vaut 0.44conforme
0x5codivaucun (opérande gauche dans l'accumulateur, droit en D7)Division entière signée 16 bits (idiv), quotient tronqué vers zéro dans D7. Si le diviseur vaut 0, il est remplacé par 1 : x/0 = x. Avant la correction : Le port ne remplaçait 0 par 1 que pour version>=60 ; pour Robinson (v31) cdiv() renvoyait 0.307corrigé
0x5eomulaucunMultiplication signée 16x16 bits (imul) ; D7 reçoit les 16 bits de poids faible du produit.342conforme
0x60onegaucunNégation arithmétique de D7 (neg). -32768 reste -32768.40conforme
0x62oabsaucunValeur absolue de D7 : le négatif est inversé. -32768 reste -32768.75conforme
0x64orndaucun (borne en D7)Générateur congruentiel 16 bits : graine = graine*0x7ab7 + 0xf881, puis D7 = mot de poids fort de graine*D7 (non signé). Résultat dans [0, D7[. La graine initiale est 0.360conforme
0x66osgnaucunSigne de D7 : 0 donne 0, négatif donne -1, positif donne 1.10conforme
0x68onotaucunComplément à un de D7 sur 16 bits (not).0conforme
0x6aoinkeyaucunD7 = code ALIS de la touche actuellement maintenue (octet positionné par l'IRQ clavier via une table de traduction), 0 si aucune. La touche n'est pas consommée.130plateforme
0x6cokeyonaucunNe fait rien (simple ret) : ne lit aucun opérande et laisse D7 inchangé.0conforme
0x6eojoyaucun (numéro de joystick en D7)Lit le joystick analogique : renvoie 0 si D7 != 0 (un seul joystick) ou si aucun n'est détecté. Sinon bits 0/1 = axe Y bas/haut, bits 2/3 = axe X, bit 7 = bouton.5plateforme
0x70oprndaucun (dépile un mot de la pile d'expressions, borne en D7)Variante de ornd : la graine dépilée subit un ror 6 sur 16 bits, puis graine' = graine*0x7ab7 + 0xf881 (non stockée) ; D7 = mot de poids fort de graine'*D7.0conforme
0x72oscanaucun (utilise le tampon circulaire du script)Lit un mot dans une file circulaire : -1 si lecture == écriture ; sinon D7 = mot en lecture, le curseur avance de 2 et reboucle (retranche la taille du champ 0x16 de l'en-tête) ; quand la file est vide, le bit 7 de l'octet d'état est effacé.70conforme
0x74oshiftkeyaucunD7 = octet d'état des modificateurs clavier : bit0 Shift gauche, bit1 Shift droit, bit2 Ctrl, bit3 Alt.21plateforme
0x76ofreeaucun (sélecteur en D7)Mémoire/disque libre : 0..4 donnent des tailles de zones mémoire ou la longueur d'une liste ; 'A'..'D' (majuscule ou minuscule) donnent l'espace disque libre (/1000, plafonné à 0x7d00) ; toute autre valeur donne -1.15conforme
0x78omodelaucunD7 = 2000 + n selon l'octet vidéo du setup : n = 4, 5 ou 6 pour les modes 5, 6, 8, sinon 2000 (donc 2000, 2004, 2005 ou 2006).22conforme
0x7aogetkeyaucunAttend bloquant qu'une touche soit pressée, puis qu'elles soient toutes relâchées ; D7 = code de la touche.4plateforme
0x7coleftune expression chaîne (dépilée), longueur en D7Garde les D7 premiers caractères de la chaîne : écrit un NUL à l'offset D7 & 0xff du tampon chaîne.4conforme
0x7eorightune expression chaîne (dépilée), longueur en D7Garde les D7 derniers caractères : dépile la chaîne dans le tampon, calcule src = fin - D7 (borné au début) et recopie jusqu'au NUL au début du tampon. Avant la correction : Le port avait une fonction vide : la chaîne n'était pas dépilée (pile d'expressions désynchronisée) et aucun résultat. Aucun script n'utilise right() ; en cours d'implémentation.0corrigé
0x80omidune expression chaîne (dépilée), départ (mot signé dépilé), longueur en D7Sous-chaîne : calcule src = tampon + départ avant de dépiler la chaîne, puis copie en do-while au moins un octet, jusqu'à la longueur ou au NUL, et termine par NUL. Avec une longueur <= 0 il copie quand même un caractère.22conforme
0x82olenaucun (chaîne courante)D7 = longueur (strlen) de la chaîne du tampon courant.23conforme
0x84oascaucun (chaîne courante)D7 = premier octet de la chaîne, étendu à zéro (0..255).0conforme
0x86ostraucun (valeur en D7)Convertit D7 en chaîne décimale dans le tampon : '-' optionnel, jusqu'à 5 chiffres, zéros de tête supprimés, dernier chiffre toujours écrit. -32768 donne '-32768'.28conforme
0x88osaddune expression chaîne (opérande droit)Concaténation : échange les tampons, évalue l'opérande droit, l'ajoute à la chaîne gauche, réechange ; le résultat est dans le tampon courant.74conforme
0x8aosequalune expression chaîne (opérande droit)Compare gauche et droite octet par octet ; si la gauche se termine la première, elles sont égales (règle du préfixe). D7 = -1 si égal, sinon 0. Les tampons restent échangés.20conforme
0x8cosdiffune expression chaîne (opérande droit)Négation de osequal, avec la même règle du préfixe.0conforme
0x8eosinfegune expression chaîne (opérande droit)Inférieur ou égal sur chaînes : à la première différence, compare la différence d'octets en signé (octets >= 0x80 négatifs) ; règle du préfixe. D7 = -1 ou 0.0conforme
0x90ossupegune expression chaîne (opérande droit)Supérieur ou égal sur chaînes, via la différence d'octets signée (jnl), règle du préfixe. D7 = -1 ou 0.0conforme
0x92osinfune expression chaîne (opérande droit)Strictement inférieur sur chaînes, via la différence d'octets signée (jl), règle du préfixe. D7 = -1 ou 0.0conforme
0x94ossupune expression chaîne (opérande droit)Strictement supérieur sur chaînes, via la différence d'octets signée (jg), règle du préfixe. D7 = -1 ou 0.0conforme
0x96ospushaccaucunEmpile la chaîne courante, NUL compris, sur la pile d'expressions.34conforme
0x98ospileaucun (chaîne dépilée de la pile d'expressions)Échange les deux tampons chaîne puis dépile la chaîne de la pile dans le second : l'ancienne chaîne courante devient l'opérande gauche (équivalent chaîne de opile).8conforme
0x9aovalaucun (chaîne courante)Convertit la chaîne en entier 16 bits : vide donne 0 ; '-' optionnel ; '$' + chiffres hexadécimaux (insensible à la casse) ou chiffres décimaux ; s'arrête au premier caractère invalide ; négation finale.0conforme
0x9coexistfaucun (nom de fichier dans la chaîne courante)Teste l'existence d'un fichier en l'ouvrant : D7 = -1 s'il existe, 0 sinon.16plateforme
0x9eochraucun (code en D7)Fabrique une chaîne d'un caractère : tampon[0] = D7 (octet bas), tampon[1] = 0.13conforme
0xa0ochangeaucun (code lecteur en D7)Change ou lit le lecteur courant : '?' renvoie le lecteur courant ; une lettre a-z/A-Z sélectionne le lecteur (A=0). Résultat : 0 si invalide, sinon la LETTRE du lecteur ('A'+n). Sur disque dur, change('?') renvoie 'C' (67) ou plus. Avant la correction : Le port renvoyait toujours 0 : change('?') < 67 était vrai et les scripts prenaient le chemin disquette (messages « insérez une disquette de sauvegarde »).43corrigé
0xa2ocountryaucunD7 = code clavier issu du setup : AZERTY = 1, QWERTZ = 2, sinon (QWERTY) 0.0plateforme
0xa4omipaucunD7 = indice de vitesse CPU : nombre d'itérations d'une boucle entre deux ticks du timer, plafonné à 0x7fff puis divisé par 40.1plateforme
0xa6ojoykeyaucunRenvoie toujours 0 (D7 = 0), sans opérande.0conforme
0xa8oconfigaucunD7 = mot de configuration matérielle : bit0 joystick A, bit1 joystick B, bit2 souris, bit6 (0x40) vitesse CD suffisante ; le bit 7 n'est jamais mis. Typique : 0x44, ou 0x45/0x47 avec joysticks. Avant la correction : Le port renvoyait 0x87 (bit 6 absent, bit 7 en trop). Les branches actuelles des scripts donnent le même résultat ;3corrigé
0xaaogettextaucunAbsent de la table originale v3 (entrées 85 à 87 nulles ; sauter à cette entrée planterait). Existe seulement dans les jeux ultérieurs.0plateforme
0xacoipsaucunAbsent de la table originale v3 (entrée nulle) ; opérateur des versions v6.0plateforme
0xaeunknownaucunDernière entrée nulle de la table originale, avant la table des storenames. Inutilisée.0conforme

Les cibles de rangement

Où cstore range le résultat d'une expression (table 0x189ae).

CodeNomOpérandesEffetUtilisationsÉtat
0x06slocbun mot : offset signé (16 bits) dans les variables localesStocke l'octet bas de la valeur (D7) à vram + offset (vb[off] = ...), l'offset pouvant sortir de 0..255.157conforme
0x08slocwun mot : offset signéStocke le mot 16 bits D7 à vram + offset (vw[off] = ...).192conforme
0x0aslocpun mot : offset signéCopie la chaîne évaluée (tampon sd7 après échange par cstore), terminateur compris, vers vram + offset (vs[off] = ...).34conforme
0x0csloctpun mot : offset signé de la table de chaînesCible un élément de table de chaînes (ts[...]) : premier indice = D7, indices suivants dépilés de l'accumulateur de mots, avec contrôle des bornes (erreurs 0x17/0x18) et double indirection des tables à pointeurs (erreur 0x1a si nul). Copie ensuite la chaîne évaluée dans l'élément.0conforme
0x0esloctcun mot : offset signé de la table d'octetsCible un élément de table d'octets (tb[...]) : indice = D7 puis mots dépilés de l'accumulateur. Dépile la valeur à stocker et écrit son octet bas.1conforme
0x10sloctiun mot : offset signé de la table de motsCible un élément de table de mots (tw[...]) : premier indice doublé, indices suivants dépilés de l'accumulateur. Dépile la valeur et écrit le mot.21conforme
0x12sdirbun octet : offset non signé (0..255)Stocke l'octet bas de D7 à vram + offset (vb[off] = ...).1560conforme
0x14sdirwun octet : offset non signéStocke le mot 16 bits D7 à vram + offset (vw[off] = ...).1046conforme
0x16sdirpun octet : offset non signéCopie la chaîne évaluée vers vram + offset (vs[off] = ...).929conforme
0x18sdirtpun octet : offset non signé de la table de chaînesStocke la chaîne évaluée dans un élément de table de chaînes (ts[...]) adressé par indice(s) évalué(s). L'original contrôle indices et pointeurs nuls (erreurs 0x17/0x18/0x1a).1844conforme
0x1asdirtcun octet : offset non signé de la table d'octetsDépile la valeur de l'accumulateur et stocke son octet bas dans l'élément tb[...] désigné.228conforme
0x1csdirtiun octet : offset non signé de la table de motsDépile la valeur de l'accumulateur et stocke le mot dans l'élément tw[...] désigné (indice doublé).8conforme
0x1esmainbun mot : offset signé relatif à basemain (variables du script principal)Stocke l'octet bas de D7 à basemain + offset (mb[off] = ...).577conforme
0x20smainwun mot : offset signé relatif à basemainStocke le mot 16 bits D7 à basemain + offset (mw[off] = ...).216conforme
0x22smainpun mot : offset signé relatif à basemainCopie la chaîne évaluée vers basemain + offset (ms[off] = ...).63conforme
0x24smaintpun mot : offset signé de la table de chaînes, base = basemainStocke la chaîne évaluée dans un élément de table de chaînes du script principal (mts[...]), indices pris dans D7 puis l'accumulateur.12conforme
0x26smaintcun mot : offset signé de la table d'octets, base = basemainDépile la valeur et stocke son octet bas dans un élément de table d'octets du script principal (mtb[...]).252conforme
0x28smaintiun mot : offset signé de la table de mots, base = basemainDépile la valeur et stocke le mot dans un élément de table de mots du script principal (mtw[...]), indice doublé.1870conforme
0x2ashimbdeux mots signés : off1 (variable locale contenant un numéro d'entité), off2 (offset dans le script cible)Écrit l'octet bas de D7 dans les variables d'un autre script (hb[var, off] = ...) : le mot signé à vram+off1 indexe la table des entités ; une valeur négative donne l'erreur 0x1f. Si le vram de la cible est <= 0 (script mort ou non démarré), l'écriture est ignorée. Avant la correction : Divergence : le test « vram <= 0 » n'existe que pour la version >= 60 et l'entité est lue non signée. Sur la v31, une cible morte fait écrire l'octet à mem[off2], corrompant la mémoire basse. Correction : toujours ignorer si vram <= 0 et lire l'entité en signé.738corrigé
0x2cshimwdeux mots signés : off1 (variable locale contenant un numéro d'entité), off2 (offset dans le script cible)Comme shimb mais écrit un mot 16 bits (hw[var, off] = ...). Entité négative : erreur 0x21. Écriture ignorée si le vram de la cible est <= 0. Avant la correction : Même défaut que shimb : sur la v31, une cible morte fait écrire 2 octets à mem[off2], et l'entité est lue non signée. Correction : return si vram <= 0 pour toutes les versions, s16 sur l'entité.58corrigé
0x2eshimpdeux mots signés : off1 (variable locale contenant un numéro d'entité), off2 (offset dans le script cible)Copie la chaîne évaluée dans les variables d'un autre script (hs[var, off] = ...) : cible = vram de l'entité (sans test de nullité), destination = cible + off2, terminateur compris.0conforme
0x30shimtpdeux mots : offset de la table dans le script cible, puis offset de la variable locale contenant le numéro d'entitéStocke la chaîne évaluée dans un élément de table de chaînes d'un autre script (hts[...]) : base = vram de l'entité (sans test de nullité), indices pris dans D7 puis l'accumulateur.0conforme
0x32shimtcdeux mots : offset de la table dans le script cible, offset de la variable d'entitéDépile la valeur et stocke son octet bas dans un élément de table d'octets d'un autre script (htb[...]), base = vram de l'entité.0conforme
0x34shimtideux mots : offset de la table dans le script cible, offset de la variable d'entitéDépile la valeur et stocke le mot dans un élément de table de mots d'un autre script (htw[...]), indice doublé, base = vram de l'entité.0conforme
0x36spileaucunEmpile la valeur 16 bits D7 sur l'accumulateur de mots.0conforme
0x38sevalune expression terminée par ofin, puis un octet : code de la cible de stockage suivanteRemet l'accumulateur à son origine, empile D7, évalue la chaîne d'indices jusqu'à ofin, puis lit le code suivant et saute vers la cible de stockage (stockages de tables ts/tb/tw/mts/mtb/mtw).4236conforme
0x3aofinaucunTermine la boucle d'évaluation d'une expression. Comme cible de stockage il n'est jamais utilisé : il n'apparaît qu'en fin de chaîne seval.0conforme

Les cibles d'ajout

Où cadd / csub ajoutent ou retirent le résultat d'une expression (table 0x18a26).

CodeNomOpérandesEffetUtilisationsÉtat
0x06alocbun mot : offset signé dans les variables localesAjoute l'octet bas de D7 à l'octet vram + offset (vb[off] += ..., retour sur 8 bits). Le drapeau zéro résultant est celui que teste cloop.10conforme
0x08alocwun mot : offset signéAjoute le mot 16 bits D7 au mot vram + offset (vw[off] += ...). Le drapeau zéro est testé par cloop.43conforme
0x0aalocpun mot : offset signéConcatène la chaîne évaluée à la fin de la chaîne située à vram + offset (vs[off] += ...), NUL compris, sans limite de longueur. Le drapeau zéro n'a pas de sens ici.12conforme
0x0caloctpun mot : offset signé de la table de chaînesConcatène la chaîne évaluée à un élément de table de chaînes (ts[...] += ...) : indice D7 multiplié par la taille d'élément, dimensions suivantes dépilées, contrôles de bornes (erreurs 0x17/0x18/0x1a).0conforme
0x0ealoctcun mot : offset signé de la table d'octetsDépile la valeur et l'ajoute à l'octet de l'élément tb[...] désigné (bornes contrôlées, erreurs fatales 0x17/0x18/0x1a). Positionne le drapeau zéro.0conforme
0x10aloctiun mot : offset signé de la table de motsDépile la valeur et l'ajoute au mot de l'élément tw[...] désigné (indice doublé, bornes contrôlées).0conforme
0x12adirbun octet : offset non signé (0..255)Ajoute l'octet bas de D7 à l'octet vram + offset (vb[off] += ...). Le drapeau zéro sert à cloop.272conforme
0x14adirwun octet : offset non signéAjoute le mot 16 bits D7 au mot vram + offset (vw[off] += ...). Le drapeau zéro sert à cloop.227conforme
0x16adirpun octet : offset non signéConcatène la chaîne évaluée à la chaîne vram + offset (vs[off] += ...).328conforme
0x18adirtpun octet : décalage non signé dans vramLit une cellule chaîne via ce décalage (relatif à vram) puis concatène à cette chaîne la chaîne d'expression courante (oldsd7, buffer 0x16010).0conforme
0x1aadirtcun octet : décalage dans vram (cellule octet de tableau)Résout la cellule octet (indices pris dans dx et la pile d'expression), dépile une valeur et l'ajoute à l'octet ciblé (add 8 bits).0conforme
0x1cadirtiun octet : décalage dans vram (cellule mot de tableau)Résout la cellule mot (index*2), dépile une valeur et l'ajoute au mot ciblé (add 16 bits).0conforme
0x1eamainbun mot signé 16 bits : décalage relatif à basemainAjoute l'octet de D7 à l'octet situé à basemain+décalage (add 8 bits) et positionne ZF, utilisable par un loop.42conforme
0x20amainwun mot signé 16 bits : décalage relatif à basemainAjoute D7 (16 bits) au mot situé à basemain+décalage et positionne ZF.137conforme
0x22amainpun mot signé 16 bits : décalage relatif à basemainConcatène la chaîne d'expression courante (oldsd7) à la chaîne située à basemain+décalage.2conforme
0x24amaintpun mot signé 16 bits : décalage du tableau de chaînes dans basemainRésout une cellule de tableau de chaînes (indices en pile, décalage signé) et y concatène la chaîne d'expression courante. Avant la correction : Le port lit le décalage en non signé : différence uniquement pour les décalages >= 0x8000 ; correction prévue (s16).0corrigé
0x26amaintcun mot signé 16 bits : décalage du tableau d'octets dans basemainRésout la cellule octet du tableau (décalage signé, bornes vérifiées), dépile une valeur et l'ajoute à cet octet.2conforme
0x28amaintiun mot signé 16 bits : décalage du tableau de mots dans basemainRésout la cellule mot (index*2 en 16 bits, dimensions supplémentaires dépilées et multipliées par les dimensions stockées), dépile une valeur et l'ajoute au mot.63conforme
0x2aahimbdeux mots signés 16 bits : off1 (variable de vram contenant l'id d'un autre script), off2 (décalage dans la vram de ce script)Retrouve la vram d'un autre script (pointeur via la table atent, erreur 0x1f si id invalide) ; si le pointeur est > 0, ajoute l'octet de D7 à l'octet en [vram+off2], sinon ignore l'ajout (les opérandes sont quand même consommés).0conforme
0x2cahimwdeux mots signés 16 bits : off1 (variable avec l'id du script), off2 (décalage dans sa vram)Comme ahimb mais en 16 bits (erreur 0x21) : ajoute D7 au mot en [vram_autre+off2], seulement si le pointeur de vram est > 0. Avant la correction : Le port lit off1 et off2 en non signé et ne teste pas pointeur > 0 : un emplacement de script vide écrit à l'adresse 0+off2 (corruption mémoire) là où l'original ignore ; off2 négatif devient +0xFFxx. Correction en cours (s16, test > 0, ZF).0corrigé
0x2eahimpdeux mots signés 16 bits : off1 (variable avec l'id du script), off2 (décalage dans sa vram)Retrouve la vram de l'autre script, ajoute off2 à son adresse (sans test > 0) et concatène la chaîne d'expression courante à la chaîne ainsi désignée.0conforme
0x30ahimtpdeux mots signés 16 bits : A (décalage du tableau), B (variable contenant l'id du script)Prend la vram de l'autre script désignée par la variable B, résout la cellule de tableau de chaînes à l'offset A (indices en pile) et y concatène la chaîne d'expression courante.0conforme
0x32ahimtcdeux mots signés 16 bits : A (décalage du tableau d'octets), B (variable contenant l'id du script)Résout une cellule octet dans la vram d'un autre script (indices depuis dx et la pile), dépile une valeur et l'ajoute à cet octet.0conforme
0x34ahimtideux mots signés 16 bits : A (décalage du tableau de mots), B (variable contenant l'id du script)Comme ahimtc mais sur une cellule mot (index*2) : dépile une valeur et l'ajoute au mot de l'autre script.0conforme
0x36spileaucunEmpile la valeur D7 sur la pile d'expression (partagée avec storename 24). Dans le contexte de cadd, la pile vient d'être réinitialisée, donc la valeur est effectivement écartée à l'instruction suivante.0conforme
0x38aevalaucun opérande propre ; consomme ensuite le flux d'opernames jusqu'à ofin puis un octet de code d'addnameRéinitialise la pile d'expression, empile D7, évalue la suite d'opernames jusqu'à ofin, puis lit un octet et saute à la cible addname suivante.65conforme
0x3aofinaucunUtilisé comme cible d'addname, il abandonne l'adresse de retour de la boucle principale et sort de l'interpréteur : l'exécution du script s'arrête pour cette trame (dans cloop, sortie sans branchement).0conforme

▶ Jouer