Category: 2019

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.

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.

Quelques autres versions

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.

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.

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.

É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

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.

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.

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.

• 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

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.

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.

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.

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.

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.

Quelques autres versions