WordPress

Category: Software

  • Space Invasion

    Avec Pipe-Mania déjà réalisé en ce début d’année 2015, Dancresp a fait un bon dans la réalisation de ses jeux. Cette fois, les couleurs sont démultipliées pour le plaisir de nos yeux

    Informations générales

    Ce jeu est une nouvelle version d’un jeu précédemment adapté pour ACORN ELECTRON, MSX et ATARI XL.

    Cette version pour Atari XL est la meilleure version, car une partie de la couleur a été ajustée plus le niveau de difficulté, faisant apparaître progressivement plus de variété d’ennemis. La vitesse est cyclique, de sorte que tous les 3 niveaux la vitesse est maxmale avant de redescendre dans le suivant. Dan a également changé l’ordre d’apparition des envahisseurs dans notre sélecteur, en les regroupant par type et par position et en les différenciant par des couleurs. S’il n’y avait pas le souci du temps de réponse du clavier, ce serait la version ultime.

    Comme ORIC fonctionne sur 40 colonnes, Dan a utilisé la disposition des éléments à l’écran des versions ACORN ELECTRON et ATARI XL, et verticalement, tout cela est un peu plus étiré du fait de l’utilisation des 25 lignes.

    Comme toujours, le fait de disposer de caractères de 8×6 pixels a contraint Dan à redéfinir certains graphismes, tels que le bunker ou le char, qui a réutilisé ceux de «nuclear invaders» pour les envahisseurs.

    Pour lire le clavier, Dan a choisi de le faire avec PEEK (520) ($208 en hexadecimal), ce qui permet de lire la dernière touche enfoncée, en évitant les problèmes de majuscules ou de minuscules. Malheureusement, le tampon clavier est limité à une touche ce qui signifie que la lecture n’est pas aussi fiable que souhaité et que la touche doit être enfoncée plus longtemps. Cependant, la difficulté a été adaptée à cette limitation pour que le jeu fonctionne correctement. Ce problème se produisait déjà dans la version ATARI mais cela a parfaitement fonctionné dans ELECTRON et MSX.

    Dan a supprimé tous les calculs et tous les ET / OU possibles. Pour utiliser un IF et s’il n’est pas satisfait, aucune autre valeur n’est à vérifier. Dan a également évité d’utiliser ELSE chaque fois que possible pour éviter les “erreurs” de l’interpréteur BASIC ORIC.

    Pour que la vitesse soit constante, en tenant compte du fait que parfois plus de lignes sont exécutées que d’autres, sur la ligne 100, j’initialise l’emplacement mémoire n ° 276 sur 0, car cette position et la suivante forment un registre de 16 bits qui est: diminue de 50 fois par seconde. Sur la ligne 220, je crée une boucle qui considère que la valeur de cette position (l’octet de poids faible) est inférieure ou égale à 230. Surtout lors de la mise à jour d’une colonne d’envahisseurs, le processus prend plus de temps que d’habitude et nous obtenons ainsi la vitesse de l’exécution soit constante. Dommage pour le thème de la lecture au clavier …

    Et comme toujours, en ce qui concerne le son, Dan a démontré une fois de plus ce point faible et s’est limité à utiliser les sons standards de l’Oric.

    PAPER et INK, les couleurs de l’Oric
    Faire un jeu coloré avec l’ORIC est toujours difficile. La gestion de la couleur par l’ORIC n’aide pas, mais ce jeu a pu être coloré avec une certaine facilité et bien que le résultat ne soit pas trop “rétro”, il est beaucoup plus attrayant et clair lorsque l’on joue.

    Pour ORIC, un attribut de couleur est un caractère que vous pouvez placer n’importe où sur l’écran. À partir de ce caractère, tout ce qui apparaît à sa droite aura cette couleur jusqu’à ce que vous trouviez un autre attribut de couleur, ce qui affectera à nouveau tout ce qui se trouve à votre droite. Cela induit, si vous faites une impression dans une position de l’écran où il y a un attribut de couleur, un emplacement de perdu, et ce qui est montré par l’IMPRESSION prend la couleur de l’attribut précédent, donnant un spectacle visuel chaotique, et compliquet beaucoup la programmation de jeux en couleurs.

    Pour éviter cette impression de désordre, il est nécessaire de laisser des espaces entre les différents éléments, où seront placés les attributs de couleur. Grâce à la disposition des éléments dans ce jeu, il a été facile de le colorier et lui donner cet aspect multicolore.

    Je vous invite à l’essayer.

    Quelques informations concernant le programme

    Dan a divisé le programme en 12 blocs:

    • Déclaration de matrice.
    • Contrôle de notre tank.
    • Contrôle de notre objectif.
    • Contrôle de notre tir.
    • Déplacer les envahisseurs.
    • Niveau de passage.
    • Perdre une vie.
    • Présentation
    • Afficher l’écran de jeu.
    • Plusieurs routines.
    • Charger UDG.
    • Définition des blocs graphiques.

    L’ensemble du programme occupe 73 lignes

    • 10 – Nous définissons les matrices du jeu.
    • 20 – Appel de routine pour lire les graphiques et afficher l’écran de présentation du jeu.
    • 100 – Début de la boucle principale.
    • 105 – Contrôle du clavier et vérifiez si notre réservoir doit être déplacé horizontalement.
    • 120 – Si vous appuyez sur “M” (Déplacer), l’envadeur de la position correspondante est modifié.
    • 150 – Si vous appuyez sur “L” (Shot), il est vérifié si l’envahisseur sélectionné se trouve dans cette colonne et le détruit.
    • 200 – Si le compteur de vitesse (W) n’atteint pas la valeur souhaitée, il est augmenté de un et passe à la ligne 220.
    • 205 – Une colonne est sélectionnée de manière aléatoire et s’il reste des envahisseurs, un est ajouté et, si aucun espace dans la colonne n’est ajouté.
    • 210 – Il est vérifié si la colonne a atteint le bunker. Si c’est le cas, il saute à la ligne de vie perdue (500).
    • 215 – Actualisez la colonne de l’envahisseur sélectionné.
    • 220 – Contrôle du temps pour que chaque passage dans la boucle principale prenne la même chose.
    • 225 – Fin de la boucle principale. Si «E = 0» revient à la répétition de la ligne 100. Si «E = 1» passe à 500 (perdre la vie).
    • 400 – Niveau de routine dépassé (E = .1). Le niveau est augmenté de 1, mais si nous passons du niveau 9, nous revenons à 7.
    • 500 – Routine qui s’exécute lorsqu’un envahisseur atteint le bunker. S’il nous reste de la vie, les marqueurs sont mis à jour, mais le message «GAME OVER» apparaît et, après une pause, nous revenons à l’écran de présentation.
    • 2000 – Écran de présentation du jeu.
    • 2050 – Attendez que nous appuyions sur une touche pour lancer le jeu.
    • 2100 – Affiche les marqueurs sur le côté droit de la zone de jeu.
    • 2500 – Le statut des cinq colonnes d’envahisseurs et de l’envahisseur “cible” est mis à jour.
    • 2505 – Affiche la partie gauche de l’aire de jeu. Où l’action a vraiment lieu.
    • 3000 – Paramètres de couleur de jeu et POKE pour masquer le curseur et les majuscules.
    • 3005 – Nous chargeons les couleurs dans C $ () et lisons les DONNEES avec l’UDG.
    • 3010 – On conserve dans la matrice G $ les graphiques qui forment chaque envahisseur et sa couleur.
    • 3015 – Lecture du nombre d’envahisseurs différents par niveau “D ()” et sa vitesse “G ()”.
    • 4000 – Routine pour imprimer les valeurs de “REST” et “AMMO”. La position verticale dans “Y” et la valeur dans “N” sont passées.
    • 4200 – Routine pour imprimer les valeurs de “SCORE” et “HI-SCORE”. La position verticale dans “Y” et la valeur dans “N” sont passées.
    • 4500 – Routine pour l’effacement partiel de l’écran.
    • 9000 – DATA avec les UDG du jeu.
    • 9500 – DATA avec les couleurs et les graphiques de chaque type d’envahisseur.
    • 9800 – DATA avec le nombre d’envahisseurs différents par niveau.
    • 9805 DATA avec la vitesse de chaque niveau.

    Le jeu

    C’est une nouvelle tentative des envahisseurs de l’espace pour prendre le contrôle de notre planète !

    Les envahisseurs descendent en colonnes et avec l’aide de notre char, nous devons sélectionner le type d’envahisseur et tirer. Si l’envahisseur est dans cette colonne, il sera détruit et le reste s’éloignera.
    Évitez de vous rendre dans la zone de bunker ou la victoire sera à vous.

    Chaque niveau est composé de 35 envahisseurs et nous avons 60 coups pour les tuer. Lorsque les niveaux sont dépassés, de nouveaux types d’envahisseurs apparaissent et descendent plus rapidement.

    Le jeu enregistre le score maximum atteint dans une partie.

    Quelques autres versions

    Space Invasion sur Acorn Electron
    La version MSX prend beaucoup de place à l’écran
    Les envahisseurs de l’espace attaquent l’Atari XL

  • Développement sur Orix

    introduction

    Le but de cet article est d’expliquer comment développer sur Orix des applications. Cet article ne va expliquer comment coder en C, mais plutôt comment utiliser les fonctions déjà codées dans cc65 pour faire des choses sur Oric. En effet, Orix s’appuie sur telemon. Pour rappel, telemon est une rom de 16Ko qui contient toutes les routines pour faire fonctionner le hard telestrat notamment, mais aussi l’affichage etc. Il n’y a pas d’interpreteur dans cette partie. Il faut imaginer telemon comme étant une grosse lib utilisable en assembleur. Les libs C de la target Telestrat sur cc65 ne font qu’appeler ces routines.

    Prérequis

    Il vous faudra l’archive contenant Oricutron avec l’émulation du CH376 : https://iss.sandacite.com/iss/oricutron/
    Puis cc65, http://cc65.github.io/cc65/
    Puis les roms : https://repo.orix.oric.org/dists/orix1/alpha/tgz/6502/roms.tgz

    Dans oricutron.cfg, mettre la rom kernel en banque7, la rom basic en banque6, la rom shell en banque 5, et dans les autres banques mettre emptyrom.

    Chaque lancement d’oricutron devra se faire avec l’option -t pour pouvoir démarrer les binaires

    Avoir un éditeur texte (notepad, visual code etc)

    CC65 utilise les prototypes de fonctions standardisées (POSIX), ainsi, il n’y a pas de hires par exemple.

    Premier exemple

    Nous allons effacer l’écran.

    Nom du fichier : clrscr.c

    #include <conio.h>

int main (int argc,char *argv[]) {
  clrscr(); // Effacer l'écran (texte) avec conio car conio gère le mode texte.
}

    On compile (sous linux ou windows)

     # cl65 -ttelestrat clrscr.c -o clrscr

    Vous aurez un binaire clrscr

    Copiez ce fichier dans oricutron/usbdrive/ (oricutron qui est dans l’archive ci dessus)

    Démarrez Oricutron de cette archive.

    Dans Orix, on regarde les informations du binaire avec file :

    # file clrscr

    File permet d’afficher les infos de fichiers (file affiche les infos d’un fichier filepack, binaire Orix, raw, script shell etc)

    Dans Orix, on execute le code : 

     # ./clrscr

    Nous avons l’écran qui s’est effacé

    Afficher hello world

    #include <stdio.h> 

main() {     
  printf("Hello World\n");
}
    • Puis je compile : 
    # cl65 -ttelestrat hello.c -o hello
    • je déplace le binaire dans le répertoire usbdrive d’oricutron (dans bin) :

    cp hello $ORICUTRON/usbdrive/bin/

    • je lance oricutron, et je tape “hello”. Cela fonctionnera sans faire ./hello, puisque nous avons placé le binaire “hello” dans bin/ qui est dans le “PATH”.

    Lire le clavier

    Nous allons utiliser la lib conio de cc65 qui est une librairie de gestion du clavier et du mode texte. Notez que cela récupère aussi le code ascii du joystick. En effet, sur telestrat, quand on utilise telemon, quand on scrute le clavier, on récupère aussi le joystick !

    #include <conio.h>
#include <stdio.h>

int main (int argc,char *argv[]) {
   unsigned char key;   // Ici le programme ne sort jamais, dès qu'une touche est pressée, elle s'affiche à l'écran.
   while (1)   {     
     key=cgetc();     
     printf("%c",key);
   }
}

    Passer HIRES

    Nous allons utiliser la lib TGI de cc65 qui est une librairie graphique standard pour passer en hires.

    #include <tgi.h>
#include <conio.h>
#include <stdio.h>
 int main (int argc,char *argv[]) {
   tgi_install (tgi_static_stddrv);
   tgi_init ();
   tgi_clear ();
   printf("Appuyez sur une touche pour revenir en mode texte");
   cgetc();
   tgi_done();
 }

    Passer HIRES et afficher une image

    il vous faut une images hrs que vous mettez à la racine de usbdrive dans l’émulateur. Cette image s’appelle img.hrs 

    #include <tgi.h>
#include <conio.h>
#include <stdio.h>
int main (int argc,char *argv[]) { 
   FILE *fp;
   char *myfile="img.hrs";
   fp=fopen(myfile,"r");
   if (fp!=NULL)   {
     tgi_install (tgi_static_stddrv);
     tgi_init ();
     tgi_clear ();
     fread(0xa000,8000,fp); // On lit 8000 octets qu'on écrit directement en hires.
     printf("Appuyez sur une touche pour revenir en mode texte"); 
    cgetc(); 
    tgi_done(); 
  } 
}
    • Puis je compile: 
     cl65 -o picture -ttelestrat picture.c

    Voilà, vous avez fait à peu près le binaire viewhrs qui permet de voir des images hrs sur oric.

    Quelques exemples sur orix : https://github.com/jedeoric/orix-samples que vous pouvez améliorer facilement. Contactez moi pour que je vous donne accès en écriture à ce repo !

    viewhrs a été recodé en assembleur depuis, et est dispo dans la ROM shell d’Orix. En voici le lien : https://github.com/orix-software/shell/blob/master/src/commands/viewhrs.asm

  • Pipe-Mania

    Un idée simple, une programmation des plus légères. Et nous voilà à jouer sur un jeu très addictif.

    Informations générales

    En pensant à son prochain projet 1K pour le ZX-81, DanCresp ne le savait pas, mais ce jeu était en tête et de la recherche d’informations sur Internet. Il décida de créer une première version pour MSX. Les problèmes de temps et la facilité d’utilisation de MS-DOS EUPHORIC sur son ordinateur portable l’ont incité à l’adapter à l’ORIC, en vérifiant auparavant qu’il n’y avait pas de version connue.

    Au bout de cinq jours, l’auteur a laissé cette version utilisable, quels que soient les niveaux et les blocs qui apparaissent dans la version d’origine, graphiquement sur la base de la version Spectrum.

    Heureusement, l’émulateur EUPHORIC permet, en appuyant sur “F3”, de mapper le clavier ORIC avec les touches du PC, ce qui facilite beaucoup l’introduction du programme. De l’émulateur, il a généré le TAP et de «l’Oricutron» de Windows, il a généré le listing dans un fichier texte utilisé pour déboguer le code source.

    La vérité est que Dan est très satisfait car le fonctionnement et la performance sont parfaits ; avec un très bon game design. Le système pour augmenter la difficulté a donné plus mal à la tête parce que le jeu devait être difficile mais réalisable. (NDLR : Dan est décidément un pro du game design)

    Les petites choses de la version ORIC
    Comme toujours lors de la programmation dans l’ORIC, les graphismes ont dû être repensés car au lieu de la matrice habituelle de 8×8 pixels, nous passons à une matrice de 8×6.
    Étant donné que l’ORIC dispose d’un mode texte de 26 lignes et de 40 colonnes, la zone de jeu a les dimensions de la version Amiga 500 d’origine de 7 lignes x 10 colonnes au lieu de la version 7×9 de la version Spectrum.

    Dan aurais aimé regarder plus avec la couleur de l’écran, mais le système “particulier” de l’ORIC ne m’a pas permis. Après consultation d’amis graphistes, c’était la meilleure solution. Très semblable à MSX … bleu et jaune.

    Pour contrôler le curseur, le clavier est lu à l’aide d’un «PEEK 520» (NDLR : le fameux PEEK #208 si connu des développeurs), ce qui évite les problèmes de lettres majuscules / minuscules et vous garantit de toujours lire la dernière touche enfoncée, en accédant à la mémoire tampon du clavier.

    Et pour le son, une fois encore, Dan a utilisé les effets prédéfinis de l’ORIC, démontrant ainsi une faiblesse dans ce domaine …

    Et l’eau coule …
    La difficulté principale et presque unique du projet a été de faire circuler l’eau à travers le tuyau, et même si au début cela semblait une question assez complexe, après une promenade avec brain-storming inclus, j’ai trouvé une solution très simple et rapide .

    Nous avons 7 types de blocs différents pour assembler notre circuit.

    Chacun de ces 7 blocs utilise certains des 11 graphiques de tubes différents, numérotés de 97 à 104.

    L’eau peut avoir 4 directions possibles, numérotées dans le sens des aiguilles d’une montre.

    Nous chargeons la matrice «U $» avec les valeurs DATA des lignes 9600 et 9605. Chacune de ces valeurs contient quatre nombres. La position indique la direction dans laquelle l’eau entre et la valeur de cette position indique la nouvelle direction à prendre par l’eau. Si la valeur est 0, cela signifie que vous avez entré une adresse incorrecte et que le jeu se termine.

    Par exemple, la valeur en U du segment de tuyau 3 (coude inférieur / gauche) est «4300». Ainsi, si l’eau entre, elle monte et entre en dessous (direction 1), elle change à gauche (direction 4). Si vous entrez, il avance vers la droite (direction 2), il passe en bas (direction 3). Mais si l’eau vient du haut ou de la gauche, la valeur est «0» et le jeu se termine.

    Lors du démarrage d’un niveau, la position initiale du bloc de sortie est calculée et dans la variable “W”, nous stockons l’adresse de la mémoire vidéo VRAM où l’eau commencera à circuler et dans la variable “O” son adresse (1, 2, 3 ou 4).

    Lorsque l’eau commence à circuler, nous examinons le graphique correspondant à cette conduite et prenons son code (entre 1 et 11). Sur la base du sens d’entrée de l’eau (1 à 4), nous calculons le changement de direction en fonction de la matrice enregistrée dans «U $» et nous mettons à jour la position dans la VRAM sur laquelle pointe la variable «W» en fonction des valeurs de la matrice «J». Cette matrice contient 4 valeurs: -40, 1, 40 et -1 et est ajoutée à «W» en fonction de la nouvelle adresse pour pointer sur la bonne adresse VRAM afin de calculer le morceau de tuyau suivant.

    Ensuite, nous modifions le CHAR du tuyau pour qu’il corresponde à l’eau, au moyen d’un POKE. Si le graphique de la position indiquée par «W» ne correspond pas à celui d’un tuyau, avec ou sans eau, le jeu se termine. J’ai utilisé un POKE car il est plus rapide et plus facile à contrôler (je n’utilise qu’une variable) qu’en utilisant un PLOT et deux variables.

    Tout cela, qui semble très compliqué, est résolu pendant le jeu avec 3 lignes de code, 170, 175 et 180. C’est aussi simple que cela.

    Une fois le niveau terminé, le même processus est exécuté pour calculer la section construite correcte, avec une copie du code précédent et quelques modifications simples, aux lignes 205, 210 et 215.

    Eh bien, rien de plus, je ne peux qu’espérer que cela vous plaise, et oeil… qui accroche le sien…

    Je vous invite à l’essayer.

    L’écran titre et toutes les touches du jeu !

    Quelques éléments concernant le programme

    Le programme est divisé en 9 blocs:

    • Déclaration de la matrice et début du jeu.
    • Boucle principale de développement.
    • Passer le niveau
    • Plusieurs routines.
    • Fin du jeu.
    • Présentation et début du jeu.
    • Préparez et montrez l’aire de jeu.
    • Charger UDG.
    • DATA avec les UDG du jeu et les valeurs de la matrice.

    L’ensemble du programme occupe 91 lignes.

    • 10 – Nous définissons les matrices du jeu.
    • 30 – Aller au sous-programme redéfinit les caractères et définit les variables globales.
    • 100 – Début de la boucle principale. Si le curseur est verrouillé, il passera à la ligne 160.
    • 105 – Prenez la touche appuyée. Si aucune touche n’a été enfoncée, le nombre passe à 160.
    • 115 – Bloc qui déplace le curseur en fonction de la touche appuyée.
    • 135 – Si vous n’appuyez pas sur “Space”, passez à 160.
    • 140 – Vérifiez si la case est occupée par un bloc spécial, sautez à 160 si c’est le cas.
    • 145 – S’il est occupé par un tuyau, réglez le compteur «N» sur 10 et il nous bloquera.
    • 150 – Bloc qui vérifie qu’aucune eau ne passe à travers le bloc.
    • 155 – Placez le bloc à la position indiquée en mettant à jour le curseur et la ligne des blocs suivants.
    • 160 – Réduit l’heure de l’indicateur “T”. S’il reste encore sauter à 185.
    • 165 – Compteur contrôlant le débit d’eau dans les tuyaux. Si vous ne devez pas avancer, passez à 185.
    • 170 – Bloc qui contrôle la progression de l’eau dans les tuyaux. Si vous ne pouvez pas, mettez “D = -9” pour interrompre la répétition.
    • 175 – Réduit le compteur “D” et vérifie le type de tuyau dans lequel se trouve l’eau.
    • 180 – Modifiez le graphique du tuyau et affectez l’adresse correspondante.
    • 185 – S’il reste encore du temps dans le compteur «D» et que l’eau circule bien dans la canalisation, retournez à REPEAT de la ligne 100.
    • 200 – Si “D = -9” saute à 1900 et met fin à la partie, sinon le niveau est dépassé.
    • 205 – Bloc qui vient de remplir d’eau l’ensemble du circuit de tuyaux assemblé.
    • 220 – Mettez à jour les points, augmentez le niveau et passez à 2100 pour monter un nouveau niveau.
    • 1000 – Routine qui place un bloc dans une certaine position.
    • 1100 – Routine qui sélectionne de manière aléatoire un nouveau bloc à quitter lors des prochaines exécutions.
    • 1200 – Routine qui montre les cinq blocs suivants à partir.
    • 1300 – Place le curseur dans la case sélectionnée.
    • 1350 – Supprimer le curseur de la case sélectionnée.
    • 1400 – Affiche le marqueur à 8 chiffres avec les points ou l’enregistrement.
    • 1900 – Le jeu se termine, met à jour le tableau de bord et marque une pause avant de passer à la présentation.
    • 2000 – Écran initial du jeu.
    • 2065 – Une touche doit être enfoncée. S’il se situe entre “1” et “9”, il est pris comme niveau initial et le jeu commence.
    • 2100 – Initialise les variables et détermine la difficulté du niveau.
    • 2105 – Dessine l’aire de jeu.
    • 2115 – Calcule les cinq prochains blocs qui vont sortir.
    • 2120 – Initialise la position des différentes cases.
    • 2130 – Calculez la position de la boîte initiale et enregistrez dans «W» l’adresse VRAM de la première position de l’eau.
    • 2135 – Calculer et positionner le curseur.
    • 2140 – À partir d’un certain niveau, les blocs avec la clé sont placés à 3 positions de la boîte initiale.
    • 3000 – Sélection des couleurs, effacement de l’écran, masquage du curseur et masquage des «CAPS» supérieurs.
    • 3005 – Lecture de données UDG.
    • 3010 – Assemblez les matrices avec des bandes de caractères.
    • 3020 – Lire les DONNÉES avec les directions de l’eau et leurs incréments.
    • 3025 – Chargez un tableau avec des chaînes numérotées de «01» à 25» et utilisées par les marqueurs. C’est plus rapide comme ça.
    • 9000 – DONNÉES avec graphiques UDG.
    • 9500 – DATA avec les différents types de blocs.
    • 9600 – DATA avec les directions de l’eau en fonction du type de tuyau.
    • 9700 – DATA permet de modifier la valeur «W» lorsque vous pointez vers la VRAM.

    Le jeu

    Pipe Mania est un jeu vidéo de type “casse-tête” développé en 1989 par The Assembly Line pour Amiga. Plus tard, LucasFilm Games a créé des versions pour d’autres machines sous le nom de Pipe Dream.

    Le pipe est confié à un plombier, Alfonzo, qui a pour objectif d’ajuster des tuyaux apparaissant au hasard dans une matrice contenant un robinet d’où sort de l’eau.

    Vous devez savoir que deux marqueurs effectuent un compte à rebours:

    • “T”: indique le temps restant avant que l’eau commence à traverser les tuyaux.
    • “D”: indique le temps restant pour terminer le niveau. Chaque unité correspond à un bloc.

    Mettre un bloc de tuyaux dans une boîte occupée nous bloquera quelques instants.

    À partir de certains niveaux, des blocs avec une clé ou des segments de tuyau apparaissent et ne peuvent être occupés.

    Sur l’écran de présentation, nous pouvons indiquer le niveau, entre 1 et 9, auquel commencer le jeu.

    Cette version suit exactement les mêmes mécanismes, mais les phases de bonus et certains types de blocs ont été éliminés.

    Contrôles:
    Contrôlez le curseur avec “Q” – “A” – “O” – “P” et appuyez sur “Espace” pour placer un segment de tuyaux.

    Quelle est votre préférée : la version Oric ou Amiga ?

    Quelques autres versions

    Pipe-Mania, au plus simple sur ZX-81

  • Blasto

    Mars 2014, l’acte 4 des développements retrouvés de Dan Cresp sur Oric. Cette fois-ci, le développement a été limité au Commodore, au MSX et la notre petite machine en rouge et noir

    Infos générales

    Le développement de la version ORIC est issu de la version MSX.

    Le MSX, armé de son Z80 et son Basic Microsoft

    En l’absence de temps libre, l’auteur a profité de trajets en train pour programmer le jeu avec la version MS-DOS de l’émulateur EUPHORIC. En effet, la saisie de programme est très facilitée avec cet émulateur qui accepte l’utilisation du clavier au format du PC (NDLR : j’ai toujours été ennuyé avec le clavier proposé par Oricutron sur la ROM Atmos de base). Le TAP a été crée avec “Oricutron” sous Windows, j’ai généré le listing dans un fichier texte et je l’ai commenté plus tard.

    Le listing de cette version est très similaire, et certaines parties sont identiques, à celle de la version MSX ; tout en prenant en compte les particularités de chaque système. Ainsi, l’adresse de la mémoire vidéo et la méthode de lecture des commandes du navire ont été modifiées. Certaines lignes ont été dépliées pour éviter des problèmes avec le “bogue” de l’instruction ELSE de l’Oric.

    C’est un excellent exemple pour comparer les performances de ces deux systèmes, et bien que les deux versions fonctionnent parfaitement, le MSX a dû “ralentir” pour éviter que ce ne soit trop rapide tandis que pour l’Oric, cela n’a pas été nécessaire.

    À cet égard, je dois reconnaître que même si la vitesse est parfaite, je m’attendais à de meilleures performances coté ORIC. Gardez à l’esprit que, dans les deux versions, POKE se trouve directement dans la mémoire vidéo pour gagner du temps et qu’il n’y a pas beaucoup de lignes de code à exécuter, sauf dans le cas d’une explosion dans une mine ou d’une mine à chaînes, et dans l’ORIC, il en jette juste assez.

    Vous êtes plutôt Oric ou Arcade ?

    Principaux écarts par rapport à l’arcade d’origine:

    • Le jeu original autorise 2 joueurs simultanés et un seul ici.
    • L’écran a 28 lignes et ici il y en a 26 (22 en MSX).
    • Dans le jeu original, il y a 84 mines et ici 78 (64 en MSX), l’aire de jeu étant un peu plus petite.
    • Les graphiques sont légèrement différents de la version originale.
    • Cette version ne permet pas l’utilisation du joystick.

    Pour le reste, la mécanique du jeu a été pleinement respectée.

    Les petites choses de la version ORIC
    Comme toujours lors de la programmation sur l’ORIC, les graphismes ont dû être repensés car au lieu de la matrice habituelle de 8×8 pixels, nous passons à une matrice de 8×6. Ainsi, l’explosion (qui occupe 9 blocs) a dû être coupée à 6 pixels horizontalement, le navire a dû être redessiné pour le laisser dans une taille réelle de 5×5 pixels et les mines ont une apparence différente.

    La magnifique aire de jeu de l’Oric

    Étant donné que l’ORIC dispose d’un mode texte de 26 lignes et de 40 colonnes, l’apparence de la zone de jeu est presque identique à celle de la version arcade.

    Pour le contrôle du navire, le clavier est lu à l’aide d’un “PEEK 520”, ce qui évite les problèmes de boîtier.

    Et pour le son, une fois encore, j’ai tiré les prédéfinis de l’ORIC.

    Réaction en chaîne
    Le jeu est techniquement très simple et la seule difficulté est de savoir comment résoudre le problème des explosions de mines à chaînes, car il peut facilement y avoir 2 mines ou plus ensemble. Pour cela, j’ai créé une matrice de 78 éléments (un par mine) avec deux pointeurs: “M” et “N”.

    Lorsque notre tir détecte que nous avons touché une mine, il augmente le pointeur «N», enregistre sa position dans la matrice et l’efface de l’écran. Les positions autour sont examinées ci-dessous. Chaque fois qu’une autre mine est trouvée, la même action est effectuée.

    A la ligne 140, nous voyons si le pointeur “M” est inférieur à “N” et si c’est vrai, nous allons à la routine qui les fait exploser, en augmentant le pointeur “M”.

    Eh bien, rien de plus, je ne peux qu’espérer que cela vous plaise.

    Je vous invite à l’essayer.

    Quelques éléments concernant le programme

    Le programme a été divisé en 10 blocs:

    • Déclaration de matrice. Appel aux routines principales.
    • Contrôle des navires.
    • Contrôle du tir.
    • Fin du jeu.
    • Le coup a touché quelque chose.
    • Détruire une mine.
    • Perdre une vie.
    • Présentation et début du jeu.
    • Plusieurs routines.
    • DATA avec les UDG du jeu et la conception de la zone de jeu.

    L’ensemble du programme occupe 73 lignes.

    Ensuite, j’indique le principe des différentes parties du programme:

    • 10 – Nous définissons les matrices du jeu.
    • 50 – Accédez au sous-programme qui lit les graphiques, redéfinit les caractères et définit les variables globales et le mode vidéo.
    • 100 – Début de la boucle principale.
    • 102 – Le clavier est consulté et si aucune touche n’est enfoncée, il passe à 140.
    • 110 – Le navire se déplace en fonction de la touche enfoncée.
    • 140 – S’il y a une mine en attente d’exploitation, reportez-vous à la routine 350 correspondante.
    • 150 – Contrôle de tir. S’il est actif, passez à 160 et si ce n’est pas le cas, vérifiez si le déclencheur a été enfoncé
    • 160 – Déplacez le coup en fonction de sa direction.
    • 190 – Le temps disponible pour terminer le jeu est réduit.
    • 200 – Si le temps le permet, passez à 100.
    • 205 – Fin de partie où il est contrôlé si le record est dépassé et si toutes les mines ont été détruites.
    • 300 – Contrôle que vous avez touché le coup.
    • 350 – Routine qui contrôle la destruction des mines à chaînes.
    • 400 – Une mine a explosé à proximité et notre navire est détruit.
    • 2000 – Écran initial du jeu.
    • 2500 – Initialise les variables pour le jeu et la routine qui place les mines.
    • 2600 – Position initiale de notre navire.
    • 2700 – Routine qui montre le labyrinthe de points à l’écran, sans les mines.
    • 3000 – Sélection des couleurs, effacement de l’écran, masquage du curseur et masquage des «CAPS» supérieurs.
    • 3010 – Lire les données UDG.
    • 3015 – Lecture des DONNEES des segments de l’aire de jeu.
    • 5100 – Routine montrant le marqueur de point.
    • 5400 – Routine indiquant la fin du jeu ou un message de jeu gratuit.
    • 9000 – DONNÉES avec graphiques UDG.
    • 9100 – DATA avec les différentes lignes qui composent l’aire de jeu.

    Le jeu

    Ce jeu vidéo pour systèmes d’arcade a été développé en 1977 par la société Gremlin.

    L’objectif du jeu est de détruire toutes les mines du champ de mines avant la fin du temps imparti. Pour cela, nous avons un navire que nous pouvons déplacer à travers les zones vides de l’écran et qui peut tout détruire. Il faut faire attention, car lorsque les mines explosent, elles détruisent ce qui les entoure.

    Si nous atteignons notre objectif, nous aurons un jeu gratuit.

    Contrôles:

    • Contrôler le navire avec Q – A – O – P.
    • Appuyez sur la “espace” pour tirer.

    Quelques autres versions

    Blasto sur MSX
    et sur Commodore

  • Une petite curiosité dans Théoric

    par André C.

    Une info erronée et hop, la légende est en marche!

    L’article bien connu “Votre Oric fait du bruit” paru dans Théoric n°1, page 6 concerne l’Oric-1 mais en fait ça marche aussi (avec plus ou moins les mêmes résultats) sur l’Atmos. L’auteur (anonyme) est parvenu à produire des sons avec des CALL inappropriés dans la Rom. Je dis inappropriés car les adresses signalées comme produisant des sons (et effectivement ça marche) tombent souvent au milieu d’une routine (et même entre opcode et argument), voir au milieu d’une table de data (un CALL dans les data, faut le faire!). Incroyable, mais authentique !

    Le fait que l’Oric puisse produire des sons lorsqu’on fait n’importe quoi est plus que surprenant. En fait l’auteur a fait plein d’essais et ne rapporte que ceux “qui marchent”. Si vous avez du temps à perdre, vous pouvez chercher à comprendre pourquoi ça ne plante pas avec les exemples cités.
    La mode de la chasse aux sons était lancée. Par la suite, des auteurs un peu plus rationnels ont cherché à produire des sons en exploitant la routine #FA6C (Oric-1) ou #FA86 (Atmos). Cette routine, appelée “Envoyer 14 paramètres au PSG 8912“, exploite les registres X et Y du 6502, qui ciblent l’adresse d’une table contenant 14 paramètres pour les registres du PSG 8912. La routine se charge donc d’écrire ces 14 paramètres dans les 14 registres du PSG.
    Là ou çà cloche, c’est que ces auteurs ont utilisé les valeurs de X et Y, non pas comme adresse d’une table de paramètres, mais comme paramètres en soit. Les articles “Bruits sur Oric-1” de Bruno Trinquier de la Valette (Théoric n°4 page 56), “Bruits sur Atmos” de Bruno Bouchaud (Théoric n°7, page 39) souffrent de cette erreur. Il ne suffit pas de donner une valeur de #00 à #FF aux registres X et Y pour obtenir 65 536 possibilités de bruits! Ce n’est que par hasard que l’adresse ciblée par X et Y tombe dans une zone de la mémoire qui contient 14 valeurs acceptables par le PSG. Dans la plupart des cas, ça ne marche pas ou ça donne des bruits inexploitables ou ça plante!
    En effet, les 5 sous-programmes PING, SHOOT, EXPLODE, “Bruit clavier touches normales” et “Bruit clavier touches de contrôle” utilisent cette routine couplée à 5 tables de 14 paramètres appropriés à chacun de ces 5 sons. Notez que ZAP utilise également cette routine couplé à une 6e table de paramètre, mais cette commande est compliquée par un post traitement du son.
    Heureusement, plusieurs lecteurs de Théoric ont signalé le problème et l’article “Toujours des bruits” de Gilles Clavequin (Théoric n°11, page 36 et 37) remet un peu d’ordre dans tout cela. Cet auteur reprend la liste des 14 registres du PSG, rappelle à quoi ils servent et la gamme de valeurs possibles que l’on peut y écrire. Quelques exemples illustrent cette petite introduction théorique. L’auteur fournit quatre tables de 14 paramètres (2 pour l’Oric-1 et 2 pour l’Atmos), permettant de générer deux nouveaux sons PONG et PCHHH. Ces tables sont mises en oeuvre grâce à la routine “Envoyer 14 paramètres au PSG8912“. Il faut bien sûr implanter tables et routine en Ram pour découvrir ces nouveaux sons. Vous trouverez le programme de Gilles Clavequin dans le fichier PONGPCHHH.TAP accompagnant cet article.
    Pour en revenir aux expériences de Bruno Trinquier de la Valette et Bruno Bouchaud, ces auteurs ont quand même réussi à repérer (parmi les 65 536 possibilités de bruits !) quelques sons intéressants. Pour quelqu’un de patient, il serait possible d’aller voir ce qu’il y a dans la mémoire aux adresses correspondantes et de recopier soigneusement les 14 octets qui s’y trouvent. Cela pourrait servir de base à la mise au point de sons plus propres en peaufinant les valeurs pour qu’elles soient mieux adaptées aux registres correspondants du PSG. Bon courage et n’oubliez pas de partager vos trouvailles…

    PONGPCHH.TAP, le fichier de Théoric n°11Télécharger

    Mise en oeuvre du fichier PONGPCHHH.TAP correspondant au listing de Théoric n°11 : Avec Oric-1 faire CALL#A000 pour obtenir un PONG et CALL#A007 pour obtenir un PCHHH (qui ressemble plutôt à TCHHH). Avec Atmos faire CALL#A00E pour obtenir un PONG et CALL#A015 pour obtenir un PCHHH.

    Bibliographie

    N’hésitez pas à consulter les excellents articles parus dans le CEO-mag sur la production des sons par l’Oric et notamment, parmi de nombreux autres :

    • “Interruptions musicales” de Dominique P. (n°99, pages 20 à 22).
    • “PLAY, MUSIC, SOUND” d’André C., Dominique P. et Claude S. (n°35 à 39).
    • “Musique Maestro !” de Mickaël P. (n°143, pages 18 à 20; n°144, pages 13 à 15).
    • “Assembleur et sons sur Oric-1/Atmos” de François L. (n°22, pages 5 et 6).
    • Les articles de Jean-Marie H. (n°26, page 13; n°27, page 16; n°29, page 9; n°31, page 6; n°34, page 13; n°35, pages 13 et 14; n°37, page 10; n°38, pages 7 et 8; n°42, page 9).
    • “Musique pour votre Oric” d’Alain W. (n°79, pages 4 à 6; n°80, pages 6 et 7; n°81, pages 11 et 12; n°82, pages 11 et 12).
    • Sans oublier la série “Musique Maestro ! initiée par Dominique P. et Claude S., “consacrée à l’Atmos stéréophonique.

  • Lights Out

    Après quelques softwares développés sur d’autres plateformes, ce logiciel marque les débuts de Dan Cresp en programmation sur l’Oric. Produit début 2012, la vision de Dan est exceptionnelle sur cette adaptation. Romuald réalisera fin 2018 une nouvelle adaptation de ce jeu de réflexion dans le cadre du concours CEO NY2019.

    Généralités

    Le jeu est une conversion informatique de la machine “LIGHTS OUT” de la maison TIGGER. Très addictif, c’est le premier jeu que Dancresp a réalisé pour l’ORIC, et c’est une adaptation du même jeu programmé pour le THOMSON MO5 fin 2011. Cette version est un peu plus rapide, mais elle a perdu la simplicité d’action liée à l’utilisation du crayon optique.

    Le MO5 de Daniel, équipé de son crayon optique … en pleine action

    L’adaptation à l’Oric est une réussite car son BASIC est assez complet et rapide et le programme de fait est agréable à utiliser. Le développement sur l’Oric m’a exigé de me familiariser avec son éditeur “étrange”, que j’ai finalement utilisé sans problèmes majeurs. D’autre part, j’ai découvert et commencé à maitriser son système de gestion de la couleur “particulier”. En fonction de ce que vous voulez faire, c’est complexe et peut limiter le développement. Enfin, il est curieux de pouvoir utiliser des caractères de double hauteur. Pour résumer, cette “expérience initiatique” se poursuivra.

    Dans le chapitre bizarreries de l’Oric, la fonction CHR a une fonction différente suivant que vous l’utilisez dans des lignes PLOT (pour indiquer une couleur) et PRINT.

    Pour conclure, disons que chaque être humain devrait avoir la possibilité, ne serait-ce qu’une fois, d’utiliser le clavier de l’ORIC ATMOS qui est un des meilleurs que j’ai pu utiliser.

    Je vous invite à l’essayer.

    Lights Out sur l’Oric Atmos de Daniel, une belle adaptation

    Quelques éléments à propos du programme

    Le programme principal est décomposé en 9 parties :

    • Déclaration de variables, initialisation du jeu et calibrage du stylet.
    • Impression des marqueurs de jeu.
    • Sélecteur de carte correspondant.
    • Envoi à l’affichage du tableau actuel et du numéro de mouvement.
    • Contrôle de clé.
    • Contrôle de l’investissement des lumières correspondantes.
    • Inversion d’une lumière.
    • Impression du tableau avec les lumières.
    • Données des 10 premiers et tableaux de bord et données d’aide de la course.

    Les variables suivantes sont utilisées:

    • M$ = Matrice où sont stockés les 10 premiers tableaux.
    • S$ = Chaîne où le tableau actuel est enregistré.
    • A$ = Carte de lumière.
    • W = Matrice où les premières analyses sont enregistrées en cas d’aide.
    • L = plateau de jeu actuel.
    • M = numéro de mouvement.
    • H = compteur d’aide.
    • F = Lumière à inverser, ou boucles
    • X = position horizontale du pointeur.
    • Y = Position verticale du pointeur.
    • P = compteur de lumière.
    • B = Nombre de lumière qui a été pressée.
    • N = Nombre de lumière lors de l’impression du tableau.

    Les mécanismes du jeu original ont été condensés en seulement 42 lignes de code.

    Le code, simple et efficace, résumé par Dancresp
    • 100 – Définition des matrices du jeu.
    • 110 – Début des variables et charge les lignes DATA dans les matrices.
    • 200 – Couleurs du jeu, et nous faisons disparaître le curseur.
    • 210 – Impression de titres double format en utilisant les séquences “d’échappement” correspondantes.
    • 220 – Copyright au bas de l’écran.
    • 230 – Impression des textes “(H) ELP!” et “(R) ESET”.
    • 300 – Impression de marqueur de niveau.
    • 310 – Position du pointeur, nombre de mouvements (M) à 0 et si le niveau est supérieur à 10, sautez à la ligne 330.
    • 320 – Décomposez les 25 voyants de la matrice (M?) Dans la matrice S? Et réglez le compteur d’aides (H) sur 1.
    • 330 – Génère une carte de manière aléatoire et définit le compteur d’aide sur 3, qui est désactivé.
    • 400 – Imprimez le tableau avec les 25 voyants et s’il n’y en a pas, passez à la ligne 300.
    • 410 – Imprimez le numéro de mouvement.
    • 500 – Imprimez le pointeur sous la lumière correspondante.
    • 510 – Lisez le clavier. Si une touche est enfoncée, supprimez le pointeur mais relisez le clavier.
    • 520 – Si vous appuyez sur “O”, déplacez le pointeur vers la droite.
    • 530 – Appuyez sur “P” pour déplacer le pointeur vers la gauche.
    • 540 – Appuyez sur “Q” pour déplacer le pointeur vers le haut.
    • 550 – Appuyez sur “A” pour déplacer le pointeur vers le bas.
    • 560 – Si vous appuyez sur la touche espace, désactivez l’aide, calculez la lumière sélectionnée et passez à 600.
    • 570 – Si vous appuyez sur “H” et que le nombre de mouvements est inférieur à 3, lancez-vous pour nous.
    • 580 – Appuyer sur “R” réinitialise le tableau.
    • 590 – Si vous appuyez sur “S”, le curseur s’affiche et vous quittez le programme, mais passe à 500
    • 600 – Inverser la lumière sur laquelle il a été appuyé.
    • 610 – Si la lumière n’est pas dans la première rangée, inversez la lumière ci-dessus.
    • 620 – Si le feu ne se trouve pas dans la dernière rangée, inversez le feu en dessous.
    • 630 – Si le feu ne se trouve pas dans la dernière colonne, inversez le feu à droite.
    • 640 – Si le feu ne se trouve pas dans la première colonne, inversez le feu à gauche.
    • 650 – Ajoutez un coup (M) et passez à 400.
    • 700 – Si le voyant indiqué par F est allumé (= 1), définissez-le sur 0 mais sur 1.
    • 710 – Le sous-programme se termine.
    • 800 – Réglez le compteur de lumière (P) sur 0 et N = 1.
    • 810 – Début de la double boucle qui imprime le tableau.
    • 820 – Si la lumière à régler est active, la couleur rouge est activée, mais la couleur blanche est activée.
    • 830 – Imprimez le fichier à la position correspondante. Il a une taille de 3×3.
    • 840 – Augmentez le nombre de jetons (N) et fermez les boucles.
    • 850 – Fin du sous-programme.
    • 900 – Données des planches. Chaque tableau consiste en une chaîne de 25 chiffres 1 ou 0 indiquant l’état de l’un des voyants. Ensuite, deux nombres correspondant aux 2 premiers cycles que la machine proposera en cliquant sur “AIDE!” Sont transmis. S’il n’y a pas d’aide, mettez comme 0,0.

    Le Jeu

    L’objectif du jeu est d’éteindre toutes les lumières rouges sur le plateau de jeu. Nous contrôlons le pointeur qui apparaît sous l’un des 25 carrés du tableau. En appuyant sur Espace, vous modifierez l’état de ce carré et des 4 carrés adjacents ; celui du dessus, du dessous, de droite et de gauche.
    En appuyant sur la touche “H” (HELP), l’ordinateur choisit les 2 premiers mouvements, à condition qu’ils soient les premiers. Appuyez sur la touche “R” (RESET) pour revenir à la position initiale du tableau.

    Le jeu a 10 niveaux prédéfinis, et à partir de là, l’ordinateur génère des tableaux aléatoires sans aide disponible

    Quelques autres versions

    La version originale de Lights Out créee par Dan, sur Thomson
    A découvrir sur ZX-80
    En Hires et plus récente, le Lights Out de Romuald

  • Nuclear Invaders

    Un des premiers programmes conçu par Dan Cresp sur Oric, publié en Février 2013 et bien sur disponible sur oric.org dans la rubrique software. Comme vous l’avez deviné, avec son amour de la programmation et sa collection de micros, Dan a adapté son jeu sur plusieurs systèmes. Vous trouverez ci-dessous ses découvertes …

    Nous avons tous un équipement plus ou moins rétro, et la conception de ces programmes sont une bonne excuse pour pouvoir les utiliser et apprendre quelque chose à leur sujet.

    En règle générale, j’invente un jeu, ou adapte quelque chose d’existant, et le transfère sur 3 systèmes différents. Cela m’aide à comparer les performances et certaines fonctionnalités. Pour Nuclear Invaders, il existe une version pour DRAGON 32 (l’original, mais beaucoup plus simple) et pour MSX et ORIC. La meilleure des trois versions est sans aucun doute celle du MSX, mais la version ORIC a été meilleure que prévu.

    Un Dragon 32 en démonstration avec Nuclear Invaders

    En ce qui concerne l’ORIC, voici une partie des choses que j’ai apprises :

    • J’ai enfin appris à utiliser l’éditeur sans problèmes. Cela me rappelle beaucoup celui du ACORN BBC / ELECTRON.
    • Le programme a été entièrement développé sur un véritable ORIC-1 ; avec toutes les difficultés liées aux cassettes. Ainsi, si je l’enregistre en mode rapide avec l’ORIC-1, il ne se charge jamais bien. Si je le charge sur un ATMOS et l’enregistre rapidement avec l’ATMOS, l’ORIC-1 le charge sans problème. Curieux
    • Le programme a parfaitement fonctionné sur l’ORIC-1. Une fois passé à l’émulateur, l’OVNI ne s’est pas déplacé. Je l’ai essayé sous EUPHORIC (MSDOS) et ORICUTRON (Windows), en émulant ORIC-1 et ATMOS et cette partie ne fonctionnait pas bien. Je devais diviser la ligne 180 en deux (180 et 185) pour que cela fonctionne. Lorsque j’ai essayé sur ATMOS, j’ai constaté que cela ne fonctionnait pas non plus. Au final, le jeu garde la ligne divisée pour que le jeu fonctionne dans toutes les configurations.
    • En ce qui concerne le son, j’ai choisi d’utiliser les paramètres prédéfinis car leur modification pénalisait la jouabilité. Il y a de bonnes options sonores, mais en BASIC, il en coûte un max de les travailler.
    • Concernant la jouabilité, j’ai assez respecté la vitesse du jeu SPACE INVADERS, et nous sommes en BASIC !!!
      Le tir avance de 2 en 2 rangées, soit “curieusement” la séparation entre les envahisseurs. Cela permet de ne vérifier qu’une fois par cycle si vous touchez quelque chose. En outre, si le tir était plus rapide, la vitesse des envahisseurs devrait augmenter car le jeu serait trop facile. Presque tout a une explication

    Personnellement, j’aime davantage programmer en assembleur, mais il est clair que faire un jeu en BASIC est un défi particulier, car vous ne pouvez rien programmer. Vous devez très bien savoir si le projet est réalisable et très bien savoir le déboguer pour le lancer.

    Un Alien approche des réacteurs … la fin est proche !

    Notes finales

    La principale difficulté du jeu a été de parvenir à une bonne vitesse d’exécution, en tenant compte du fait que le jeu d’origine n’est pas particulièrement rapide. J’ai utilisé différentes techniques pour y parvenir. Parmi celles-ci, la sauvegarde des différentes animations des envahisseurs en fonction de leur position.

    Les graphismes ORIC sont composés d’une grille 6×8, 6 large par 8 haut. Comme aucun envahisseur n’occupe plus de 12 pixels, ils sont parfaitement positionnés. Pour le tank et l’OVNI je devais utiliser 3 caractères. J’ai redéfini les minuscules pour pouvoir lister le programme sans problèmes.

    L’écran de présentation est un “duplicata” du jeu d’origine, à l’exception du changement de nom du jeu. La forme de présentation est différente puisque tout est montré ici en une fois et non pas lettre par lettre.

    Ecran de présentation de Nuclear Invaders

    La boucle principale du développement va des lignes 100 à 260, soit 19 lignes au total. Ici, vous contrôlez le char, le tir, l’OVNI et un envahisseur. Comme le processus est rapide, tout se passe bien. Cependant, l’impossibilité d’utiliser ELSE en toute quiétude, ainsi que la limitation de la longueur des lignes ont rendu ce bloc plus compliqué que dans la version MSX.

    Pour détecter si le tir touche un ennemi, avant de montrer le tir dans sa nouvelle position, je regarde quelque chose, et si oui, je saute à la ligne 400. Ici, je vérifie verticalement si c’est l’OVNI, et sinon, c’est un envahisseur qui en position verticale, je calcule la ligne et en position horizontale la colonne.

    Dans cette version, je montre un précédent écran d’instructions où j’indique les touches de contrôle. Pendant ce temps, les graphiques redéfinissent et initialisent certaines matrices et variables.

    L’éditeur de l’ORIC est très similaire à ACORN BBC / ELECTRON, mais au lieu de la touche “COPY []”, le “CTRL + A” est utilisé ici. La différence est que dans ACORN, vous voyez ce que vous copiez dans le tampon, mais pas dans l’ORIC. Il est donc conseillé de vérifier avec un LIST de la ligne pour s’assurer que les modifications ont bien été enregistrées.

    Il y a un bogue important avec la commande ELSE du Basic de L’ORIC. Entre autres choses, il n’identifie pas bien à quoi le SI est associé et empêche le programme de le traiter correctement. Cela signifie que certaines lignes doivent être divisées en deux ou trois pour éviter des erreurs.

    En ce qui concerne l’enregistrement sur bande, l’ORIC-1 enregistre généralement mal en mode FAST (par défaut) et vous devez utiliser le paramètre «, S» pour le faire en mode SLOW, qui est beaucoup plus lent mais plus sûr. L’enregistrement rapide n’échoue pas dans l’ORIC ATMOS et l’ORIC-1 lui-même le charge sans problèmes.

    Pour ce qui est du son, domaine pour lequel je suis assez ignare, après plusieurs tests au cours desquels la performance d’ORIC est tombée trop bas, j’ai choisi d’utiliser les sons prédéfinis dont elle dispose. Les performances sonores de l’ORIC sont bonnes, mais leur utilisation est quelque peu fastidieuse.

    Avec la touche “ESC” on quitte le programme et en utilisant POKE # 26A, 3 activer le curseur et le clic de la touche.

    Quelques éléments concernant le programme

    La routine du jeu est divisée en 14 blocs

    • Déclaration de la matrice
    • Contrôle de notre tank
    • Contrôle de notre tir
    • Déplacement de OVNI
    • Déplacement des envahisseurs
    • Destruction d’un ennemi ou de l’OVNI
    • Perte d’une vie
    • Niveau de passage.
    • Présentation
    • Affichage de l’écran de jeu.
    • Chargement des graphiques. SPRITES et UDG.
    • Initialisation des variables et matrices du jeu.
    • Routines
    • Blocs graphiques.

    L’ensemble du programme occupe 79 lignes dont voici les principales :

    • 10 Définition des matrices du jeu.
    • 30 Routines d’appel pour lire les graphiques (3000), Affichage de la présentation (2000).
    • 100 Nous vérifions si notre char doit être déplacé, en le montrant dans la nouvelle position.
    • 130 S’il y a un tir à l’écran, nous le déplacerons, et nous verrons si un nouveau tir est réalisé (RETURN).
    • 170 S’il y a un OVNI sur l’écran, nous le déplaçons, et diminuons le compteur (W).
    • 200 Routine de déplacement des envahisseurs. Un envahisseur différent se déplace à chaque passage. D’abord, nous regardons s’il y a toujours des envahisseurs dans la position correspondante (3 par position), s’il y en a, nous avançons. Si la vitesse est assignée, nous la déplaçons, et si nous n’utilisons pas un nombre aléatoire, nous décidons de commencer à bouger. Pendant le mouvement, nous modifions son animation et voyons si il a atteint la centrale nucléaire.
    • 250 Compteur du prochain envahisseur à déplacer (M).
    • 260 Si tous les envahisseurs n’ont pas été détruits (T), nous retournons à REPEAT à 100, et s’ils ne restent pas, nous continuons jusqu’à 300
    • 300 Code de niveau de passe. Le passe est donné lorsque nous détruisons les 30 envahisseurs. Le contrôle de difficulté (C) indique que la largeur de la centrale nucléaire est augmentée.
    • 400 Cette routine est exécutée lorsque le tir détecte qu’il a touché quelque chose (sur 160). Ici, il est calculé si un envahisseur ou l’ovni a été touché et agit en conséquence. En 410, un envahisseur est détruit et en 450, l’OVNI est détruit.
    • 500 Routine en cours lorsqu’un envahisseur arrive à la centrale nucléaire. Un son est joué et une vie est supprimée. S’il reste des vies, nous recommençons le niveau et sinon, nous revenons à l’écran de présentation après une pause.
    • 2000 Écran de présentation du jeu
      La commande de déclenchement est enregistrée dans la variable (G).
    • 2100 Suppression de l’écran de présentation.
      Message joueur 1 pour être prêt et la centrale nucléaire est dessinée.
    • 2800 Positionnez et montrez les envahisseurs et notre tank à l’écran. Réinitialise la valeur de certaines variables.
    • 3000 Nous chargeons les graphiques des lignes de données dans la VRAM. D’abord, les SPRITES sont chargés, puis l’UDG.
    • 5000 Routine pour imprimer un numéro sur un marqueur.
      Passez la valeur dans (I) et la position dans (N).
    • 5200 Programme de suppression d’une partie de l’écran, en respectant les repères supérieur et inférieur.
    • 9000 Données du graphique UDG du jeu.
    • 9500 Données des envahisseurs selon la position et l’animation.
    Nuclear Invaders possède des sprites classiques et bien définis

    Le Jeu

    Les envahisseurs de l’espace sont de retour !!!

    En 1977, ils ont essayé d’envahir les villes de la Terre et ont échoué !
    Maintenant, ils sont de retour avec un plan diabolique : détruire les centrales nucléaires pour laisser la planète inhabitable.
    Avec l’aide de notre tank, nous devons éviter qu’ils atteignent leur objectif.

    Chaque niveau est composé de 30 envahisseurs (NDLR : je ne suis pas encore arrivé au bout des 30 premiers envahisseurs), après chaque vague il apparaîtra un centre plus grand. De ce fait, les envahisseurs doivent parcourir moins de distance pour atteindre et détruire notre planète.

    Bonus : Détruisez l’OVNI qui apparaît en haut pour obtenir des points supplémentaires.

    L’écran du 1er niveau.

    Quelques autres versions

    MSX, la plus belle version d’après Dan Cresp
    Nuclear Invaders sur ZX Spectrum
    Avec le CPC, le jeu en noir et blanc prend des couleurs !
    La version originale de Nuclear Invaders, sur Dragon 32

  • Daniel Crespo aka Dancresp, le collectionneur programmeur

    Nombre d’entre nous ont une petite collection d’ordinateurs, de consoles (enfin, ceux qui ont de la place car cela est plus encombrant que de collectionner les timbres). Si Fabrizio (l’auteur de Cross Shoot et de Cross-Chase) a choisi de porter son cross-développement une quantité impressionnante de machines, Dan porte ses créations sur quelques illustres ordinateurs qu’il affectionne particulièrement ZX Spectrum, MSX et bien sûr l’Oric

    Les années passent et il faut regarder vers l’avenir, mais faisons d’abord un petit tour dans le passé.

    Mon penchant pour l’informatique et les jeux vidéo a commencé à naître voici près de 35 ans, et depuis lors, j’ai formé des équipes, peu nombreuses et avec beaucoup d’efforts au début, mais c’est désormais plus facile.

    Début 2016, j’ai fait le point de mes priorités et de mes objectifs afin de coordonner mes actions et mes envies. Heureusement pour moi, ma passion pour ce monde informatique rétro est immense et j’ai résisté à l’envie de faire une crise et “tout laisser tomber”, J’ai donc repensé ce que je faisais et mes objectifs.

    Pour planter le décor, j’avais :

    • Environ 130 consoles, avec ou sans écran. À l’exception de deux ou trois, elles fonctionnent toutes. Incroyable !
    • Environ 100 ordinateurs et calculatrices programmables. À l’exception de deux ou trois, ils fonctionnent tous. Incroyable !!
    • Environ 160 portables, de type LCD, LED ou LSI. Sauf 3, ils fonctionnent tous. Incroyable, si si si …
    • Environ 1500 cartouches, CD et DVD d’origine. Rien ne manque ici !
    Les Game & Watch de la collection de Dan
    En sus des consoles et accessoires rétro, Dan possède plusieurs clones modernes
    Bien sûr, l’Oric est en bonne place dans sa collection

    Il n’est pas nécessaire de réfléchir beaucoup pour se rendre compte que, mis à part l’espace qu’ils occupent (j’ai la chance de ne pas souffrir de ce problème), il arrive un moment où l’on doit consacrer périodiquement du temps à les faire fonctionner un moment ou à régler de petits incidents qu’ils ont, cela me prend plus de temps que je ne le souhaite. (NDLR : La rénovation de nos micros passe bien souvent par le changement des condensateurs, l’un des organes les plus fragiles face au temps et de sus destructeur des circuits imprimés. Fort heureusement, l’Oric est peu sensible à ces phénomènes)

    Quelques-uns de ces équipements m’ont accompagné pendant une grande partie de ma vie et pour moi, leur valeur est tout simplement incalculable. Il en va ainsi pour mon ZX-81, mon Sony MSX HP-20P ou bien sûr à ma Game & Watch “Turtle Bridge” de Nintendo, ma Green House, mon Pong ou à mon Atari 2600. Et ils fonctionnent tous parfaitement.

    Autour de ce noyau informatique, beaucoup d’autres ordinateurs sont venus plus tard, certains massivement et parfois presque de manière compulsive. Certains m’ont offert de bons moments, d’autres ont été à peine utilisés. Cela m’a fait me demander s’il était nécessaire de les conserver, en particulier lorsque j’ai commencé à détecter, notamment avec les Game & Watch possédant un écran LCD, des défaillances irréparables.
    Ne nous leurrons pas, le reste, tôt ou tard, cessera de fonctionner.

    Gagner du temps avant que ces appareils finissent par se dégrader … Allez, merde ! J’aurais peut être mieux fait de collectionner des timbres.

    Qu’allons nous faire ?
    Comme je suis un homme de nature plutôt inquiète et que j’essaie de résoudre mes problèmes … j’ai lancé une série d’actions.

    Émulation

    Bien qu’au début, j’étais réticent, j’ai fini par y prendre goût. Ce n’est pas la même chose d’utiliser un émulateur sous MS-DOS ou sous Windows, et j’ai passé un bon moment à rechercher, obtenir et organiser des émulateurs de plus de 100 ordinateurs, pour la plupart des consoles, des systèmes portables et des différents systèmes d’exploitation.

    Ainsi, si certains équipements tombent en panne, je peux continuer à en profiter … A l’exception de l’Oric 1 et du ZX-81, tous les développements réalisés ont été programmés sur la plateforme d’origine. Jamais sur un émulateur ou avec des outils modernes de développement.

    Mon objectif principal est d’optimiser au maximum le BASIC de ces ordinateurs, en développant des jeux ou des applications avec une ergonomie professionnelle et une grande fluidité.
    La clé est de simplifier et de déboguer le code, en appliquant des techniques que j’ai développé et en expérimentant. Grâce à cela, les jeux comportent très peu de lignes, mais ils sont ludiques et rapides.

    Archéologie Rétro-Informatique

    Comme vous l’avez peut-être vu avec certains de mes articles consacrés aux équipements rétro-rétro (NDLR : Daniel est très actif sur www.retrowiki.es), de type IBM 1401, Kenbak-1, Programma-101 et les équipements Orao, Acorn System-1 ou Apple-1, j’adore obtenir des émulateurs de ces machines antiques (ou d’autres machines équivalentes) et rechercher sur Internet des documents permettant de produire quelque chose avec ces ordinateurs.

    Mes projets de Flow-matic, Math-Matic, Dartmouth Basic et les émulateurs de Kenbak-1 et Programma-101 ont été mes expériences les plus enrichissantes de ces dernières années. Il m’a fallu beaucoup explorer, faire des recherches et il faudra encore beaucoup d’explorations et de découvertes. Heureusement, grâce à Internet, cela ne coûte pas cher.

    Hardware

    A de très rares exceptions, je n’achète rien d’autre que des ordinateurs de plus de 20 ou 30 ans. Ainsi, je pense acheter un Apple II qui manque terriblement à ma collection.

    Au niveau des jeux vidéo, j’ai récupéré de nouvelles cartouches pour Megadrive, Atari 2600, Atari 7800, CBS Colecovision, et des cartouches de jeu Intellivision. J’ai également des consoles multi-systèmes telles que la Retron 3 ou la Game Box. Je les ai utilisées et j’en suis ravi.

    Je suis également de près les nouveaux équipements de type Spectrum Harlequin, basé sur FPGA, ou d’autres Raspberry et Arduino, entre autres.

    Réduire le stock de machines, d’interfaces et autres matériels

    C’est la partie la plus complexe.

    Après de nombreuses années à accumuler du matériel, du temps s’est écoulé et j’en ai conclu que la satisfaction que cette accumulation m’avait procurée dans le passé ne me satisfaisait plus.
    Donc, une partie de ma collection a été progressivement mise en vente, et je continuerais de la rationaliser ensuite

    Que personne ne se frotte les mains ni ne regarde le niveau de son compte en banque, car en principe je vais me débarrasser de tout le matériel dont je dispose, à l’exception du Spectrum, du ZX-81 et de l’Oric notamment. J’ai trop de choses, mais je ne vais pas faire des folies que je regretterai plus tard.

    Opérationnels ou non, ils m’accompagneront le reste de mes jours.

    Réorganiser mon sanctuaire

    J’ai un espace de 35 m2 qui est en train d’être complètement réorganisé. En 2016, je pensais me concentrer sur ce qui me plaisait vraiment mais finalement, ma collection 2019 a encore grandi.
    Au niveau des consoles, je suis généreux, et certaines ont déjà défilé jusqu’au parking, mais concernant les ordinateurs, je suis plus strict et ma garde rapprochée consiste essentiellement en mes ZX-81, Spectrum, MSX, Oric, Dragon-64, CPC-6128 + , C-64, Atari 800 et des équipements de poche. (NDLR : Effectivement, il lui manque toujours un Apple II. Si un jour Dan en récupère un, nul doute que les programmes seront adaptés)

    Finalement, je gagne beaucoup d’espace, et c’est tout sauf serré.

    En conclusion

    Quand j’aurai fini, et lorsqu’il me restera que peu de chose, je reprendrai une activité normale dans RetroWiki, parce que … non, je ne quitte pas l’univers du rétrogaming. A partir de 22h30, la famille dort et je passe 2 heures par jour dans le train. Le temps et la santé pour continuer à vous déranger avec mes “briques” pour beaucoup plus longtemps. Je le peux.

    Je n’arrête jamais de programmer sur ZX-81, notamment et bien que je veuille aussi enquêter sur des équipements particulièrement rares ou volumineux, etc. J’ai besoin de temps …

    Basic Videographie sur Oric

    • Lights Out (05/01/2012)
    • Nuclear Invaders (17/02/2013)
    • Galaxy Wars (14/09/2013)
    • Blasto (16/01/2014)
    • 6502 Assembler (20/05/2014)
    • Pipe-Mania (17/01/2015)
    • Space Invasion (21/01/2015)
    • Fungaloids (16/02/2015)
    • DBase II Lite (29/04/2015)
    • Averno (25/3/2019)
    • Solomon’s Key (17/05/2019)

  • Galaxy Wars

    Infos générales

    Ce jeu est une adaptation de la version précédemment programmée pour le COMMODORE-16 et le ZX-SPECTRUM. Pour cela, j’ai copié, ligne par ligne, le code de la version C-16, en y apportant de petites modifications car elles ont le même nombre de lignes et peuvent toutes deux utiliser ELSE.

    Galaxy Wars sur C-16, base du développement de la version Oric
    Une des premières versions de Galaxy Wars, sur ZX

    Pour la première fois, j’ai utilisé un émulateur pour développer le jeu : EUPHORIC sous MS-DOS. Le résultat est très satisfaisant puisque cet émulateur permet, en appuyant sur F3, d’avoir un clavier qui correspond à celui du PC, cela permet de taper un programme très rapidement et confortablement. Prendre un listing ou charger / enregistrer un programme est tout aussi simple.

    Les graphismes originaux, basés sur des largeurs de 8 pixels de base

    La seule complication lors du développement de cette version a été le besoin de coder à nouveau tous les graphiques, car l’ORIC utilise des caractères de 6 pixels de large et non de 8 comme le reste des ordinateurs. Ainsi, la conception du missile est légèrement plus étroite et les vaisseaux supérieurs occupent 3 caractères de large au lieu de 2. Quoi qu’il en soit, je l’ai fait et si vous touchez un navire du côté droit, vous ne le détruisez pas.

    Des graphismes “handheld”

    En ce qui concerne le son, j’ai repris les routines standards.

    Et en ce qui concerne l’aspect, grâce au système particulier de mémoire d’écran de ce système, c’est la seule version dans laquelle j’ai vraiment été capable de reproduire l’effet «cellophane», en émulant les rayures colorées.

    Ecarts à la version TAITO d’origine:

    • Cette version est un peu plus large et beaucoup moins haute puisque dans le jeu original l’écran est vertical.
    • Il y a moins de rangées d’astéroïdes, en raison de la taille verticale.
    • Pendant l’ascension du missile, nous pouvons le contrôler horizontalement, mais nous ne contrôlons pas la vitesse.
    • Les envahisseurs n’accélèrent pas lorsqu’il ne reste que quelques-uns d’entre eux.
    • Les astéroïdes ne descendent pas lorsqu’ils atteignent les extrêmes.
    • Les scores sont limités à 50, 100 et 150 points.
    • Il n’y a pas d’animations sur les ennemis.

    Le contrôle des ennemis est très simple. Il y a 6 bandes avec les ennemis dans la position correspondante. Les lignes paires tournent à gauche et les lignes impaires à droite.

    Le bloc principal du programme n’occupe que 18 lignes. À chaque passage, je déplace une rangée d’ennemis et contrôle un tir ennemi. Le compteur est commun dans les deux cas (A).

    Pour gagner de la vitesse, je me suis débarrassé des animations des ennemis. J’ai choisi d’utiliser les graphiques des ennemis dispersés.

    Lors de collisions, je vérifie seulement si la tête du missile touche quelque chose, mais pas la partie inférieure. En ce qui concerne les bombes ennemies, seul celui qui est actif vérifie s’il touche quelque chose. Cela rend le jeu plus rapide, mais il se peut que nous touchions quelque chose et que rien ne nous arrive. Comme le processus est rapide, il y a un risque … et il vaut mieux ne pas y jouer.

    En ce qui concerne les performances, cette version fonctionne aussi bien (sinon autre chose) que les deux précédentes (C-16 et SPECTRUM).
    La vérité est que, malgré ses bugs, ce BASIC tire plus que bien.

    Eh bien, rien de plus, je ne peux qu’espérer que cela vous plaise.

    Je vous invite à l’essayer.

    Quelques éléments concernant le programme

    Le programme principal est divisé en 10 blocs:

    • Déclaration de matrice. Appel aux routines principales.
    • Contrôle notre plateforme ou missile.
    • Contrôle des envahisseurs et des astéroïdes.
    • Contrôle des tirs ennemis.
    • Détection d’impact de missile. Touchez un astéroïde, un envahisseur ou un tir ennemi.
    • Perdre une vie.
    • écran de présentation.
    • Début du jeu.
    • Plusieurs routines.
    • Données avec les graphismes du jeu.

    Comment le programme fonctionne-t’il, avec ses 88 lignes ?

    • 10 – Nous définissons les matrices du jeu.
    • 30 – Initialiser l’enregistrement (R) et aller à la routine qui redéfinit les graphiques.
    • 50 – Allons à la présentation du jeu.
    • 100 – Nous déplaçons la plate-forme ou le missile dans la direction indiquée.
    • 130 – Si le missile a été tiré (T = 2), il passe à 160.
    • 140 – Si la touche RETOUR est enfoncée, nous tirons le missile et supprimons la plate-forme.
    • 160 – Nous supprimons le missile et modifions la position verticale (Y).
    • 170 – Si la pointe du missile touche quelque chose, nous sautons à 400.
    • 180 – Nous mettons le missile dans la nouvelle position.
    • 200 – Nous déplaçons l’une des 6 rangées d’ennemis ou d’astéroïdes dans la direction correspondante. (B = 1: Droite, B = -1: Gauche).
    • 220 – Nous imprimons la ligne de l’ennemi.
    • 250 – Nous voyons si l’une des 6 bombes ennemies est active.
    • 260 – Si ce n’est pas le cas, nous voyons s’il y a un envahisseur en position sur l’écran pour activer le tir.
    • 270 – Si le tir touche la plate-forme ou si le missile passe à 500.
    • 400 – Si la position Y est supérieure à 5, c’est que nous avons frappé avec un astéroïde ou tiré et sauté à 500.
    • 410 – Nous calculons la position de l’envahisseur détruit.
    • 420 – On met l’explosion, un son retentit et on calcule les points (50, 100 ou 150).
    • 430 – Nous supprimons l’envahisseur de la ligne et soustrayons un envahisseur des autres (Q).
    • 450 – Nous montrons les points et faisons une pause (5500) et mettons à jour le marqueur.
    • 470 – En passant le niveau, nous augmentons sa valeur s’il est inférieur à 5.
    • 500 – Nous mettons une explosion à la position du missile et reproduisons un son.
    • 520 – Nous mettons à jour le marqueur de vie.
    • 550 – S’il n’y a plus de vies, le jeu se termine.
    • 2000 – Écran de présentation du jeu.
    • 2050 – Appuyez sur une touche pour effacer l’écran (5400) et faire clignoter le marqueur du lecteur 1.
    • 2500 – Nous avons monté les bandes des envahisseurs.
    • 2510 – Routine générant de manière aléatoire des bandes d’astéroïdes. Fuller dans les niveaux avancés.
    • 2570 – Initialisation des variables principales de l’item.
    • 5000 – Changer les couleurs, masquer le curseur et désactiver les majuscules.
    • 5002 – Instruction Écran pendant la lecture des graphiques.
    • 5010 – La routine commence pour redéfinir le jeu de caractères.
    • 5020 – Nous sauvegardons l’attribut color de chaque ligne de l’écran dans la matrice C $.
    • 5040 – Initialise la matrice de la hauteur des différents ennemis V ().
    • 5050 – Initialise la position des bombes ennemies.
    • 5100 – Affiche le marqueur de score ou l’enregistrement.
    • 5400 – Routine d’effacement de l’écran activant les couleurs correspondantes par ligne.
    • 5600 – Affiche les 6 rangées d’ennemis dans leur position et avec la couleur correspondante.
    • 9000 – Ligne de données avec graphiques du jeu.

    Le jeu

    Ce jeu vidéo d’arcade a été développé par Universal et fabriqué par Taito en 1979.

    L’objectif du jeu est de détruire la flotte d’envahisseurs dans la partie supérieure de l’écran. Pour cela, nous contrôlons une plate-forme avec un missile. Lors du tir du missile, vous devez éviter les astéroïdes et les tirs ennemis et toucher un envahisseur.

    Contrôles:
    Appuyez sur Z ou X pour déplacer la plate-forme et le missile vers la gauche ou la droite. Appuyez sur la touche RETOUR pour tirer le missile.

    Quelques autres versions

    Comparaison de la version C-16 avec la version originale
    Le C-16 en action !
    Comparaison de la version ZX Spectrum avec la version d’arcade originale
    le ZX Spectrum en action

  • Visitons la Rom Monitoring (7e et dernière partie)

    Paru mag 164 page 6 https://www.oric.org/ceomag_download/index.php?action=&id=&exppath=/2003/ceomag/12_december

    par André C. et Claude S.Z

    Partie finale de la Rom (en FFC7-FFFF).a)

    Table de conversion Clavier/Ascii FFC7: 10 4C La touche ‘L’ de caractère Ascii normal #4C devient #10 normalement inutilisé (CTRL/P qui inverse le b2 de 026A). Le seul effet visible en pratique est qu’après un CTRL/T (mode minuscules) l’appui sur SHIFT+L n’afficherien alors que SHIFT+K par exemple affiche bien un ‘K’. Cette différence avec la Rom v1.1 ressemble bien à une bogue. Modification des vecteurs d’interruption

    b) Le vecteur d’interruption NMI, situé en FFFA-FFFB envoie normalement à l’adresse 0247 où se trouve l’adresse de la routine F8B2 (Warm Start qui correspond aussi aubouton Reset). Maintenant le détour par la page 2 a été supprimé : Le vecteur envoie directement en F8B2, supprimant ainsi tout détournement ou inhibition de ce Reset. En FFFA-FFFB les octets 4702 ont été remplacés par B2F8.c) Le vecteur d’interruption de Reset Système, situé en FFFC-FFFD renvoie normalement à l’adresse F88F où se trouve la routine Cold Start.

    Maintenant il envoie en F89A où se trouve la nouvelle routine simplifiée.En FFFC-FFFD les octets 8FF8 ont été remplacés par 9AF8.d) Le vecteur d’interruption IRQ, situé en FFFE-FFFF envoie normalement à l’adresse 0244 où se trouve celle de la routine EE22. Maintenant le détour par la page 2 a été supprimé : Le vecteur envoie directement en EE22, supprimant ainsi tout détournement. En FFFE-FFFF les octets 4402 ont été remplacés par 22EE. Le même type de prévention a été appliqué en C4B 4(001A, imprimer chaîne AY), C5E8 (023B, prendre un caractère au clavier), CCF4 (023E, vecteur imprimante), EE31 (024A, retour IRQ), F907 (0238, afficher caractère) et FA0 1 (0238, afficher caractère). BANC D’ESSAI A l’utilisation, cette Rom présente le très grand avantage de permettre une maîtrise quasi complète de la situation.

    Les outils de débogage qui ont été ajoutés (DUMP, DES, HDKMOD, CLEAN, SEARCH, MOVE et MON) font merveille. Et comme ils sont inscrits dans la Rom, ils sont disponible sen permanence. De ce point de vue la Rom Monitoring est un excellent outil de développement. La perte de certains caractères,notamment les minuscules peut être facilement contournée par leur chargement en Ram après le boot. Vous pouvez facilement récupérer le fichier nécessaire en exécutant un SAVE”MINUSC.CHS”,A#B708,E#B770 sur un Oric normal. Mais cette Rom a quand même quelques petits défauts.

    Citons en premier lieu, le non blocage du lancement AUTO lorsqu’il s’agit non plus de développer, mais de transférervos cassettes favorites sur disquette. Certes, on peut utiliser le Reset sous l’Oric et accéder à tout ce qu’il y a en mémoire. Mais ce n’est pas très pratique. Il est vrai que certaines protections reposent sur l’obligation d’exécuter le programme et nous avons fait l’expérience que les Roms ‘qui bloquent tout’ ne sont pas non plus d’un usage universel. Notez aussi que l’exécution d’un programme peut parfois détruire les vecteurs du Dos, rendant impossible la sauvegarde sur disquette… A propos de Dos, la Rom Monitoring n’est malheureusement pas compatible avec Sedoric et il faut se rabattre sur un autre Dos pour sauvegarder son travail. Enfin, l’affichage des adresses de début et de fin est très pratique, notamment parce qu’il se produit à la fin, au moment où il faut appuyer sur le Reset.

    Mais cet affichage présente l’inconvénient de polluer l’écran qui fait partie du programme qu’on cherche à récupérer. Il n’y a pas de solution simple, à part peut-être l’ouverture d’une fenêtre temporaire avec restitution ultérieure de l’écran. Mais cela aurait sans doute fait beaucoup de code à caser dans une Rom déjà pleine comme un oeuf !

    TRANSFERT K7 VERS DISQUETTE

    Si vous avez un problème pour transférer une de vos anciennes K7 sur disquette, nous vous invitons à relire notre article de synthèse paru dans le Ceo-Mag n°138, pages 6 à 9.Au fil de nos articles, nous vous avons parlé de plusieurs Roms susceptibles de vous aider : La Rom ‘Renifleuse’ (Ceo-Mag n°77, pages 3 et 4), dans laquelle les caractères minuscules ont été sacrifiés pour installer une routine qui affiche les adresses de début et de fin de fichier. Un Reset permet ensuite de sauver sur disquette en utilisant les adresses indiquées.La Rom ‘Déplombeuse’ (Ceo-Mag n°139, pages 6 à 8),dans laquelle le démarrage Auto a été neutralisé, ainsi que laroutine de ëvérification’ de la Ram (cette routine écrit des #AA puis des #55 qui écrasent tout), largement utilisée dans nombre de dispositifs ‘anti-copie’.La Rom ‘Suceuse’ (Ceo-Mag n°140, pages 7 à 10), qui a les mêmes propriétés que la ‘Déplombeuse’, mais en plus la commande EDIT a été remplacée par la commande SUCE, capable de lire octet après octet tout ce qu’il y a sur une K7 et de le copier en RAM sans chercher à savoir quoi que ce soit. B’te, mais efficace ! Enfin la Rom ‘Monitoring’ qui a fait l’objet de toute cette série d’articles, tant son contenu était riche.

    CONCLUSION

    Nous nous doutons bien que la plupart d’entre vous ont décroché depuis belle lurette, découragés par cette avalanche de code machine. Portant, le Ceo-Mag n’a pas pour unique but de distraire ses lecteurs. Comme l’ont remarqué beaucoup d’entre vous, le Ceo-Mag c’est la mémoire de l’Oric. Un hommage a été rendu à Jean-Jacques Jung, auteur de la Rom Monitoring. Espérons qu’un jour ou l’autre, certains pourront y puiser l’une ou l’autre des bonnes routines de Jean-Jacques. En attendant, n’hésitez pas à l’utiliser, même sans connaître le détail de ses rouages…