Tag: dancresp

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 !

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 !

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.

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.

Une version française modifiée

Dom, dont vous trouverez le post sur https://forums.oric.org/t694-enfer#8970 a amélioré le logiciel de Dancresp.

• Utilisation de video inverse sur les tableaux
• Ajout de l’enregistrement des High Scores
• Ajout d’une ‘P’ Pause et d’une ‘S’ Sauvegarde (associées aux touches ‘1’ et ‘2’ de l’écran principal)
• Transformation du .tap en .dsk
• Corrections de bugs

Informations générales

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,

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 …

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

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

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.

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.

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.

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