Comme indiqué dans le sous-titre, il s’agit d’une version améliorée de Radar Oric (voir le CEO-mag n°358, pages 4 & 5 et RadarOric.dsk dans le fichier 358.zip). Outre de nouvelles commandes, cette version comporte 48 nouvelles grilles réparties en 3 niveaux de difficulté (1 Fastoche, 2 Faisable et 3 Fortiche). Autre petit plus : Le jeu est maintenant bilingue Anglais et Français.
Rappel du synopsis
Votre QG est attaqué par une flotte ennemie et pour vous défendre, vous disposez d’un tout nouveau radar couplé à un ordinateur dernier cri : l’Oric. Votre tâche est de localiser exactement la position de tous les bateaux ennemis, puis de déclencher un feu apocalyptique qui les anéantira.
Vitesse de déplacement du curseur
A l’usage, il est apparu que Radar Oric pouvait être amélioré.
Tout d’abord, le déplacement du curseur trainait beaucoup trop lentement dans les 100 cases de la grille. J’ai donc un peu revu l’algorithme du jeu afin de perdre le moins de temps possible. Cela a entraîné une redéfinition des labels à attribuer aux cases. Ces labels, sont maintenant passés de 1 à 9 :
1 – Case vide
2 – De l’eau (et sans sous-marin par-dessous !)
3 – Élément de bateau présent mais indéterminé ou hypothèse de présence d’un élément
4 – Sous-marin
5 – Extrémité “gauche” d’un navire
6 – Extrémité “droite” d’un navire
7 – Extrémité du “haut” d’un navire
8 – Extrémité du “bas” d’un navire
9 – Élément du corps d’un navire
La nouveauté importante est l’ajout du label 3 qui permet de placer des hypothèses, ce qui n’est pas du luxe pour les grilles de “Fortiches”.
Autre innovation pour accélérer les déplacements : les mystérieuses commandes H et V. En fait, elles n’ont rien de mystérieux. C’est plutôt que je n’arrivais pas à décrire ces commandes de manière concise dans mon écran d’instructions ! Les commandes H ou V éditent la ligne Horizontale ou la colonne Verticale où se trouve le curseur. Cette édition consiste à marquer toutes les cases de la ligne ou de la colonne avec le label 2 (de l’eau), sauf si une hypothèse ou un élément de bateau est déjà présent. Cerise sur le bateau, le compteur des coups joués n’est pas incrémenté : non seulement vous gagnez du temps dans le déplacement du curseur, mais vous améliorez vos performances, qui je le rappelle sont la combinaison d’un score maximum ET d’un nombre minimal de déplacements. En outre, vous réduirez vos déplacements car le curseur reste à la position initiale, ce qui vous permet d’atteindre des cases distantes sans perdre de temps pour vous y rendre et pour revenir !
Nouvelles commandes
Le jeu comporte maintenant 7 commandes au lieu de 4.
Outre le commandes H et V décrites ci-dessus et les commandes déjà présentes dans la première version (flèches de déplacement, numéros de label pour les cases, R pour reprendre au début la grille en cours et S pour sauver la partie en cours afin d’aller faire dodo), la nouvelle version offre la commande L qui permet de charger (Load) la partie précédemment sauvegardée. Dans la première version de Radar Oric, on ne pouvait choisir cette option que lors du lancement du jeu. Recharger la partie sauvegardée sort donc maintenant de son rôle initial (reprise de la partie le lendemain).
En effet, au cours de la résolution d’une grille complexe, lorsque plusieurs possibilités s’offrent à vous, il est intéressant d’effectuer une sorte de point de restauration avec la commande S. Si la voie dans laquelle vous vous étiez engagée se révèle erronée, il vous suffit de restaurer l’état précédent avec la commande L et de tester une autre hypothèse. La commande R au contraire régénère la grille à son point de départ. Cette commande sert en principe à repartir sur un bon pied lorsque la situation est devenue trop embrouillée. Le score affiché est alors celui qui était présent lors du chargement initial de cette grille et non celui qui était acquis au moment “du point de restauration”. J’espère que vous apprécierez la meilleure jouabilité de Radar Oric 2 et que ce petit jeu de réflexion vous apportera quelques moments agréables…
Notre Librairie Oric compte environ 80 livres en Français, Anglais et Espagnol, mais malheureusement, à ma connaissance, aucun en Allemand, ce qui est fâcheux pour nos cousins germains. Les ouvrages les plus importants y figurent, grâce au dévouement de Jérôme et de Didier, sans oublier ceux qui ont envoyé des livres ou des scans. Mais il en manque encore pas mal et nous comptons sur vous pour contribuer à enrichir cette collection. L’ouvrage présenté aujourd’hui m’a été transmis par quelqu’un ayant appris indirectement que je m’intéressais à l’Oric. Comme quoi toutes les voies sont bonnes ! Je l’ai donc scanné et OCRisé et il est maintenant disponible en téléchargement :
L’url https://oric.bqtt.net/doku.php?id=private:librairie n’est plus valable, mais la page https://ceobeta.oric.org/doku.php?id=private:librairie est encore active. Je suppose que son équivalent définitif sera bientôt mis en ligne. En effet, La refonte en cours du site oric.org et de la page du CEO est un énorme travail et vous comprendrez qu’il entraîne forcément quelques inconvénients. En cas d’urgence, vous trouverez tous ces livres sur mon site.
Des programmes pour votre Oric
Il s’agit d’un livre d’initiation à l’Oric-1 comportant 24 petits programmes d’application.
Pratiquement tous les éditeurs ont publié ce type de bouquin et même souvent plusieurs (avec les mêmes auteurs ou avec des auteurs différents). A l’époque, il devait donc s’agir d’un marché juteux. La plupart du temps ces livres ont été publiés dans l’urgence lors de la sortie d’un nouvel ordinateur. La concurrence entre les maisons d’édition était féroce. Il en a hélas résulté que nombre de ces livres ne sont pas d’une qualité transcendante. Cependant, la bibliothèque du CEO se veut d’être exhaustive, autant que possible, et il fallait donc faire une petite place pour le livre de Michel Piot.
Le contenu de ce livre
Il est maigre : 120 petites pages, dont en annexe, les codes Ascii et les attributs ! Ces deux annexes font grise mine à côté de celles, abondantes et bien faites, du manuel de John Scriven, livré avec l’Oric-1 (téléchargeable dans la librairie du CEO).
Le coté initiation se fait au fur et à mesure des programmes proposés. L’auteur a cherché à utiliser un maximum de commandes Basic pour en illustrer l’emploi. Etant donné la faible épaisseur du livre, Michel Piot aurait pu développer un peu le chapitre 15 “Le Basic de l’Oric” du manuel de John Scriven.
Pendant que j’en suis aux récriminations, les illustrations (des photos de l’écran réel) sont souvent illisibles. Enfin, les listings sont issus d’une imprimante à aiguilles et certaines lignes sont réfractaires à toute OCRisation. Je doute qu’il soit possible de récupérer un listing utilisable. En règle générale, on est toujours obligé d’apporter des retouches aux listings issus d’une OCRisation, mais là, ça ne me semble pas rentable.
Je vais être plus positif avec les 24 programmes proposés qui sortent souvent des sentiers battus habituels (chenille, pendu etc.) et on peut y trouver quelques belles idées qui pourraient servir de point de départ pour un développement plus conséquent… Je vous laisse le soin de les explorer…
Les commandes PRINT@ et PLOT sont rejetées en mode HIRES. On obtient le message d’erreur “?DISP TYPE MISMATCH ERROR“. C’est une limitation très fâcheuse pour utiliser la zone TEXT du bas de l’écran ! Et c’est un problème qui me titille depuis des années. Pour développer un jeu en mode HIRES, j’avais besoin d’exploiter les 3 lignes de la zone TEXT pour y afficher certains paramètres de l’évolution du jeu (messages, score etc.) et il fallait trouver une solution.
Etat des lieux
En mode HIRES, la zone TEXT fonctionne comme l’écran TEXT normal (mais hélas avec quelques limitations). Si les numéros de colonnes restent inchangés (X va de 0 à 39), par contre, les numéros de lignes sont restreints (Y va de 1 à 3). En mode HIRES, on peut observer ces valeurs en suivant le contenu des variables #0268 (numéro de ligne du curseur TEXT) et #0269 (numéro de colonne du curseur TEXT). Mais à quoi cela peut-il servir puisque les commandes PRINT@X,Y; et PLOTX,Y sont prohibées? C’est ce que nous allons voir.
Pour la petite anecdote
Il existe en RAM, entre la zone écran HIRES et la zone écran TEXT, une zone mémoire de 40 octets, inutilisée à l’écran, qui pourrait correspondre à une ligne numéro zéro (une sorte de ligne service inutilisée). Il s’agit peut-être d’un résidu de développement. Notons sur le plan pratique, qu’avec une routine appropriée, il serait possible de scroller la zone TEXT d’une ligne vers le haut (c’est à dire cacher la ligne numéro 1 en vue de la récupérer ultérieurement). Tout autre usage est également à recommander (par exemple stockage de variables ou d’un bout de code en langage machine). Comme en mode TEXT, le scrolling de l’écran vers le haut n’affecte pas cette “ligne 0”.
Revenons à nos moutons
Que faire pour afficher sélectivement au point X,Y ? Il n’y a pas 36000 solutions. Soit on arrive à repositionner le curseur en X,Y et le PRINT suivant se fera à partir de ce point. Soit on calcule l’adresse en RAM correspondant à ce point X,Y et on y POKE le code Ascii souhaité. La zone texte commence en #BF68. La formule est donc AD=#BF40+(#28*Y)+X avec Y de 1 à 3 et X de 0 à 39. Mais le problème n’est pas là. Pour afficher une chaîne de caractère, il faudra découper celle-ci avec la commande MID$ et en POKEr tous les code Ascii un à un. Idem pour les nombres qu’il faut d’abord transformer en chaine de caractères. Vous pouvez imaginer la lenteur de l’affichage ! Reste donc la commande PRINT qui a la particularité d’afficher au curseur. Le problème est élémentaire mon cher Watson, il suffit de repositionner le curseur. En quelque sorte, la commande PRINT@X,Y; est scindée en deux : 1) positionner le curseur en X,Y 2) envoyer un PRINT.
Positionner le curseur sur une ligne Y
Je me suis demandé s’il ne serait pas possible de forcer la variable #0268 avec les valeurs 1, 2 ou 3 à l’aide d’un POKE. Zut, ça ne marche pas : l’affichage commence systématiquement sur la première ligne. Divers autres essais ne se sont pas révélés plus heureux. A la réflexion, ce n’est pas grave, car il suffit d’un PRINT pour passer à la ligne suivante et comme il n’y a que 3 lignes, c’est vite fait. Cette solution serait bien trop lourde en mode TEXT où il faudrait répéter 26 fois la commande PRINT pour placer le curseur sur la dernière ligne ! Je rappelle en passant que PRINT”” (chaîne vide) ne fait rien sinon passer à la ligne suivante et que PRINT””; ne fait absolument rien (sinon valider des variables du système, mais c’est un autre sujet). Il est utile de se rappeler que la commande CLS nettoie la zone TEXT et repositionne le curseur au début de la première ligne. Elle peut être utilisée à tout moment, alors que les commandes PAPER et INK doivent être placées avant la commande HIRES si on veut affecter la zone TEXT. Sinon, elles affectent la zone HIRES. Attention, la zone TEXT est scrollée exactement comme en mode TEXT, mais comme ici on ne dispose que de 3 lignes, les infos fichent rapidement le camp vers le haut, notamment lors du retour au Ready. Seule solution pour contrôler ça : Utiliser un”;” à la fin des commandes PRINT.
Positionner le curseur sur une colonne X
Et que faut-il faire pour afficher à un endroit spécifique sur la ligne ? Ecartons tout de suite l’utilisation d’espaces pour atteindre la case ciblée, car ces espaces écrasent les informations situées à gauche de cette case. On pourrait évidemment remplacer ces espaces par des codes Ascii 9 (déplacement à droite). Mais imaginez-vous en train d’écrire PRINT CHR$(9) CHR$(9) CHR$(9) CHR$(9) CHR$(9) CHR$(9) CHR$(9) CHR$(9) CHR$(9)CHR$(9) CHR$(9) CHR$(9) CHR$(9) CHR$(9) CHR$(9) CHR$(9) CHR$(9) CHR$(9)”OK” seulement pour afficher “OK” au milieu de la ligne ! J’ai donc repris l’étude des variables du système. En page zéro, l’adresse #30 contient la position du curseur sur la ligne TEXT, mais la commande POKE#30,X ne modifie pas l’affichage. En page 2, la variable #0253 contient le numéro de la première colonne valide (et donc 0 ou 2), mais la commande POKE#0253,X ne modifie pas l’affichage. De toute façon, il me semblait farfelu de toucher à ce paramètre qui gère les 2 colonnes protégées. Après le #0268 qui n’avait pas marché, il me semblait peu probable que modifier la variable #0269 (numéro de colonne du curseur TEXT de 0 à 39) donne des résultats. Mais j’ai quand même testé. Divine surprise, un POKE#0269,10:PRINT”OK” affiche bien “OK” à la position X=10 de la première ligne de la zone TEXT. Un POKE#0269,12:PRINT”OK” envoie le “OK” sur la deuxième ligne. Enfin, avec un POKE#0269,14:PRINT”OK”; on voit apparaître le hoquet sur la troisième ligne (attention à ne pas oublier le “;” final). Ceci est illustré par la recopie du bas de l’écran ci-dessous et le programme correspondant.
Affichage contrôlé dans la zone TEXT en mode HIRESEt le bout de programme qui permet de faire ça…
Dernier point sensible, cette méthode ne permet pas la mise à jour automatique de l’affichage du curseur TEXT et mes essais laissent traîner des curseurs fantômes… Il est donc impératif de bloquer l’affichage du curseur en plaçant la commande suivante : POKE#26A,(PEEK(#26A)AND#FE):PRINT””:’ CURSEUR TEXT OFF dans le programme Basic, juste après la commande HIRES. NB. Cette commande éteint le curseur quelle que soit son statut antérieur, alors que : POKE#26A,(PEEK(#26A)OR#01):PRINT””:’ CURSEUR TEXT ON allume le curseur à coup sûr (dans un programme Basic complexe, l’utilisation répétée de la bascule PRINTCHR$(17) c’est-à-dire contrôle + Q est vite difficile à gérer, car on ne sait plus où on en est). La recopie du bas de l’écran ci-dessous et le programme correspondant donnent un exemple concret de pseudo PRINT@ en mode HIRES !
Exemple d’application en situation réelleEt le bout de programme qui permet de faire ça…
En conclusion
N’importe laquelle des 120 cases de la zone TEXT est adressable individuellement. En fait, pas la 124e, qui n’est accessible qu’avec un POKE#BFDF,code Ascii sous peine de déclencher un scrolling.
Coule, je vais pouvoir retourner au développent de mon jeu…
Après une longue pause de programmation sur Oric, L’année 2019 démarre en fanfare avec ce nouveau jeu proposé par DanCresp, une pleine réussite qui a été traduite en Français quelque peu modifiée par Dom.
Informations générales
Dan a été presque quatre ans sans rien programmer pour l’ORIC. Comme le temps passe vite ! Il est de retour, avec quelques nouvelles découvertes sur son système préféré.
Cette fois, c’est une adaptation assez fidèle d’un jeu acheté pour MSX qu’il a apprécié, beaucoup aimé et qui a laissé chez Dan de bons souvenirs.
Il existe des versions pour plusieurs systèmes, vous pouvez maintenant ajouter l’ORIC. Sur l’Oric, le jeu a un mécanisme identique à celui d’origine, mais avec quelques améliorations et quelques petites choses que Dan a laissées de côté. Il lui a fallu près d’une semaine pour réaliser une version jouable !
Ecran titre de la version 2019 sur Oric
Dan est très satisfait de cette version car le jeu a les mêmes niveaux que la version originale, la même résolution des niveaux et les performances du jeu sont identiques aux versions originales, voire un peu plus élevées … sauf pour la génération de l’écran.
Les petites détails de la version ORIC Comme toujours pour 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. Comme les graphiques sont formés avec deux blocs de 1×2 caractères ou 2×2 caractères de 8×8 pixels, nous avons des blocs de 8×16 pixels ou 16×16 pixels.
La solution choisie par Dan consiste à utiliser des blocs de 1 x 3 ou 2 x 3 caractères, de sorte que les blocs aient une largeur de 18 pixels et non de 16 pixels. Comme il ne pouvait pas utiliser de couleurs pour délimiter les blocs, l’auteur a laissé une bande de pixels vide au début. et à la fin de certains graphiques pour les rendre moins déroutants. Contrairement à la version d’origine, la porte et les clés ont toutes deux un masque pour mieux s’intégrer à l’arrière-plan.
Lorsque sont placés les graphiques à l’écran, ils prennent presque toute la largeur de l’écran. Dan a donc supprimé certains marqueurs, le reste étant placé en haut, car l’ORIC comporte plus de lignes.
Un autre problème a été le problème de la couleur, en raison de la façon dont il gère les attributs, Dan a dû produire un jeu en monochrome, en donnant toutefois un peu de couleur dans la présentation et dans les marqueurs. Dommage, mais très ORIC !
L’écran du 1er niveau, en monochrome Le truc du mag, le fantôme ne peut monter que 2 marches à la fois … pensez y !
A ce stade, nous arrivons à la création de l’écran. Chaque écran est constitué d’une matrice de 20 lignes et de 10 colonnes. Dans chacune des colonnes, il y a un graphique ou une partie de celui-ci, comme avec les portes et les clés. En codant de manière brute, une matrice de 13 (écrans) x 20 (lignes) x 10 (colonnes) aurait pu être créée. Au total, 260 lignes de code, avec la quantité de mémoire correspondante, de 600 octets par niveau. Au lieu de cela, l’auteur a choisi de coder les niveaux, chaque niveau étant compris entre 50 et 100 octets. La présentation du niveau prend environ 6 secondes et le codage est effectué comme suit, l’écran étant bleu:
Une lettre entre “A” et “Z” a une valeur comprise entre 1 et 26 et correspond aux blocs de briques de l’arrière-plan à afficher.
Une lettre entre “a” et “z” a une valeur comprise entre 1 et 26 et correspond aux blocs de pierre à afficher.
Un nombre compris entre 1 et 8 correspond à un bloc prédéfini stocké dans la matrice B $, en mettant ce qui entre dans la ligne correspondante.
L’encodage des niveaux sur Oric
Avec ce nouveau logiciel, Dan a découvert de nouvelles difficultés. Ainsi, c’est la première fois qu’en BASIC, il fait bouger le protagoniste sur le fond sans le supprimer. Pour ce faire, un deuxième processus doit être effectué, ce qui prend environ 10 secondes. Au cours d’une boucle double, Dan lit la mémoire d’écran et conserve les caractères à l’écran dans la matrice “S”. Pendant le processus de lecture de la mémoire vidéo, l’auteur crée un effet d’aveuglement qui change la couleur de la ligne en jaune final. Ce n’est pas du plus bel effet, mais c’est nécessaire pour déplacer le personnage rapidement.
Le jeu original utilise des blocs cachés à plusieurs niveaux. Dan a découvert ce détail en regardant une vidéo alors que son adaptation du jeu était presque terminée et a choisi de les ignorer. Cela l’a obligé à faire quelques changements mineurs dans ces niveaux, car dans cette version, les blocs sont visibles. Cependant, ils n’affectent pas la résolution des niveaux.
Pour contrôler le curseur, le clavier est lu à l’aide d’un «PEEK 520» ($208 pour les intimes), 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 sa faiblesse dans ce domaine …
Pour terminer, ayant respecté les niveaux d’origine, Dan trouve que la difficulté n’est pas linéaire et que les niveaux les plus simples se situent au début et à la fin de la partie. Mais comme le jeu original était comme ça, l’auteur l’ai laissé ainsi.
Dan vous invite à l’essayer et espère que ce jeu vous plaira …
Quelques informations à propos du programme
Le programme est divisé en 10 blocs:
Déclaration de la matrice et début du jeu.
Boucle principale de développement.
Passer le niveau ou perdre une vie.
Mouvement fantôme.
Présentation et début du jeu.
Routine pour afficher le niveau.
Écran de victoire finale.
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 137 lignes.
10 – Nous définissons les matrices du jeu.
20 – Passez au sous-programme qui redéfinit les caractères et définit les variables globales.
30 – Afficher l’écran de présentation.
40 – Afficher le niveau.
100 – Début de la boucle principale.
105 – Prenez la touche appuyée. Si vous appuyez sur “Echap”, quittez la boucle et perdez une vie.
110 – Mouvement fantôme selon la touche enfoncée.
122 – Actualiser le repère temporel.
125 – Voyez ce qu’il y a sous le fantôme, agissez en conséquence.
135 – Mise à jour du temps, laissant la boucle si elle se termine.
140 – Retournez à REPEAT si la variable U = 0.
150 – Lorsque vous quittez la boucle, regardez la valeur de U. U = 1 pour passer le niveau ou U = 2 pour perdre une vie.
155 – La routine de la mort
200 – Déplace le fantôme vers la droite.
250 – Déplace le fantôme vers la gauche.
300 – Contrôle la chute du fantôme, surveillant s’il passe au-dessus d’une clé ou d’une porte.
400 – Montre le fantôme. Avec D = 1, regardez à droite et D = -1, à gauche.
420 – Routine de collecte de clés. Il met U = 1 si tous ont été collectés.
450 – Actualiser le marqueur de temps.
460 – Actualiser le marqueur de point.
500 – Lancer un bloc de briques. Calculez la position du fantôme pour dire quel bloc devrait tomber.
2000 – Écran de présentation.
2100 – Routine qui montre le niveau. Les données sont encodées dans la matrice M $.
2130 – Double boucle qui enregistre les caractères de chaque position sur l’écran dans la matrice D.
2200 – Écran de fin de jeu à la fin du niveau 13.
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 des matrices avec des bandes de caractères et des positions du fantôme.
9000 – DATA avec graphes, positions, blocs de graphes et codage de niveau UDG.
Le jeu
Averno est un jeu publié pour plusieurs systèmes en 1989. C’est un jeu de réflexion dans lequel nous contrôlons un fantôme qui doit collecter toutes les clés du niveau pour ouvrir la porte. Vous devez ouvrir les 13 portes pour échapper aux dégâts. Nous devons éviter de manquer de temps ou de rester coincés.
Le fantôme a la capacité de déposer des blocs de briques pour accéder à certaines parties du niveau ou de s’y placer, car il ne peut pas escalader les murs de plus de deux blocs de briques. Vous pouvez seulement déposer des blocs qui n’ont rien en dessous.
Cette version suit exactement la même mécanique et les 13 écrans sont identiques au jeu original, sauf que les blocs invisibles ont été supprimés, ce qui n’affecte pas la résolution des niveaux.
Contrôles :
Déplacez le fantôme vers la droite ou la gauche avec “Z” et “X”.
Appuyez sur “Entrée” pour déposer un bloc de briques, selon que vous êtes dessus ou partiellement dessus.
Appuyez sur “Echap” si vous êtes verrouillé. Vous allez perdre l’une de vos 5 vies.
Dans un précédent article (voir CEO-Mag n°357), j’expliquais
clairement que les commandes DSTORE
/ DRECALL souffraient de certaines
limites dans leur version initiale :
Impossibilité
de sauver des tableaux à plusieurs dimensions ;
Risque
d’écrasement de la routine en cas de redéfinition du jeu de caractères
alternés ;
Utilisation
du mode TEXT uniquement.
Avec cette nouvelle version, ces imperfections appartiennent
désormais au passé :
La routine loge entre $9400 et $977B, ce qui permet d’utiliser le mode HIRES et de redéfinir les caractères alternés mais nécessite un HIMEM#93FF avant toute utilisation ;
Grâce à l’appel de la commande SAVEM de SEDORIC, les tableaux alphanumériques de grandes tailles (et de plusieurs dimensions) peuvent être stockés sur la disquette.
La syntaxe n’a quant à elle pas évoluée :
DSTORE
TAB, “Nom Fichier” : sauve un tableau alpha/numérique avec le
nom “Nom Fichier” sur disquette
DRECALL
TAB, “Nom Fichier” : récupère un tableau alpha/numérique portant
le nom “Nom Fichier” depuis la disquette
Le branchement sur la routine se fait désormais
grâce à DOKE#4EA,#9400.
COMMENT ÇA
MARCHE ?
La sauvegarde des caractères qui composent un
tableau alphanumérique a toujours lieu en RAM Overlay, de $C400 à $C7FF :
$C400-$C401 :
nombre d’éléments stockés.
$C402-$C7FF :
caractères du tableau alphanumérique. Les caractères sont précédés d’un nombre
qui indique la taille de la variable alphanumérique en cours de stockage.
Lorsque l’adresse de stockage en RAM Overlay dépasse
$C7FF, une première sauvegarde a lieu sur la disquette. Le stockage des
éléments restants reprend alors en RAM Overlay à partir de $C400, et un nouveau
fichier sera ajouté au précédent grâce à la commande SAVEM.
Lors de la récupération des données depuis la
disquette, le premier fichier est transféré en RAM Overlay de $C400 à $C7FF.
Chaque élément du tableau alphanumérique est créé en
RAM grâce à la routine $D264/RAM Overlay ($D5AB/ROM) qui réserve une chaîne dont
la longueur est dans le registre A (adresse chaîne réservée en $D1-$D2,
longueur en $D0).
Les caractères sont ensuite copiés un par un, depuis
la RAM Overlay vers la RAM jusqu’à obtenir la longueur finale de la chaîne en
cours.
Lorsque toutes les chaînes du fichier en cours ont été transférées en RAM, on vérifie s’il existe un fichier “mergé” et on poursuit de la même manière si tel est le cas.
Au passage, quelques routines en ROM / RAM Overlay :
$EA9E (ROM) : Ajuster adresse tableau alphanumérique dans $0209-$02AA ($0C-$0D) et $02AB-$02AC.
$D264 ($D5AB/ROM) : Réserver chaîne de longueur A (adresse chaîne réservée en $D1-$D2, longueur en $D0).
$E12E (RAM Overlay) : Charger fichier mergé selon valeurs en $C102,x et $C103,x (avec valeur x fixée par le registre X).
UN BEAU DESSIN
VAUT MIEUX QU’UN LONG DISCOURS
Ci-après, les ordinogrammes des commandes DSTORE et DRECALL afin d’y voir plus clair.
UN P’TIT COUP DE DÉBOGUEUR POUR LA ROUTE ?
Les copies d’écran du débogueur ci-dessous montrent le descripteur du tableau alphanumérique M$ et une portion dudit tableau stocké en RAM Overlay.
Descripteur tableau alphanumérique M$(21)
Après sauvegarde du tableau alphanumérique M$ via la commande DSTORE M$,”TABLEAUM”, un rapide ‘DIR’ permet de vérifier la présence du fichier ‘TABLEAUM’ sur la disquette et de contrôler ses adresses de début ($C400) et de fin ($C6C8) ainsi que le type de fichier ($42).
Contenu disquette STREC.BIN (routine principale #C9400-#977B) DEMALPHA (programme de démo en Basic) TABLEAUM (Tableau alpha M$ sauvé en #C400-#C6C8)
Le manuel de l’Atmos présente l’ajout du paramètre “@X,Y;” à la syntaxe de la commande PRINT comme une simple option supplémentaire par rapport au PRINT de l’Oric-1, permettant d’afficher aux coordonnées X,Y de l’écran. PRINT@X,Y;plist n’est pas présenté comme une nouvelle commande, mais comme une simple extension de syntaxe.
D’autre part, rappelons que si on place un “;” à la fin d’une commande PRINT, les coordonnées X,Y de la “case” qui suit le dernier caractère affiché sont mémorisées pour l’impression suivante. Il est alors possible d’utiliser ces coordonnées pour une autre commande d’affichage. Pour le dire plus simplement, après le “;” final, le curseur reste à clignoter au bout du dernier affichage et représente le prochain point d’affichage.
Ce que ne dit pas le manuel
Dans certains cas, il peut y avoir un conflit entre les paramètres “@X,Y;” et le “;”final. En effet, au niveau du code, lorsqu’un paramètre “@X,Y;” a déjà été détecté au début de l’analyse de syntaxe, un paramètre “;” en fin de ligne n’est ni rejeté, ni traité correctement.
En pratique
Lorsqu’on utilise une série de PRINT@X,Y;”CHAINE”, pour chacune des commande PRINT@, la chaine mentionnée est bien affichée aux coordonnées X,Y indiquées, pas de problème. Si la longueur de la chaîne est supérieure à la place disponible, l’affichage se poursuit tout naturellement à la ligne suivante.
Si pour une raison quelconque on est amené à mélanger des commandes PRINT@ avec d’autres commandes d’affichage, on risque de rencontrer des problèmes. Voyons ce qu’il en est avec un exemple.
Soit le petit programme ci-dessus.
La chaîne figurant à la ligne Basic 10 comporte 30
caractères. Le premier caractère, un “2”, sera affiché dans la
“case” de coordonnées X=2, Y=10. Le dernier caractère, un
“1”, sera affiché dans la “case” X=31, Y=10. A cause du
“;” final, le curseur restera à clignoter sur la case suivante. (Le
déroulé du programme est trop rapide pour voir ce curseur clignotant, sauf si
on place une commande GET R$ en fin de ligne).
La ligne Basic 15 affiche “OK” au curseur, c’est à
dire au point X=32, Y=10. Ici encore, le curseur restera en attente sur la case
suivante à cause du “;” final.
La ligne Basic 20 devrait commencer l’affichage de la chaîne
“SALUT LES GARS!” (15 caractères) de la “case” de
coordonnées X=16, Y=10 et la terminer à la “case” X=30, Y=10. Au lieu de ça, seul “SALUT
” est affiché correctement, le reste de la chaîne, soit “LES
GARS!”, est rejeté au début de la même ligne n°10 de l’écran et, curieusement,
pas à la ligne suivante.
Vous me direz que le “;” n’a logiquement rien à faire à la fin du PRINT”OK” et que cela relève d’une faute de conception du programme Basic. Peut-être. Mais la commande PRINT proprement dite est mal codée : Lors de l’analyse de syntaxe, la rencontre d’un paramètre “@X,Y;” devrait entraîner la neutralisation des coordonnées X,Y en cours et leur remplacement par celles indiquées par “@X,Y;”.
Si on retire le “;” après le PRINT”OK” l’affichage rentre dans l’ordre et redevient ce qu’il doit être.
Ceci montre bien qu’il ne faut pas utiliser de “;” à la fin d’une commande PRINT@, sauf raison particulière et en toute connaissance des risques.
Il n’est pas toujours simple de comprendre ce qui se passe. Ainsi, si on garde le “;” après le PRINT”OK”, mais que l’on supprime le “;” de la ligne Basic 10, alors la chaîne “SALUT LES GARS!” s’affiche correctement. Le truc, c’est qu’entre temps les paramètres X,Y ont été régénérés lors du retour à la ligne pour afficher “OK”. Même si le curseur reste à clignoter après le “K” de OK, le PRINT@ qui suit opère sans problème.
Autre petite curiosité, lorsqu’on déplace progressivement l’affichage de la chaîne “SALUT LES GARS!” vers la droite en augmentant la valeur de X à la ligne Basic 20, on observe une rupture pour X=34. Pour X=33, le reliquat “LES GARS!” est rejeté au début de la même ligne de l’écran, alors que pour X=34, il est affiché au début de la ligne suivante, comme il se doit !
Il n’existe pas de commande LPRINT@, donc pas de problème de ce côté-là.
Oups !
J’ai fait en dernier ce que j’aurais dû faire en premier : Vérifier si la bogue “PRINT@;” était déjà connue. Et oui : Vous pouvez consulter le CEO-mag n°10, page 9 de mars 1991, qui en donne une autre démonstration (article de Roger B.).
Conclusion
Comme vous l’avez vu, la situation peut devenir complexe quand la syntaxe d’une commande est mal gérée. Il est difficile de prévoir à l’avance le résultat final. Ceci vaut évidemment pour toutes les commandes Basic de l’Oric réputées pour leurs bogues. A la liste IF THEN ELSE, RND(), POS(), CLOAD, POINT(x,y), ‘ (apostrophe pour REM), EDIT, DRAW, il faut donc ajouter PRINT@;
Ceci est une nouvelle version de l’un des jeux préférés de Dan Cresp pour le ZX-81, adapté d’abord sur MSX et SHARP MZ-700,
Fungaloids, sur Sharp MZ-700
Dan a décidé de créer une version “Cellophane Edition” pour ORIC, pour laquelle il a travaillé davantage sur la partie graphique et adapté le jeu à 36 colonnes au lieu de la version originale ou de 40 sur le MZ-700.
D’un côté, Dan aurait aimé avoir un jeu différent au niveau des couleurs, mais les limitations de l’ORIC ne l’ont pas permis. Il a donc décidé de le présenter tel quel, ce qui lui donne un aspect très rétro. Ce résultat est magnifique.
Les performances de l’ORIC sont très bonnes pour certaines choses, tel que le traitement des polices de caractères, mais en retrait pour d’autres aspects, ce qui fait que le jeu n’est pas aligné avec la fluidité que souhaitée. Comme tous les ennemis sont représentés par un seul personnage, Dan a décidé de passer directement sur l’écran vidéo par des POKE, au lieu d’utiliser le PLOT. Cela a simplifié le code et amélioré les performances.
La boucle principale se répète jusqu’à ce que nous perdions la seule vie que nous ayons. A chaque passage, nous ne déplaçons qu’un des ennemis, sélectionné aléatoirement avec un nombre compris entre 0 et 2 :
0 : Nous levons ou baissons la barrière d’énergie au hasard.
1 : Au hasard, nous élevons ou abaissons l’un des navires ennemis.
2 : Pour les fongoïdes, nous calculons un grand nombre aléatoire. S’il est inférieur à 6, nous faisons croître le Fungaloid correspondant et sinon nous ne faisons rien. Cela les fait progresser plus lentement, mais au fur et à mesure que le jeu avance, le nombre que nous calculons diminue et, par conséquent, augmente sa vitesse et sa difficulté.
Pour détecter les collisions, j’utilise certaines variables qui indiquent la position absolue dans la mémoire de l’écran sur laquelle se trouve l’aile gauche de notre navire, ou notre tir. En accédant à la mémoire vidéo avec un PEEK, nous pouvons voir que nous jouons. Cela nous évite de nombreux calculs et cela reste assez précis.
Dans le jeu original, il faut survoler un Fungaloid et lui tirer dessus. Ici, pour gagner de la vitesse, j’ai choisi de lui faire tirer dessus en détruisant un fragment de Fungaloid. Donc, je prends le même code qui me dit que Fungaloid est parvenu à poser sa balle sur le sol correspondant.
La vérité, c’est que Dan aurait aimé apporter quelques modifications, mais il a choisi de conserver l’esprit du jeu original. Bien que complètement programmé en BASIC, le jeu a atteint une vitesse très convenable et vous permet de jouer parfaitement. Bien sûr, comme pour les autres logiciels crées par Dan Cresp, le son reste le point faible.
Je vous invite à l’essayer
Quelques informations à propos du programme
Dan a divisé le programme en 11 blocs:
Déclaration de la matrice et début du jeu.
Contrôle de notre vaisseau.
Déplace les ennemis.
Contrôle du tir.
Contrôle du projectile ennemi.
Fin du jeu.
Niveau de passage.
présentation
Afficher l’écran de jeu et initialiser les variables.
Plusieurs routines.
bloc de données.
L’ensemble du programme occupe 82 lignes.
Ci dessous, le principe des différentes parties du programme:
10 – Nous définissons les matrices du jeu.
100 – Nous lisons le clavier: si aucune touche n’est enfoncée, elle passe à 170, mais le navire est supprimé de l’écran.
160 –Nous vérifions la position du navire. S’il y a autre chose que des espaces, passez à 600.
200 – Code déterminant quel ennemi nous devons nous déplacer: 0- Barrière énergétique, 1- Navires ennemis et 2- Fungaloids.
210 – Routine de mouvement de barrière d’énergie.
240 – Programme de déplacement d’un des trois navires.
270 – Programme de déplacement de l’un des six Fungaloids.
300 – Contrôle de notre tir.
400 – Commande de déclenchement fongoïde.
450 – Nous regardons les 3 personnages qui sont dans la position de notre vaisseau. S’ils ne correspondent pas au navire, cela signifie que nous sommes entrés en collision avec quelque chose et que nous sautons à la fin de la partie, sinon le système revient au début de la boucle.
600 – Fin de partie.
700 – Niveau de réussite.
800 – Divers programmes: charger des munitions (820), charger du carburant (850), montrer le score (880).
900 – Routine pour imprimer notre vaisseau dans la position correspondante.
2000 – Écran de présentation.
2500 – Nous dessinons l’aire de jeu.
2800 – Initialise les variables du jeu.
3000 – Nous chargeons les graphiques et initialisons certaines variables.
9000 – Données des positions verticales initiales des 6 fongoïdes.
Le jeu
Le jeu original a été publié en 1982 et fut programmé pour le ZX-81 étendu à 16K.
Le but du jeu est de détruire les Fungaloids avant qu’ils n’atteignent le haut de l’écran. Ces plantes poussent et produisent des spores qui nous détruisent si elles nous parviennent. Nous devons éviter d’entrer en collision avec eux ou avec les différents ennemis de la région.
Notre seul navire a une capacité limitée de carburant et de munitions et nous devons périodiquement faire le plein dans les zones correspondantes.
En détruisant tous les segments des Fungaloids, nous recevons 100 points, nous passons le niveau et la difficulté augmente.
Près de la base de certains Fungaloids, il y a des constructions. Si nous en détruisons un, nous perdons 20 points.
Le jeu se termine si nous perdons notre seule vie ou si nous perdons tous les points.
Contrôles : Q-A-O-P pour déplacer le navire et ESPACE pour tirer.
D’autres versions …
Fungaloids sur ZX-81, la version originale Fungaloids sur le MZ-700Et pour finir, sur le MSX
Prévu à l’origine pour être un cadeau de Noël, ce programme a connu un peu de retard à force de le peaufiner. Mais bon, il est maintenant disponible et vous le trouverez dans le zip accompagnant cet article, ainsi que sur mon site, à l’adresse http://andre.cheramy.net/telechargement/Programmes/choix.htm
C’est une sorte de bataille navale, mais dans le jeu
classique (en vigueur dans les cours de récréation et qui se joue sur une
grille papier), deux protagonistes
s’échangent des missiles pour couler les bateaux de l’adversaire et (cf. “touché”,
“en vue” et “dans l’eau”). Dans les équivalents numériques
le jeu est souvent réduit à un seul joueur contre l’ordinateur.
Dans Radar Oric, il n’y a aucun risque de recevoir des missiles sur vos bateaux, car vous n’avez pas de bateaux. C’est votre QG qui est attaqué par une flotte ennemie et pour vous défendre, vous disposez d’un tout nouveau radar couplé à un ordinateur dernier cri, l’ Oric. Votre tâche est de localiser exactement la position de tous les bateaux ennemis, puis de déclencher un feu apocalyptique qui les anéantira vite fait bien fait avant qu’ils aient eu de temps de dire ouf ! Oui, je sais les bateaux ne peuvent pas dire ouf, mais bon…
Le jeu proprement dit
Votre rade est représentée par une grille de 10×10 cases où les 10 bateaux de la flotte ennemie se sont faufilés, profitant d’un épais brouillard. Heureusement, il y a quelques trous dans ce brouillard, dans lesquels vous pouvez apercevoir des bouts de navires ou… de l’eau ! Mais c’est tout (voir la figure ci-dessous).
Pas facile de savoir où sont les bateaux ennemis !
Heureusement encore, votre super Radar Oric est capable de scanner cette grille
et de vous indiquer combien d’éléments de bateaux se trouvent dans chaque ligne
et dans chaque colonne (voir les chiffres rouges à gauche et sous la grille).
Heureusement encore, votre super Radar Oric est
capable de scanner cette grille, ligne par ligne et colonne par colonne, et de
vous indiquer combien d’éléments de bateaux s’y trouvent (voir les chiffres
rouges à gauche et sous la grille).
Un peu de réflexion vous permettra de déduire la
localisation exacte des 10 bateaux ennemis. Dernier petit service offert par
votre Radar Oric : il vous indiquera si vous vous êtes planté dans votre
raisonnement ou si les bateaux sont bien là où vous pensez.
Si c’est correct, il ne vous restera plus qu’à les anéantir
et l’ennemi n’aura même pas le temps de comprendre ce qui lui arrive. Le
résultat est garanti en un rien de temps !
Hélas, l’ennemi a la peau dure et il ne va pas tarder à vous
envoyer une nouvelle flotte. Sacrebleu, il va encore falloir se creuser les
méninges !
Mais tout est bien qui finit bien, il arrivera
inexorablement un moment où l’ennemi sera à court de bateaux et où aurez
définitivement gagné.
Chaque flotte ennemie est composée des 10 bateaux suivants
Un porte-avions (4 cases)
Deux croiseurs (3 cases)
Trois destroyers (2 cases)
Quatre Sous-marins (1 case)
Cet effectif vous est rappelé au-dessus de la grille et vous sera utile pour vous aider à trouver où peuvent se tenir les bateaux.
Les commandes disponibles
Les quatre flèches pour déplacer le curseur dans
la grille.
Les chiffres de 1 à 8 pour marquer la case au
curseur selon ce que vous pensez qu’elle contient.
La touche “R” pour recommencer la
grille au début, si vous êtes trop embrouillé.
La touche “S” pour sauvegarder la
partie en cours afin de la reprendre plus tard.
Correspondance entre les touches 1 à 8 et le marquage des cases
Case indéterminée
De l’eau
Corps de bateau
Sous-marins
Extrémité gauche d’un bateau
Extrémité droite d’un bateau
Extrémité basse d’un bateau
Extrémité haute d’un bateau
A tout moment, vous pourrez consulter le pense-bête, situé à
droite de la grille (chiffres bleus suivis d’une icône).
Enfin, le n° de la flotte qui vous attaque est visible juste au-dessus de ces chiffres (par exemple le
4 sur la figure ci-dessus indique que vous vous défendez contre la 4e
flotte ennemie).
Toutes les grilles du jeu ont bien sûr une solution et une seule.
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
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.
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 !
