CoddyRun

Tous les articles · Articles

Article

Comprendre le fonctionnement d’un moteur de Raycasting 2.5D

Ce programme recrée le fonctionnement des premiers jeux en vue subjective à partir d’une structure relativement simple.

CoddyRun · · 30 min de lecture · 1 lecture
Comprendre le fonctionnement d’un moteur de raycasting 2.5D en temps réel
Comprendre le fonctionnement d’un moteur de raycasting 2.5D en temps réel

Ce programme recrée le fonctionnement des premiers jeux en vue subjective à partir d’une structure relativement simple : un labyrinthe en deux dimensions, une caméra mobile et un ensemble de rayons produisant une illusion de profondeur.

Derrière son apparence tridimensionnelle, le jeu repose sur un moteur 2,5D. Il associe une génération procédurale du labyrinthe, un rendu par raycasting, des objets à collecter, un radar, des collisions et un système complet de déplacement.

L’objectif du joueur consiste à explorer un labyrinthe généré aléatoirement, à récupérer six cristaux, puis à rejoindre une porte dorée. Celle-ci ne devient accessible qu’après la collecte de tous les cristaux.

Un moteur 2,5D et non un véritable moteur 3D

Le programme ne construit pas un espace tridimensionnel à l’aide de triangles, de maillages ou de modèles 3D. Le monde est enregistré dans un simple tableau représentant une grille vue du dessus.

Chaque case de cette grille contient un nombre :
- 0 : correspond à un couloir
- 1 : correspond à un mur de pierre
- 2 : correspond à un mur de brique
- 3 : correspond à un mur métallique
- 4 : correspond à la porte de sortie

La position du joueur est déterminée par trois valeurs :

posX, posY, cap

posX et posY représentent sa position sur le plan. La variable cap indique la direction dans laquelle il regarde.

Il n’existe aucune coordonnée verticale Z. La caméra ne peut pas regarder vers le haut ou vers le bas, les murs possèdent tous la même hauteur logique et le sol reste parfaitement plat.

L’impression de profondeur est créée uniquement au moment de l’affichage. Le programme transforme les distances mesurées dans le plan 2D en hauteurs de murs à l’écran.

Cette combinaison entre un monde calculé en deux dimensions et un rendu donnant une apparence tridimensionnelle correspond à un moteur 2,5D.

La configuration du moteur

La zone d’affichage mesure 760 pixels de large sur 520 pixels de haut :

LARG vaut 760
HAUT vaut 520

Le champ de vision est fixé à 60 degrés :

ANGLE_VUE vaut 60

Pour produire l’image, le moteur lance 152 rayons. Chaque rayon correspond à une bande verticale de 5 pixels :

RAYONS vaut 152
BANDE vaut 5

Ces valeurs correspondent exactement à la largeur de l’écran : 152 × 5 = 760 pixels

Le programme ne calcule donc pas un rayon pour chaque pixel. Il calcule une distance par bande verticale, puis dessine une tranche de mur de cinq pixels de large.

Cette solution représente un compromis entre la précision du rendu et les performances. Une augmentation du nombre de rayons améliorerait la finesse de l’image, mais demanderait davantage de calculs et de formes à dessiner.

La ligne d’horizon est placée à la hauteur 250 :

HORIZON vaut 250

Elle sépare visuellement le ciel du sol et sert de centre vertical pour la projection des murs.

La constante suivante règle la taille apparente des éléments :

ECHELLE vaut 300

Plus cette valeur est élevée, plus les murs et les objets projetés paraissent grands.

La représentation du labyrinthe

Le labyrinthe est contenu dans le tableau carte. Sa taille est de 17 cases sur 17 :

COTE vaut 17

Comme carte est un tableau linéaire, une case de coordonnées (c, l) est accessible avec l’index suivant :

l * COTE + c

La fonction caseEn centralise la lecture de la carte :

fonction caseEn(c: nombre, l: nombre): nombre
    si c < 0 ou l < 0 ou c >= COTE ou l >= COTE alors
        retourne 1
    fin si

    retourne carte[l * COTE + c]
fin fonction

Cette fonction remplit deux rôles.

Elle traduit d’abord les coordonnées de colonne et de ligne en un index utilisable dans le tableau. Elle considère ensuite toute position extérieure au labyrinthe comme un mur.

Cette seconde règle est importante. Elle empêche les rayons de sortir indéfiniment de la carte et interdit au joueur de quitter l’espace de jeu.

La préparation des tableaux

Avant de créer une partie, le programme initialise les tableaux nécessaires :

procédure preparerTableaux()
    i est un nombre

    pour i de 0 à COTE * COTE - 1
        carte ajoute 1
        pileC ajoute 0
        pileL ajoute 0
    fin pour
fin procédure

Le tableau carte contient les cases du labyrinthe.
Les tableaux pileC et pileL serviront pendant la génération. Ils mémoriseront respectivement les colonnes et les lignes des cases visitées.

Leur taille correspond au nombre total de cases du terrain, ce qui garantit suffisamment d’espace pour stocker le chemin de génération.

La génération procédurale du labyrinthe

Le labyrinthe n’est pas dessiné manuellement. Il est créé au commencement de chaque partie par la procédure creuserLabyrinthe.

Initialisation du terrain

Toutes les cases sont d’abord remplies avec la valeur 1, c’est-à-dire avec des murs :

pour i de 0 à COTE * COTE - 1
    carte[i] vaut 1
fin pour

Le point de départ est ensuite placé en (1, 1) et transformé en couloir :

pileC[0] vaut 1
pileL[0] vaut 1
carte[COTE + 1] vaut 0

La variable sommet désigne la position actuelle dans la pile :

sommet vaut 0

Les quatre directions

Les directions cardinales sont enregistrées dans deux tableaux :

DIRC ajoute 1
DIRC ajoute 0
DIRC ajoute 0 - 1
DIRC ajoute 0

et :

DIRL ajoute 0
DIRL ajoute 1
DIRL ajoute 0
DIRL ajoute 0 - 1

Les couples correspondants sont donc :

(1, 0)
(0, 1)
(-1, 0)
(0, -1)

Ils représentent les déplacements vers la droite, vers le bas, vers la gauche et vers le haut dans la grille.

Le parcours en profondeur

L’algorithme avance de deux cases à la fois. Cela laisse un mur entre deux positions possibles du parcours.

À chaque étape, il récupère la case située au sommet de la pile :

c vaut pileC[sommet]
l vaut pileL[sommet]

Il choisit ensuite un ordre aléatoire pour examiner les quatre directions :

depart4 vaut hasard(0, 3)

La direction réellement examinée est calculée ainsi :

d vaut (depart4 + k) mod 4

La nouvelle position potentielle se situe deux cases plus loin :

nc vaut c + DIRC[d] * 2
nl vaut l + DIRL[d] * 2

Si cette position se trouve à l’intérieur des limites et contient encore un mur, le programme ouvre le passage.

Il transforme d’abord le mur intermédiaire en couloir :

carte[(l + DIRL[d]) * COTE + c + DIRC[d]] vaut 0

Puis il transforme la case d’arrivée en couloir :

carte[nl * COTE + nc] vaut 0

La nouvelle position est enfin ajoutée à la pile :

sommet vaut sommet + 1
pileC[sommet] vaut nc
pileL[sommet] vaut nl

L’exploration continue depuis cette nouvelle case.

Si aucune direction n’est disponible, l’algorithme remonte dans la pile :

sommet vaut sommet - 1

Ce mécanisme correspond à un parcours en profondeur avec retour sur ses pas. Il produit un labyrinthe entièrement connecté, car toutes les zones creusées appartiennent au même réseau de couloirs.

L’ajout de boucles

Un labyrinthe généré avec un parcours en profondeur contient généralement de nombreux culs-de-sac.

La procédure ouvrirBoucles supprime donc quelques murs supplémentaires. Elle cherche notamment un mur placé entre deux couloirs horizontaux :

carte[l * COTE + c - 1] = 0 et carte[l * COTE + c + 1] = 0

Elle peut également ouvrir un mur placé entre deux couloirs verticaux :

carte[(l - 1) * COTE + c] = 0
et
carte[(l + 1) * COTE + c] = 0

Lorsque l’une de ces situations est détectée, le mur devient un passage :

carte[l * COTE + c] vaut 0

Le programme tente de réaliser cette opération seize fois.

Ces ouvertures ajoutent plusieurs itinéraires possibles et réduisent le caractère strictement arborescent du labyrinthe. Le joueur peut alors contourner certaines zones au lieu de systématiquement revenir sur ses pas.

L’apparence des murs

Après la création des couloirs, la procédure habillerMurs attribue différentes matières aux murs restants.

La valeur initiale 1 représente la pierre. Un tirage aléatoire peut la remplacer par :
2 : pour la brique
3 : pour le métal

v vaut hasard(0, 9)

si v < 2 alors
    carte[l * COTE + c] vaut 3
sinon si v < 5 alors
    carte[l * COTE + c] vaut 2
fin si

Les couleurs de base sont stockées dans trois tableaux :

MUR_R
MUR_G
MUR_B

Chaque type de mur possède ainsi une composante rouge, verte et bleue.

Le programme ne charge pas de textures. L’identité visuelle de chaque paroi repose sur une couleur unie, ensuite modulée selon la distance et l’orientation de la face.

Le placement de la sortie

La porte est installée sur l’un des murs extérieurs du labyrinthe.

La fonction couloirDepuis mesure le nombre de cases de couloir accessibles dans une direction donnée :

fonction couloirDepuis(c, l, dc, dl): nombre

Elle commence à la position voisine et avance tant que les cases rencontrées sont des couloirs. La recherche est limitée à neuf cases.

La procédure poserSortie examine ensuite les quatre bordures de la carte :
- le bord inférieur
- le bord supérieur
- le bord droit
- le bord gauche

Pour chaque position possible, le programme attribue une note en fonction de la longueur du couloir situé derrière le mur :

loin vaut note * 4 + c + COTE

ou, selon le bord examiné :

loin vaut note * 4 + l

L’emplacement ayant la meilleure note devient la sortie :

carte[bl * COTE + bc] vaut 4

La position centrale de la porte est ensuite enregistrée :

sortieX vaut bc + 0.5
sortieY vaut bl + 0.5

Ce système cherche à placer la porte face à un couloir suffisamment long. Le joueur peut ainsi l’apercevoir à une certaine distance au lieu de ne la découvrir qu’au dernier moment.

Le lancement d’une nouvelle partie

La procédure nouvellePartie réinitialise l’état du jeu :

posX vaut 1.5
posY vaut 1.5
cap vaut 0
porteOuverte vaut faux
ramasses vaut 0
depart vaut chrono()
duree vaut 0
distanceFaite vaut 0

Le joueur commence au centre de la case (1, 1).

L’utilisation de coordonnées décimales permet des déplacements fluides, même si le labyrinthe est composé de cases entières.

La procédure exécute ensuite toutes les étapes de création :

appelle creuserLabyrinthe()
appelle ouvrirBoucles()
appelle poserSortie()
appelle habillerMurs()
appelle placerCristaux()

L’ordre de ces opérations est important. Les couloirs doivent être générés avant la pose de la sortie et le placement des cristaux. L’habillage des murs intervient après le placement de la porte afin de ne pas modifier sa valeur spéciale.

Le cœur du rendu : le lancer de rayons

La procédure dessinerVue constitue le cœur graphique du programme.

Pour chacune des 152 bandes de l’écran, elle calcule la distance entre le joueur et le premier mur visible.

La direction de la caméra

La direction du joueur est transformée en vecteur :

dirX vaut cosinus(cap)
dirY vaut sinus(cap)

Pour chaque rayon, le moteur calcule un angle compris dans le champ de vision de 60 degrés :

ang vaut cap + radians(0 - ANGLE_VUE / 2+ ANGLE_VUE * i / (RAYONS - 1))

Le premier rayon part vers le bord gauche du champ de vision. Le dernier part vers le bord droit. Tous les autres sont répartis entre ces deux limites.

La direction du rayon est obtenue avec :

rdx vaut cosinus(ang)
rdy vaut sinus(ang)

Deux contrôles empêchent les composantes de devenir exactement nulles :

si absolue(rdx) < 0.00001 alors
rdx vaut 0.00001
fin si

Le même traitement est appliqué à rdy. Cette précaution évite une division par zéro dans les calculs suivants.

La position dans la grille

Le joueur possède une position continue, par exemple (4.37, 8.62). Le moteur doit cependant déterminer la case entière dans laquelle il se trouve :

mx vaut arrondi_inferieur(posX)
my vaut arrondi_inferieur(posY)

mx et my correspondent donc aux coordonnées de la case actuellement occupée.

Le fonctionnement de l’algorithme DDA

La méthode DDA fait progresser le rayon de frontière en frontière dans la grille.

Le moteur calcule la distance nécessaire pour traverser une colonne ou une ligne :

dx vaut absolue(1 / rdx)
dy vaut absolue(1 / rdy)

Il détermine ensuite le sens de progression sur chaque axe :

sx vaut -1 ou 1
sy vaut -1 ou 1

Les variables cx et cy indiquent la distance jusqu’aux prochaines frontières verticale et horizontale.

À chaque itération, le programme compare ces deux distances :

si cx < cy alors
  cx vaut cx + dx
  mx vaut mx + sx
  face vaut 0
sinon
  cy vaut cy + dy
  my vaut my + sy
  face vaut 1
fin si

Si cx est plus petit, le rayon rencontre d’abord une frontière verticale. Sinon, il rencontre une frontière horizontale.

Le contenu de la nouvelle case est alors examiné :

v vaut caseEn(mx, my)
 
si v > 0 alors
  touche vaut 1
fin si

La boucle s’arrête dès qu’un mur ou la porte est rencontré.
Cette méthode est plus efficace qu’une progression par très petits pas, car elle ne teste que les cases réellement traversées par le rayon.

Le calcul de la distance

Lorsque le rayon rencontre une paroi, le moteur récupère la distance atteinte juste avant l’entrée dans la case du mur :

si face = 0 alors
  dist vaut cx - dx
sinon
  dist vaut cy - dy
fin si

La variable face indique si l’impact s’est produit sur une frontière verticale ou horizontale.
Cette information servira également à appliquer une luminosité différente selon l’orientation du mur.

La correction de l’effet fish-eye

La distance parcourue par un rayon latéral est naturellement plus grande que celle du rayon central.

Si cette distance brute était utilisée directement, les murs sembleraient courbés sur les bords de l’écran. Cet effet est généralement appelé fish-eye.

Le programme corrige cette déformation avec :

corr vaut dist * cosinus(ang - cap)

La différence ang - cap représente l’écart entre le rayon considéré et l’axe central de la caméra.

Cette multiplication transforme la distance mesurée le long du rayon en une distance perpendiculaire au plan de projection. Les murs apparaissent alors droits.

Une valeur minimale est imposée :

si corr < 0.05 alors
  corr vaut 0.05
fin si

Cette précaution évite une division par une valeur nulle ou extrêmement petite lorsque le joueur se trouve presque contre un mur.

La projection des murs

Une fois la distance corrigée, la hauteur apparente du mur est obtenue par une relation inverse :

hauteurMur vaut limiter(ECHELLE / corr, 4, HAUT * 2)

Plus la paroi est proche, plus sa tranche est grande. Plus elle est éloignée, plus elle paraît petite.

La fonction limiter empêche la hauteur de descendre sous quatre pixels ou de dépasser deux fois la hauteur de l’écran.

La position verticale est centrée autour de l’horizon :

hy vaut HORIZON - hauteurMur / 2

La position horizontale dépend de l’indice du rayon :

hx vaut i * BANDE

Le moteur dessine finalement une bande rectangulaire :

rectangle(ecran, hx, hy, BANDE, hauteurMur, couleur)

La répétition de ces 152 bandes produit l’image complète du labyrinthe.

La lumière et le brouillard de distance

La luminosité d’un mur est calculée à partir de sa distance :

f vaut limiter(1.25 - corr * 0.11, 0.12, 1)

À courte distance, f se rapproche de 1. La couleur reste alors proche de sa teinte d’origine.
À grande distance, f diminue jusqu’à 0.12. Les murs deviennent plus sombres, ce qui simule un brouillard ou une diminution progressive de la lumière.

Les faces horizontales et verticales ne reçoivent pas exactement la même luminosité :

si face = 1 alors
  f vaut f * 0.66
fin si

Cette différence aide le joueur à distinguer les angles du labyrinthe. Deux murs perpendiculaires possèdent des teintes légèrement différentes, ce qui renforce l’impression de relief.

Lorsque la porte est ouverte, sa luminosité est augmentée :

si ton = 4 et porteOuverte alors
  f vaut limiter(f * 1.9 + 0.25, 0, 1)
fin si

Elle devient donc plus visible après la collecte des six cristaux.

L’arête supérieure des murs

Après avoir dessiné une tranche de mur, le programme ajoute une fine ligne claire sur son bord supérieur :

rectangle(ecran, hx, hy, BANDE, 2, couleur_claire)

La couleur est obtenue en ajoutant de la luminosité aux composantes du mur, sans dépasser 255.
Cette ligne souligne les contours des parois et améliore la lisibilité de la scène, notamment dans les zones sombres.

Le ciel et le sol

Avant de dessiner les murs, le moteur affiche plusieurs grandes zones de couleur :

rectangle(ecran, 0, 0, LARG, HORIZON, CIEL_HAUT)
rectangle(ecran, 0, HORIZON - 60, LARG, 60, CIEL_BAS)
rectangle(ecran, 0, HORIZON, LARG, HAUT - HORIZON, SOL_HAUT)
rectangle(ecran, 0, HORIZON + 70, LARG, HAUT - HORIZON - 70, SOL_BAS)

Deux teintes sont utilisées pour le ciel et deux autres pour le sol.

Il ne s’agit pas d’un véritable dégradé calculé pixel par pixel. Le programme superpose plusieurs bandes colorées afin de créer une variation simple et économique.

Le tableau de profondeur

Pour chaque rayon, la distance du mur détecté est enregistrée dans le tableau profondeur :

profondeur[i] vaut corr

Ce tableau joue le rôle d’un tampon de profondeur par colonne.

Dans un moteur 3D traditionnel, un z-buffer peut stocker une profondeur pour chaque pixel. Ici, comme le décor est calculé par bandes verticales, une distance par rayon suffit pour déterminer si un objet se trouve devant ou derrière un mur.

Cette information est utilisée pendant le dessin des cristaux.

La projection des objets

Les cristaux ne sont pas de véritables modèles tridimensionnels. Ils sont construits avec des formes 2D projetées dans la vue.

La procédure dessinerObjet commence par calculer la position de l’objet relativement au joueur :

rx vaut ox - posX
ry vaut oy - posY

Elle construit ensuite un plan de caméra perpendiculaire à la direction du regard :

planX vaut 0 - dirY * tangente(radians(ANGLE_VUE / 2))
planY vaut dirX * tangente(radians(ANGLE_VUE / 2))

Une transformation permet d’obtenir deux valeurs :
tx, qui représente la position latérale de l’objet dans l’espace de la caméra ;
ty, qui représente sa profondeur devant la caméra.

L’objet n’est projeté que s’il se trouve devant le joueur :

si ty > 0.25 alors

Sa position horizontale à l’écran est ensuite calculée :

ex vaut LARG / 2 * (1 + tx / ty)

Sa taille varie en fonction de sa profondeur :

t vaut limiter(ECHELLE / ty, 6, 420)

Comme pour les murs, un objet proche paraît grand tandis qu’un objet éloigné paraît petit.

Le masquage des objets par les murs

Avant de dessiner un cristal, le moteur détermine la colonne d’écran correspondante :

col vaut limiter(arrondi_inferieur(ex / BANDE), 0, RAYONS - 1)

Il compare ensuite la profondeur de l’objet avec celle du mur enregistré pour cette colonne :

si ty < profondeur[col] alors

Si la profondeur du cristal est inférieure à celle du mur, l’objet est devant la paroi et peut être affiché.

Dans le cas contraire, il se trouve derrière le mur et n’est pas dessiné.

Cette comparaison empêche les cristaux d’apparaître à travers les parois.

La méthode reste volontairement simple : le masquage est vérifié à partir de la colonne centrale de l’objet. Pour de petits cristaux, cette approximation produit un résultat satisfaisant.

Le dessin d’un cristal

Chaque cristal est construit avec plusieurs formes géométriques.

Un cercle transparent produit une aura autour de l’objet :

cercle(ecran, ex, ey, t * 0.34, rgba(91, 214, 240, 0.14))

Un premier polygone forme le corps principal du cristal :

polygone(ecran, ex, ey - t * 0.3, ex + t * 0.19, ey,ex, ey + t * 0.3, ex - t * 0.19, ey, teinte)

Un second polygone plus clair simule un reflet sur sa surface.

La taille de toutes ces formes dépend de t. Le cristal conserve donc les mêmes proportions quelle que soit sa distance.

Comme le dessin est directement réalisé dans le plan de l’écran, l’objet reste toujours orienté vers la caméra. Ce type de représentation est appelé un billboard.

Le tri des objets

Lorsque plusieurs objets se superposent, leur ordre de dessin devient important.

La procédure dessinerObjets affiche les cristaux du plus éloigné au plus proche.

Pour chaque cristal, elle calcule une distance au carré :

d vaut(criX[i] - posX) * (criX[i] - posX) + (criY[i] - posY) * (criY[i] - posY)

Le calcul d’une distance au carré évite d’utiliser une racine carrée, inutile pour une simple comparaison.

L’objet possédant la plus grande distance est dessiné en premier. Les objets proches sont ensuite affichés par-dessus les objets éloignés.

Le placement des cristaux

Le jeu contient six cristaux :

NB_CRISTAL vaut 6

La procédure placerCristaux choisit aléatoirement des cases de couloir.

Une condition évite de placer un cristal trop près du point de départ :

absolue(c - 1.5) + absolue(l - 1.5) > 6

Lorsqu’une position convient, le cristal est placé au centre de la case :

criX[i] vaut c + 0.5
criY[i] vaut l + 0.5

Chaque cristal possède trois informations :
- sa coordonnée horizontale dans criX
- sa coordonnée verticale dans criY
- son état dans criPris

Une valeur 0 dans criPris signifie que le cristal est toujours présent. Une valeur 1 signifie qu’il a été ramassé.

La collecte des cristaux

La procédure majObjets vérifie la distance entre le joueur et chaque cristal encore présent :

d vaut absolue(criX[i] - posX) + absolue(criY[i] - posY)

Le programme utilise ici une distance simplifiée, obtenue par l’addition des écarts sur les deux axes.

Si cette valeur descend sous 0.6, le cristal est collecté :

criPris[i] vaut 1
ramasses vaut ramasses + 1

Un message indique alors la progression :

"Cristal 3 sur 6."

Lorsque le sixième cristal est récupéré, la porte devient accessible :

porteOuverte vaut vrai

Un nouveau message informe le joueur de son ouverture.

La porte et la condition de victoire

La fonction libre détermine si une position est praticable.

Une case de valeur 0 est toujours accessible :

si v = 0 alors
  retourne vrai
fin si

Une case de valeur 4 n’est accessible que lorsque la porte est ouverte :

si v = 4 et porteOuverte alors
  retourne vrai
fin si

Avant la collecte complète, la porte se comporte donc comme un mur.

Une fois la porte ouverte, le programme vérifie la proximité entre le joueur et son centre :

si absolue(sortieX - posX) + absolue(sortieY - posY) < 0.8 alors
  etat vaut 2
fin si

La valeur 2 correspond à l’écran de victoire.

Les déplacements du joueur

La procédure majJoueur lit l’état des touches et répartit les commandes dans trois variables :
- av pour avancer ou reculer
- cot pour effectuer un pas de côté
- tour pour pivoter

Les touches directionnelles ou Z et S permettent d’avancer et de reculer.
Les touches Q et D commandent la rotation.
Les touches A et E produisent un déplacement latéral.

La rotation est calculée avec :

cap vaut cap + tour * VIT_TOURNE * dt

L’angle est ensuite maintenu entre 0 et 2π.

Le vecteur de direction du joueur est obtenu avec :

dirX vaut cosinus(cap)
dirY vaut sinus(cap)

Le déplacement vers l’avant utilise directement ce vecteur :

appelle avancer(dirX * av * VIT_AVANCE * dt, dirY * av * VIT_AVANCE * dt)

Le pas de côté utilise un vecteur perpendiculaire :

appelle avancer(0 - dirY * cot * VIT_COTE * dt, dirX * cot * VIT_COTE * dt)

Cette organisation permet des déplacements fluides vers l’avant, vers l’arrière et sur les côtés.

L’utilisation du temps écoulé

La variable dt représente le temps écoulé depuis l’image précédente :

dt vaut limiter((instantT - dernierTemps) / 1000, 0, 0.1)

Les vitesses sont multipliées par cette durée :
code]
VIT_AVANCE * dt
VIT_COTE * dt
VIT_TOURNE * dt
[/code]

Grâce à ce calcul, le joueur se déplace approximativement à la même vitesse lorsque la fréquence d’affichage varie.

La limitation à 0.1 seconde empêche un mouvement excessif après une interruption ou une image particulièrement longue à calculer.

Les collisions avec les murs

La procédure avancer traite séparément les axes horizontal et vertical :

si libre(nx + signe(ax) * RAYON_CORPS, posY) alors
posX vaut nx
fin si

Puis :

si libre(posX, ny + signe(ay) * RAYON_CORPS) alors
  posY vaut ny
fin si

Si le déplacement horizontal est autorisé, il est appliqué. Le déplacement vertical est ensuite testé indépendamment.

Cette séparation améliore le confort de jeu. Lorsqu’un joueur avance en diagonale contre une paroi, l’axe bloqué est refusé, mais l’autre peut continuer. Le personnage glisse donc le long du mur au lieu de rester complètement immobilisé.

La constante suivante ajoute une marge autour du joueur :

RAYON_CORPS vaut 0.22

Sans cette marge, la collision serait vérifiée uniquement au centre du personnage. Celui-ci pourrait alors s’approcher excessivement des murs ou sembler les traverser partiellement.

Le calcul de la distance parcourue

Lorsqu’un mouvement est accepté, le programme augmente la variable distanceFaite :

distanceFaite vaut distanceFaite + absolue(ax)

ou :

distanceFaite vaut distanceFaite + absolue(ay)

Cette valeur est affichée à la fin de la partie sous la forme d’un nombre de « pas parcourus ».

Le programme ne compte donc pas réellement des pas individuels. Il additionne les composantes de déplacement effectivement appliquées.

Le radar local

Le radar est affiché dans un panneau de 132 pixels sur 132, en haut à gauche :

rectangle_arrondi(ecran, 14, 14, 132, 132, 8, rgba(8, 12, 22, 0.82))

Il ne redessine pas la totalité du labyrinthe. Il examine uniquement les cases situées dans une zone de huit cases autour du joueur :

pour c de mc - 8 à mc + 8
pour l de ml - 8 à ml + 8

Chaque case est positionnée relativement au joueur :

x vaut 80 + (c - posX) * maille
y vaut 80 + (l - posY) * maille

Le joueur reste donc au centre du radar tandis que le labyrinthe semble se déplacer autour de lui.

Les éléments sont représentés par des couleurs distinctes :
- les murs sont bleu sombre
- la porte est dorée
- les cristaux sont cyan
- le joueur est rouge

Le champ de vision sur le radar

Deux lignes partent du joueur pour représenter les limites du champ de vision.

La première utilise l’angle :

cap - radians(ANGLE_VUE / 2)

La seconde utilise :

cap + radians(ANGLE_VUE / 2)

Ces deux lignes forment un cône de 60 degrés correspondant à la zone couverte par les rayons.

Le radar n’est donc pas seulement une carte locale. Il indique également l’orientation du joueur et la portion du labyrinthe visible dans la vue subjective.

L’interface utilisateur

L’interface affiche plusieurs informations :
- le nombre de cristaux récupérés
- le cap du joueur
- le temps écoulé
- l’état de la porte
- les messages temporaires

Les cristaux collectés sont représentés par des losanges cyan. Ceux qui restent à trouver sont dessinés avec une couleur transparente.

La fonction pointCardinal transforme l’angle de la caméra en une direction lisible :
- Nord
- Est
- Sud
- Ouest

Le programme convertit l’angle en degrés, le normalise, puis sélectionne la direction correspondant à l’intervalle obtenu.

Les messages temporaires

La procédure annoncer permet d’afficher une notification :

procédure annoncer(txt: texte)
  message vaut txt
  messageFin vaut chrono() + 2600
fin procédure

Le texte est enregistré dans message.

La variable messageFin contient l’instant auquel le message doit disparaître. Comme le programme ajoute 2600 au chronomètre courant, la notification reste visible pendant environ 2,6 secondes si chrono() est exprimé en millisecondes.

Le message est affiché tant que la condition suivante reste vraie :

chrono() < messageFin

Ce système est utilisé pour indiquer la collecte d’un cristal ou l’ouverture de la porte.

Les différents états du jeu

La variable etat pilote trois phases :
- 0 : pour l’écran d’accueil
- 1 : pour la partie en cours
- 2 : pour l’écran de victoire

État 0 : accueil

L’écran d’accueil présente :
- le titre du jeu
- la nature du rendu
- les commandes
- l’objectif
- une invitation à cliquer

Un clic fait passer le programme à l’état actif.

État 1 : partie

Pendant la partie, le programme met à jour :
- les mouvements
- les collisions
- les cristaux
- l’ouverture de la porte
- la condition de victoire
- le chronomètre

État 2 : victoire

Après avoir atteint la sortie, le programme affiche :
- un message de réussite
- le temps final
- la distance parcourue
- une invitation à créer un nouveau labyrinthe

Un clic relance alors la procédure nouvellePartie.

L’ordre de rendu

La procédure générale dessiner affiche les éléments dans l’ordre suivant :

appelle dessinerVue()
appelle dessinerObjets()
appelle dessinerRadar()
appelle dessinerInterface()

Elle ajoute ensuite l’écran d’accueil ou l’écran de victoire si nécessaire.

Cet ordre correspond à une superposition logique :
- le décor est dessiné en premier
- les cristaux sont placés dans la scène
- le radar est affiché au-dessus
- l’interface est ajoutée
- l’accueil ou la victoire recouvre l’ensemble

Les panneaux utilisent des couleurs semi-transparentes. La scène reste donc partiellement visible derrière les écrans d’accueil et de fin.

La boucle principale

Le programme fonctionne à l’intérieur d’une boucle exécutée tant que appActif reste vrai :

tant que appActif

À chaque passage, il commence par mesurer le temps écoulé :

instantT vaut chrono()
dt vaut limiter((instantT - dernierTemps) / 1000, 0, 0.1)
dernierTemps vaut instantT

Si une partie est active, il met à jour le joueur et les objets :

appelle majJoueur(dt)
appelle majObjets()

Le chronomètre de la partie est également actualisé :

duree vaut (chrono() - depart) / 1000

Si le programme se trouve sur l’écran d’accueil ou de victoire, il attend un nouveau clic.

Le dessin est ensuite actualisé :

appelle dessiner()
affiche ecran

Une courte pause termine l’itération :

pause 30

Cette attente de 30 millisecondes donne une fréquence théorique maximale proche de 33 images par seconde, sans compter le temps nécessaire aux calculs et à l’affichage.

La détection des clics

La variable clicAvant permet de détecter le moment précis où le bouton de la souris vient d’être pressé :

si souris_appuyée(ecran) et clicAvant = faux alors

Sans ce contrôle, un clic maintenu pendant plusieurs images pourrait déclencher plusieurs actions.

À la fin de chaque itération, l’état actuel du bouton est mémorisé :

clicAvant vaut souris_appuyée(ecran)

Le programme peut ainsi distinguer un nouveau clic d’un bouton déjà maintenu.

La fermeture du programme

Lorsque la touche Échap est pressée, la boucle principale s’arrête :

si touche_pressée('échap') alors
  appActif vaut faux
fin si

Après la sortie de la boucle, l’écran est effacé et un message final est affiché :

label(ecran, LARG / 2 - 70, HAUT / 2, "A bientot.", OR, 20)

Le programme attend ensuite 800 millisecondes avant de se terminer.

Les principales qualités techniques du programme

Ce moteur réunit plusieurs mécanismes complémentaires dans une architecture relativement accessible.

Une génération rejouable
Chaque nouvelle partie produit un labyrinthe différent. Les passages supplémentaires, les matériaux, l’emplacement de la sortie et les cristaux contribuent à renouveler l’exploration.

Un rendu économique
Le moteur n’utilise que 152 rayons et des formes géométriques simples. Il évite les modèles 3D et les textures complexes.

Une perspective corrigée
La correction de la distance perpendiculaire empêche les murs de paraître courbés sur les bords de l’écran.

Une profondeur cohérente
Le tableau profondeur empêche les cristaux de s’afficher lorsqu’un mur se trouve devant eux.

Des déplacements réguliers
L’utilisation de dt réduit l’influence de la fréquence d’affichage sur la vitesse du joueur.

Des collisions confortables
Le traitement séparé des axes permet de glisser contre les murs.

Une progression compréhensible
Le joueur dispose d’un objectif clair, d’indicateurs visuels, d’un radar et de messages temporaires.

Les limites du moteur

Le programme reste volontairement plus simple qu’un véritable moteur 3D.

Il ne gère pas :
- les sols et plafonds texturés en perspective
- les hauteurs variables
- les escaliers
- les pièces superposées
- les ponts
- les modèles polygonaux
- les lumières dynamiques réelles
- les ombres portées
- la rotation verticale de la caméra
- un tampon de profondeur par pixel

Les objets sont également masqués à partir d’un test effectué sur leur colonne centrale. Pour des objets très larges, une comparaison sur plusieurs colonnes offrirait un résultat plus précis.

Ces limites ne constituent pas nécessairement des défauts. Elles résultent du principe du raycasting sur une grille et permettent au moteur de rester rapide, lisible et relativement facile à comprendre.

Les améliorations envisageables

Plusieurs évolutions pourraient enrichir le programme sans modifier complètement son architecture.

Ajouter des textures
La position exacte du point d’impact sur un mur pourrait servir à sélectionner une colonne dans une texture. Les parois afficheraient alors des motifs détaillés de pierre, de brique ou de métal.

Améliorer le brouillard
Au lieu de seulement assombrir les murs, le moteur pourrait mélanger progressivement leur couleur avec une teinte de brouillard.

Animer les cristaux
Leur position verticale, leur rotation apparente ou leur taille pourrait varier légèrement en fonction du temps.

Ajouter de nouveaux objets
Des clés, des pièges, des bonus ou des éléments décoratifs pourraient réutiliser le système de projection existant.

Introduire des portes intermédiaires
Certaines parties du labyrinthe pourraient demander une clé particulière ou un nombre minimal de cristaux.

Affiner le masquage des objets
Toutes les bandes occupées par un objet pourraient être comparées avec le tableau de profondeur, au lieu de vérifier uniquement sa colonne centrale.

Ajouter une mémoire au radar
Le plan pourrait conserver les zones déjà découvertes et dissimuler les parties encore inexplorées.

Générer des cartes plus grandes
La taille du labyrinthe pourrait devenir configurable. Il faudrait alors adapter le nombre de cristaux, la quantité de boucles et le choix de la sortie.

Conclusion

Ce programme constitue un exemple complet de moteur de jeu 2,5D par lancer de rayons. Son monde est une grille en deux dimensions, mais chaque colonne de l’image est construite selon la distance entre le joueur et les murs. Cette technique suffit à produire une vue subjective convaincante sans utiliser de véritable géométrie 3D.

Le programme rassemble plusieurs mécanismes importants :
- la génération procédurale par parcours en profondeur
- l’ouverture de passages supplémentaires
- le raycasting DDA
- la correction de l’effet fish-eye
- la projection en perspective des murs
- l’atténuation de la lumière selon la distance
- les objets orientés vers la caméra
- le tampon de profondeur par colonne
- les déplacements fluides avec collisions
- le radar local
- la collecte d’objets
- l’ouverture conditionnelle de la sortie
- la gestion des écrans d’accueil, de jeu et de victoire

Son intérêt ne réside pas uniquement dans son résultat visuel. Il montre comment une succession de calculs 2D relativement simples peut former un jeu en vue subjective cohérent, interactif et rejouable.

Ce moteur constitue ainsi une démonstration pédagogique complète des principes employés par les premiers jeux en pseudo-3D.

Le programme complet

Réservé aux membres

740 lignes de CoddyRun, à copier puis à coller dans l'application. Le compte est gratuit et prend une minute.

@  CONFIGURATION
ecran est une toile
LARG est un nombre
LARG vaut 760
HAUT est un nombre
HAUT vaut 520
dimension(ecran, LARG, HAUT)
Le programme entier est réservé aux membres Créez votre compte gratuit pour le lire en entier et le copier.
Partager

Les programmes présentés ici tournent avec CoddyRun, gratuit pour Windows. Pour les essayer sans rien installer, ouvrez les démos en ligne.