Site logo

Triceraprog
La programmation depuis le Crétacé

  • Récréation 3D, Micral N ()

    Je l'avais brièvement mentionné il y a presque un an : j'ai eu la chance de pouvoir travailler avec l'association M05.COM à l'analyse et restauration d'un exemplaire de « Micral N ».

    Entre deux analyses, j'ai reproduis cet exemplaire en modèle 3D, que je présente ici dans un rendu assez simple.

    J'y voyais deux intérêts. Le premier est que c'est pour moi une façon d'étudier l'aspect extérieur d'une machine. Dans le cas de celle-ci, est-ce que j'ai bien vu tous les détails ? Est-ce que j'ai bien vu toutes les LEDs et tous les interrupteurs. L'exercice de modélisation force à se pencher sur les détails.

    En comparant les photos, on peut aussi voir les différences entre différents exemplaires. Par exemple, l'exemplaire de l'association a un interrupteur ajouté sur la droite du panneau de contrôle par rapport aux autres exemplaires dont les photos sont disponibles.

    Le deuxième intérêt est que cette modélisation pourra servir pour l'émulateur « grand public » (toute proportion gardée), afin de manipuler le clone virtuel de cette machine.

    Reproduction en image de synthèse de l'exemplaire Micral N de l'association MO5

    L'exemplaire original, lui, peut-être vu dans cet article de blog sur le site de l'association.


  • La Maison dans la colline, partie 3 ()

    Suite de la série sur le développement du jeu La maison dans la colline sur VG5000µ. Après, un exposé du contexte dans la première partie, puis un aperçu des outils utilisés dans la seconde partie, cet article aborde l'idée du jeu et de son évolution au fur et à mesure du développement.

    La première idée

    LE VG5000µ est une machine que je commence à bien connaître, et, comme expliqué dans le premier article, j'étais en train d'approfondir les capacités du VDP lorsque ce petit défi a commencé. Je voulais me servir des mes nouvelles connaissances et je suis parti sur l'idée de faire un affichage « fin » et sans clignotement.

    L'idée de faire un jeu d'aventure graphique me trottait dans la tête depuis quelques temps, et c'est un genre qui collait bien à mes objectifs. Peu de mouvements à l'écran, donc l'affichage pourrait être maîtrisé.

    Initialement, le jeu se passe dans un manoir, c'est-à-dire un lieu avec de nombreuses pièces. Et puis, c'est le classique des jeux graphiques ou textuels, repris aussi par des standards comme « Alone in the Dark » en jeu vidéo, ou « Mansions of Madness » en jeu de plateau. Les jeux où le but est de sortir d'une maison fermée ne manquent pas.

    Rapidement, je fais quelques croquis pour me fixer une idée de ce à quoi le jeu ressemblerait. Un peu de place pour l'affichage de la pièce courante vue de dessus, de la place pour un texte et un inventaire.

    Premières notes manuscrites du jeu.

    Creuser les idées

    Dans ce genre de jeux, il s'agit de résoudre des énigmes qui prennent la forme de trouver les bons objets pour les amener aux bons endroits. Il peut y avoir quelques énigmes plus complexes à résoudre, mais je veux m'arrêter là. Le temps va passer vite, et il faut rester sur du faisable, et sachant que ça sera déjà probablement trop.

    Je lance quelques idées d'objets. Une torche électrique. Une boite d'allumettes. Ah, donc autant remplacer la torche pas une lanterne à allumer. Des livres. Des clés. C'est vague, mais cela me permet de définir quels types d'interactions le personnage du jeu peut avoir. Ah, et des portes aussi.

    Au tout début, les interactions sont nombreuses : prendre, lire, utiliser, combiner, poser, ouvrir... Mais je sens que cela va faire beaucoup. Je voudrais aussi essayer que le jeu soit jouable avec la manette, à un seul bouton (ce ne sera pas le cas au final). Cette contrainte me fait réfléchir à réduire le nombre d'interactions, ou en tout cas de faire en sorte qu'elles soient automatiques : si je fais une action sur un livre, c'est pour le lire. Si je fais une action devant une porte en ayant une clé, c'est pour l'ouvrir. Et ainsi de suite. Mais pour le moment, je ne creuse pas plus avant. Je laisse cette idée mûrir.

    Je veux aussi me détacher des jeux d'époque dont une partie de la difficulté est de comprendre comment manipuler le jeu. De ce côté-ci, je veux apporter de la modernité (toute relative) : en jouant, les objets sur lesquels ont peut agir doivent être facilement identifiables, et les actions possibles indiquées en fonction du contexte. Ça va probablement raboter la durée du jeu, mais cela sera beaucoup plus agréable.

    Concernant la durée d'ailleurs, je ne vise pas quelque chose de très long. Les quelques personnes susceptibles de jouer à ce jeu ne cherchent probablement pas une expérience de douze heures. Ni même d'une heure. Trente minutes pour quelqu'un qui ne connaît pas la solution, ça semble bien. Même si je cherche à ce que le jeu soit agréable à jouer et un bon moment à passer, c'est avant tout une preuve de concept d'affichage sur VG5000µ. Et c'est un hobby à mes heures perdues.

    Ci-dessous, une maquette préliminaire du jeu avec des essais de rendu. On y voit un essaie de personnage plus large. Les portes sont différentes aussi.

    Maquette préliminaire du jeu.

    Évolutions

    Toutes ces idées, je les notes sur un carnet (électronique), et je n'hésite pas à les annoter, les modifier, les corriger, en fonction des développements, du temps qui passe, des choses plus faciles à programmer que d'autres, des simplifications,... Cette espèce de document de design est un document vivant, que j'adapte au fur et à mesure.

    Je commence à coller un scénario sur mes éléments de gameplay, afin d'expliquer les contraintes. Pourquoi est-ce que le personnage ne peut pas sortir de la maison une fois qu'il y est entrée. Que s'est-il passé dans les différentes pièces.

    En retour, le scénario influe sur le design. Comment est-ce que j'agence les pièces, quels objets vont dans quelles pièces, qu'est-ce que je fais faire aux gens qui jouent ?

    C'est allers et retours entre conception du jeu, de niveaux, du scénario et du programme nourrissent peu à peu ces différentes parties et les font avancer de concert.

    Le manoir initial se transforme en une maison à moitié troglodyte, car c'est un moyen assez « simple » d'avoir un environnement d'intérieur de maison et de grotte dans un espace assez restreint. C'est un peu tiré par les cheveux mais bon, on est dans du jeu vidéo rétro. Je me trouve même assez sobre par rapport à certaines productions.

    Petit à petit se construit aussi un double objectif afin de pouvoir terminer le jeu. Sortir de la maison, mais aussi pouvoir reprendre la voiture qui nous a amené sur les lieux.

    J'ajoute aussi un peu de « lore » avec quelques objets qui ne sont pas nécessaires, mais qui font transparaître une histoire assez simple, mais je pense suffisante pour l'ambition toute relative de ce jeu. J'ai donc écrit un petit background sur les évènements passés de cette maison. Qui sait ? Peut-être que je compléterai l'histoire grâce à d'autres jeux dans le futur.

    Léger

    La constante, c'est de rester léger. Comme je l'ai évoqué, c'est un petit défi de programmation hobbyiste. Il ne faut surtout pas hésiter à couper, et donc prévoir des choses de manières à ce qu'elles puissent facilement être enlevées en modifiées.

    Je suis assez satisfait du résultat, même si j'y vois plein de petites erreurs, ou maladresses, en y jouant.

    Diagramme montrant les étapes du jeu.


  • Mattel Aquarius, scan des touches en assembleur ()

    Le scan du clavier, sur Mattel Aquarius, à lieu dans la ROM à l'adresse $1e80. Cette fonction traite les minuscules, les majuscules mais aussi les raccourcis BASIC, en injectant au fur et à mesure les touches nécessaires comme si elles avaient été tapées au clavier.

    C'est beaucoup trop pour un scan de clavier dans un jeu, et peut même poser quelques soucis. Mais c'est une bonne base pour écrire une routine de lecture de clavier, car la lecture des valeurs des touches n'est pas forcément très simples.

    Ce que nous apprends la lecture de la routine en ROM est qu'il semble falloir attendre une stabilité dans les valeurs avant d'accepter la touche. En effet, la routine fait plusieurs lectures et ne considère la touche appuyée que si cette lecture est stable.

    Voici une version de la routine, où j'ai enlever ce qui était traitement de raccourcis BASIC, ainsi que le traitement des touches de modifications. Ainsi, la traduction ne se fait qu'avec les touches minuscules.

    Attention, je n'ai pas encore testé cette routine sur du matériel réel !

    La routine

    Dans cette version, le décodage de la touche est faite par rapport aux minuscules. En changeant vers la fin la valeur de HL de lower_key_table-1 vers upper_key_table-1, il est possible d'obtenir un décodage avec des majuscules.

    Il est aussi possible de ne traiter que des codes de touches, sans traductions. Dans ce cas là, il suffit de remplacer les trois instructions après accept_key par un simple LD A, E.

    Les deux emplacements en RAM, qui commencent ce code source, doivent être en RAM et être adaptés à votre programme.

    latest_keycode_pressed: EQU     0380eh
    keyword_delay_value:    EQU     0380fh
    
    lower_key_table:        EQU     01f38h
    upper_key_table:        EQU     01f66h
    
    check_key:
        EXX
    
        LD         BC,0xff
        IN         A,(C)
        CPL
        AND        0x3f
        LD         HL,latest_keycode_pressed
        JR         Z,no_key_scanned            ; ?No row were selected, quick skip?
        LD         B,0x7f                      ; Input row 7
        IN         A,(C)
        CPL
        AND        0xf                         ; Only 4 keys in lower bits
        JR         NZ,decode_key_scan
        LD         B,0xbf                      ; Input rows 6 to 0
    
    loop_input_rows:
        IN         A,(C)
        CPL
        AND        0x3f                        ; 5 keys in lower bits
        JR         NZ,decode_key_scan
        RRC        B
        JR         C,loop_input_rows
    
    no_key_scanned:
        INC        HL
        LD         A,0x46
        CP         (HL)                        ; Compare with delay
        JR         C,return_no_key_value
        JR         Z,reset_latest_key
        INC        (HL)                        ; Increment delay
    
    return_no_key_value:
        XOR        A
        EXX
        RET
    
    reset_latest_key:
        INC        (HL)
        DEC        HL
        LD         (HL),0x0
        JR         return_no_key_value
    
    decode_key_scan:
        LD         DE,0x0
    
    count_row:
        INC        E
        RRA
        JR         NC,count_row
        LD         A,E                         ; E is the active row
    
    count_add_column:
        RR         B
        JR         NC,keycode_found
        ADD        A,0x6                       ; Add 6 for each column
        JR         count_add_column
    
    keycode_found:
        LD         E,A
        CP         (HL)                        ; HL = 0380eh
        LD         (HL),A
        INC        HL
        JR         NZ,new_key_delay            ; That's a new key, we need a bit of selay
        LD         A,0x4
        CP         (HL)
        JR         C,commit_key_delay_continued
        JR         Z,accept_key                ; Wait if over, accept key!
        INC        (HL)                        ; Increment delay from 4 to 6 iteratively
        JR         return_no_key_value
    
    commit_key_delay_continued:
        LD         (HL),0x6                    ; Set the delay for the second pass
        JR         return_no_key_value
    
    new_key_delay:
        LD         (HL),0x0
        JR         return_no_key_value
    
    accept_key:
        LD         IX,lower_key_table-1
        ADD        IX,DE
        LD         A,(IX+0x0)                  ; Read decoded Key value
    
    return_key_value
        EXX
        RET
    

  • Mattel Aquarius, entrées des commandes BASIC ()

    Commençant à étudier le Mattel Aquarius afin de participer à la nouvelle session de « Retro Programmers United for Obscure Systems », et devant le manque de documentation, j'ai regardé ce qu'il y avait dans la ROM. Et c'est un BASIC Microsoft qui y est implémenté, ce qui est bien pratique puisque c'est un BASIC que j'ai bien étudié à travers le VG5000µ.

    J'ai donc ressorti ma trousse à outils et voici la liste des points d'entrées des commandes et fonctions du BASIC.

    La première colonne est le token BASIC, la seconde l'adresse du point d'entrée en ROM et la troisième le nom.

    Les commandes

        128     $0c21         end
        129     $05bc         for
        130     $0d13         next
        131     $071c         data
        132     $0893         input
        133     $10cc         dim
        134     $08be         read
        135     $0731         let
        136     $06dc         goto
        137     $06be         run
        138     $079c         if
        139     $0c05         restore
        140     $06cb         gosub
        141     $06f8         return
        142     $071e         rem
        143     $0c1f         stop
        144     $0780         on
        145     $07b5         lprint
        146     $1b15         copy
        147     $0b3b         def
        148     $0b6d         poke
        149     $07bc         print
        150     $0c4b         cont
        151     $056c         list
        152     $0567         llist
        153     $0ccd         clear
        154     $1c2c         cload
        155     $1c08         csave
        156     $1a4f         pset
        157     $1a4c         preset
        158     $1ad6         sound
        159     $0bbd         new
    

    Les fonctions

        178     $14f5         sgn
        179     $15b1         int
        180     $1509         abs
        181     $3803         usr
        182     $10a8         fre
        183     $0b2e         lpos
        184     $0b33         pos
        185     $1775         sqr
        186     $1866         rnd
        187     $1385         log
        188     $17cd         exp
        189     $18d7         cos
        190     $18dd         sin
        191     $1970         tan
        192     $1985         atn
        193     $0b63         peek
        194     $0ff3         len
        195     $0e29         str
        196     $1084         val
        197     $1002         asc
        198     $1013         chr
        199     $1021         left
        200     $1050         right
        201     $1059         mid
        202     $4ec5         point
    

    Cela peut aider à donner des points d'entrée pour comprendre comment fonctionne la machine.


  • La Maison dans la colline, partie 2 ()

    Suite de la série sur le développement du jeu La maison dans la colline sur VG5000µ. Après, la première partie, qui donnait le contexte de création, voici donc la deuxième partie, où j'aborde les outils de développement utilisés.

    Les bases

    Lorsque je développe un logiciel, je veux pouvoir me consacrer sur un temps contiguë maximum au cœur du projet. Même, et peut-être surtout, lorsque ce développement est un hobby, et que j'ai peu d'heures à y consacrer, ici et là en fonction de mon temps libre.

    Ainsi, une fois le projet en développement, lorsque j'ai une petite demi-heure par-ci ou une grosse heure par là, je veux pouvoir m'installer et me consacrer à la valeur de ce projet. À son développement concret.

    Pour moi, cela signifie que tout ce que je peux automatiser et qui me permettra de profiter de ces temps là au maximum doit l'être fait en amont. Si je dois cliquer sur des boutons, faire des manipulations, lancer ou configurer des logiciels à chaque fois que je fais un essai, voire même à chaque fois que je débute une session, c'est un temps précieux qui est inutilisé. Chaque manipulation est aussi une occasion de faire une erreur.

    Dans le passé sur ce site, j'ai déjà présenté quelques outils destinés à me faciliter la tâche. Et dès les essais sur l'EF9345 dont je parlais dans l'article précédent, j'ai remis en place un script qui permet de lancer l'émulateur automatiquement, configuré avec lancement du chargement.

    Comme je me doutais que le programme allait gagner en taille, j'ai ajouté au script une manière de passer l'émulateur en vitesse accélérée le temps du chargement.

    Ainsi, dès que je termine une compilation, je n'ai que quelques secondes à attendre avant de retrouver le jeu, prêt à être testé, dans l'émulateur.

    Le framework

    Afin de pouvoir itérer sur le jeu, particulièrement sur son gameplay, j'ai choisi de développer dans un mélange de C et d'assembleur. Le C permet des modifications simples de morceaux de code sans trop se poser de questions bas niveau. L'assembleur permet d’accélérer certaines parties une fois qu'elles sont fixes, ainsi qu'un accès rapide au matériel.

    Car en effet, si j'ai choisi de faire un jeu d'aventure graphique, je tiens à deux choses au niveau de l'affichage :

    • que l'affichage d'une pièce soit très rapide (si ce n'est immédiat),
    • que les mouvements à l'écran ne provoquent aucun clignotement

    Difficile voire impossible à faire cela en BASIC. Plus facile à faire en C, mais c'est l'assembleur qui me permettra de vraiment réaliser ces objectifs.

    De même, je voulais initialement que le jeu tienne sur une machine sans extension mémoire. Malheureusement, je ne réaliserai pas cet objectif. De peu...

    z88dk

    Quelques temps (années ?) auparavant, j'avais croisé le chemin de z88dk, un framework de programmation en C dédié aux machines Z80. Cela me semblait être une bonne occasion pour l'essayer, avoir l'espoir qu'il vienne avec des fonctionnalités intéressantes qui me feraient gagner du temps.

    Après tout, il y a des outils de création de programme assemblés dans une suite complète, une bibliothèque C pour Z80, un support VG5000µ et un fichier crt.s déjà configuré et configurable. Ça, se sont les avantages.

    Après usage pendant toute la durée du projet, voici les inconvénients :

    • le programme principal qui appelle les autres pour la compilation n'a pas une syntaxe d'option standard, et cela me posera des problèmes avec cmake,
    • le compilateur par défaut n'est pas le meilleur, je m'en rendrai compte beaucoup plus tard, vers la fin du projet. Il est possible d'utiliser un compilateur alternatif, qui optimise visiblement mieux. Malheureusement, les deux ne se comportent pas tout à fait de la même façon, et j'ai préférer ne pas changer en chemin. On verra pour un futur projet peut-être,
    • le support VG5000µ est axé sur une utilisation en mode texte, et passe par le système implémenté par la ROM, sans accès direct à l'EF9345. Ce n'est pas cohérent avec ce que je veux faire, et je n'utiliserai finalement aucune fonction spécifiquement dédiée au VG5000µ.

    Au final, je ne suis pas entièrement convaincu par z88dk, qui à l'air de prendre une orientation plutôt CP/M et machined un peu plus puissantes qu'un VG5000µ.

    Gestion de la construction

    Pour le gestionnaire de construction de version, je suis parti sur cmake. C'est très probablement surdimensionné, mais je connais son utilisation classique. Ici, je voulais pousser plus loin et aborder sa configuration de chaîne de compilation « exotique ».

    J'ai beaucoup appris sur cmake au passage ; ma solution finale n'est pas entièrement solide, je confirme à nouveau que Stack Overflow n'est d'aucune aide dès que vous avez un soucis qui n'est pas basique, que la documentation de cmake est toujours peu aidante... et qu'un Makefile tout simple aurait été probablement tout aussi efficace. Mais je m'emmêle toujours les pinceaux avec un Makefile dès que je quitte les règles de bases.

    cmake est probablement trop automatique sur certains points, et il n'est pas toujours facile de lui faire comprendre que la buildchain utilisé ne se comporte pas tout à fait comme ce à quoi il s'attend.

    Enfin maintenant c'est fait, et même si je dois corriger certaines petites choses au niveau des dépendances entre les .c, les .h et les .asm, ça marche globalement bien.

    Éditeur de code

    cmake était surdimensionné ? Que dire de l'éditeur de code que j'ai utilisé. CLion... vim ou visual studio code auraient suffit. Et il m'est arrivé d'utiliser vim pendant le développement pour quelques modifs rapides. Mais là encore, je connais bien CLion, ses outils, sa configuration, et l'habitude, ça compte.

    De toute façon, mes outils d'automatisation ne sont dépendants ni de cmake, ni de clion, ce sont donc des choix indépendants.

    Paré au départ !

    Ou presque. J'ai cité les outils de développement principaux. Mais je parlais en introduction d'automatiser la mise en place de l'environnement de développement. Pour cela, j'utilise le terminal kitty associé à un script. Lorsque je lance ce script, le terminal se met en place avec les bon terminaux ouverts dans les bons répertoire, et des outils textes déjà lancés (ranger pour la gestion de fichier, lazygit pour la gestion de version, nb pour la prise de notes, le script d'automatisation à l'écoute).

    Ainsi, démarrer une session depuis un ordinateur fraîchement allumé me prend deux clics pour avoir l'intégralité de l'environnement en place, et j'ai tout ce qu'il me faut pour la session. Cela aurait été un seul si je n'avais pas choisi Clion.

    Alors... clic, clic... et la suite au prochain épisde.

    Capture montrant l'explorateur textuel Ranger dans le répertoire du jeu.


« (précédent) Page 3 / 20 (suivant) »