Rebords, escaliers et ponts en pixel art dans un monde de tuiles

Un rebord, dans les Pokémon en 2D, n’exige aucune différence de hauteur. C’est une porte à sens unique dans le graphe de marche, et il relie le plus souvent deux cellules de même élévation stockée : dans Rouge Feu, chacune de ses 1 042 cellules de rebord est stockée à la valeur de transition 0, 984 d’entre elles (94,4 %) relient un départ et une réception à la même élévation, et aucune ne relie deux niveaux de sol différents ; dans Émeraude, c’est le cas de 784 sur 944 (83,1 %), et 28 (3,0 %) sautent d’un niveau de sol à un autre, le moteur se contentant de donner au marcheur l’élévation de la cellule de réception, comme après n’importe quel pas.1234 Aucun rebord des cartes lues dans Rouge, Cristal, Émeraude ou Rouge Feu ne se franchit vers le haut de l’écran, et dans Rouge, Cristal et Émeraude le saut couvre deux cellules en 32 images, 0,536 seconde, sur un arc de 12 pixels, l’ombre restant au sol.156 Là où la troisième génération stocke une hauteur, il s’agit d’un deuxième niveau, rarement d’un troisième : 50 des 68 agencements extérieurs d’Émeraude et 67 des 76 de Rouge Feu utilisent au plus un niveau de sol, les escaliers extérieurs d’Émeraude font le plus souvent une ou deux cellules (73 sur 84) et coûtent un pas ordinaire (les escaliers de roche de Rouge Feu ralentissent la marche), et seules 252 des 702 cellules de pont d’Émeraude (35,9 %) portent la valeur multiniveau qui permet de passer dessous.789 Rejouée sur les 114 escaliers extérieurs des deux jeux, la règle de marche d’Émeraude les gravit tous, et la règle esquissée dans les notes de moteur de Kiradex n’en gravit aucun.10 La ville de Kiradex World tient sur deux niveaux depuis le build 35, avec un mur de soutènement et une volée d’escalier toutes les 7 ou 8 tuiles, et une descente placée n’importe où dans ce mur ferait gagner au plus 0,59 tuile sur un trajet d’une porte du haut à une porte du bas, et rien sur un trajet vers l’arrivée.114 Le cahier des charges dit donc oui aux descentes, comme arêtes orientées, au bord de la place, là où le chemin du retour est long ; non à la hauteur par cellule tant qu’aucune tuile n’est praticable à deux hauteurs ; et il apporte une règle de marche corrigée, un saut, une rangée de toit praticable, une passerelle et neuf vérifications qu’un script ou une capture peut exécuter.

En bref

  • Un rebord est une arête, et il n’a pas besoin de hauteur. Dans Rouge Feu, les 1 042 cellules de rebord sont toutes à la valeur de transition et 94,4 % relient des élévations égales ; dans Émeraude, c’est le cas de 83,1 % des cellules de rebord droites ayant une cellule de chaque côté (784 sur 944), le triplet le plus fréquent étant départ 3, rebord 0, réception 3, 598 fois, et seules 28 relient deux niveaux de sol différents, 22 de 5 vers 3 et 6 de 3 vers 5. Dans la troisième génération, le moteur n’accorde un rebord au joueur que si le comportement de la cellule désigne la direction droite du déplacement ; il ne lit jamais l’élévation du rebord, et après le saut le marcheur prend celle de la cellule de réception.121234
  • Les rebords descendent ou vont de côté, jamais vers le haut, et surtout vers le sud. En comptant les cellules que chaque moteur fait sauter, les 946 cellules de rebord d’Émeraude sont à 69,5 % orientées sud, les 1 042 de Rouge Feu à 92,3 %, les 758 de Rouge à 93,5 % vers le bas, et les 1 148 de Cristal à 84,0 % droit vers le bas ; les constantes de saut vers le haut de Cristal sont marquées inutilisées et n’apparaissent dans aucune carte lue. Les 77 pièces d’angle diagonales d’Émeraude sont dessinées et bloquées, et aucun code ne les lit ; les angles de Cristal, eux, se sautent.1315144
  • Le saut prend le temps de deux pas de marche, quelle que soit l’allure. Rouge, Cristal et Émeraude déplacent tous le joueur de deux cellules en 32 images, 0,536 seconde (Rouge attend ensuite au moins trois images de plus avant de relire la croix directionnelle), en s’élevant de 12 pixels, avec une ombre gardée au sol, un son au départ et, dans Émeraude, un nuage de poussière de trois images à la réception ; dans Émeraude, un joueur qui court saute dans les mêmes 32 images, deux fois le temps qu’il lui faut pour courir sur ces deux cellules.6151612174
  • La hauteur, là où elle est stockée, se résume à deux niveaux reliés par un escalier d’une cellule. À l’extérieur, 99,7 % des paires praticables adjacentes sur un niveau de sol d’Émeraude et 99,8 % de celles de Rouge Feu se trouvent sur un même niveau ; 73 des 84 escaliers extérieurs d’Émeraude font une ou deux cellules et coûtent un pas ordinaire, tandis que les escaliers de roche de Rouge Feu ralentissent la marche de 16 à 23 images par cellule.7864
  • Sur un escalier, le marcheur n’appartient à aucun niveau. Émeraude met l’élévation du marcheur à 0 sur une cellule de transition ; rejouée sur les 114 escaliers extérieurs d’Émeraude et de Rouge Feu, cette règle les gravit tous, et l’esquisse des notes de moteur de Kiradex, qui conserve l’ancienne hauteur, n’en gravit aucun.31018
  • Un rebord mérite sa cellule là où l’escalier est loin. La moitié des 549 cellules de rebord droites extérieures mesurées dans Émeraude (269) n’ont aucun détour possible dans leur carte, et les autres un détour médian de 12 cellules contre les 2 du saut ; la terrasse de Kiradex a une volée d’escalier toutes les 7 ou 8 tuiles, si bien qu’une descente y fait gagner au plus 0,59 tuile.19114
  • Ce que cela apporte à Kiradex. Un cahier des charges pour des descentes à sens unique dans les murs en terrasse de la promenade des Prés, qui conservent le chemin du retour de 88,07 tuiles du billet sur les routes et, reliées à la Grand-Place, raccourcissent l’aller sur certains agencements, si bien que la conception à descentes respecte les fourchettes du cahier des charges des routes sur 4 607 des 160 000 agencements d’ouvertures, contre 4 111 pour le portillon ; un saut qui prend le temps de ses deux tuiles à l’allure propre du marcheur, 0,5 seconde à la marche actuelle, avec l’ombre au sol, et qui s’écarte du canon à la course, là où un saut de durée fixe rendrait le retour en courant par le pré plus lent que celui par le portillon de la haie (section 9) ; une règle de marche corrigée pour le jour où une carte aura besoin de hauteur ; une rangée de toit praticable ; une passerelle au-dessus de l’étang qui ramène un trajet de 12,83 tuiles à 6,00 ; et neuf vérifications de recette.2021221123

Kiradex est mon app de collection de cartes pour iPhone, et Kiradex World est la petite ville en pixel art qu’elle abrite, où les collectionneurs se promènent, se croisent et montrent leurs cartes. La ville tient sur deux niveaux depuis le build TestFlight 35 : un mur de soutènement sur toute sa largeur, traversé par cinq volées d’escalier, avec en haut les maisons, la halle et la terrasse de la fontaine, et en bas la cour d’arrivée, la boutique de cartes et le parc.2425 Sa hauteur est dessinée, pas parcourue. La forge qui construit la ville le dit en une phrase : « Height is drawn, not simulated: the wall’s cells are blocked and the stairs are stone, so nothing about the feet changed. » (la hauteur est dessinée, pas simulée : les cellules du mur sont bloquées et les escaliers sont en pierre, donc rien n’a changé pour les pieds).24 Trois billets précédents de cette série ont laissé la question suivante en suspens. La recherche sur les structures refusait les rebords (« No ledges to jump, no climbing, no isometric », pas de rebords à sauter, pas d’escalade, pas d’isométrie), le billet hommage a réduit ce refus à « a one-cell, one-way drop » (une descente d’une cellule, à sens unique) sans aucune hauteur, et le billet sur les routes a tiré son chemin du retour plus court d’un portillon dans une haie et renvoyé les descentes à sens unique à ce billet.262717

Ce billet mesure donc comment la troisième génération stocke la hauteur (Rouge et Cristal n’en stockent pas par cellule), ce qu’est un rebord dans les données des quatre jeux, combien de temps dure un saut, ce que coûte un escalier, comment un pont fait passer un marcheur au-dessus d’un autre, et à quelle fréquence on a besoin de tout cela. Il relit ensuite les jeux SNES et les références modernes à travers ce que la recherche sur les structures avait déjà établi, et tranche la question des rebords pour Kiradex avec des chiffres tirés de la ville telle qu’elle est livrée.

1. Comment la troisième génération stocke la hauteur, mesuré dans le code

Les chiffres proviennent de clones superficiels des décompilations pret, les projets communautaires qui reconstruisent chaque jeu en C et en assembleur avec des constantes nommées : pokered à d2704a6 (commit du 22 septembre 2026), pokecrystal à 5beda23 (29 septembre), pokeemerald à 731ad5b (1er octobre) et pokefirered à 037335f (26 septembre).28 Chaque décompte ci-dessous est la sortie d’un script Python conservé avec sa sortie dans le dossier de preuves de l’auteur pour ce billet. Il y en a douze, sept issus du premier jet et cinq ajoutés lors de la relecture (r3_jump_behaviors.py, r4_corner_cells.py, astra_ledge_triples.py, astra_meadow_joined.py et cr3_bridge_ledge_cells.py), plus un utilitaire, engine_terrain.py, qui lit dans le code C les tests d’eau et de pont du moteur lui-même. La relecture par le second moteur a trouvé fautif le filtre de sol de measure_gen3_elevation.py, un filtre par nom qui prenait les comportements de pont pour de l’eau, et il a été reconstruit à partir du test du moteur ; l’ancien script et ses sorties sont conservés à côté des nouveaux, et la section sur les escaliers ci-dessous indique quels chiffres ont bougé. Pour ce jet, j’ai relancé les douze dans une copie de travail du dossier et retrouvé leurs sorties enregistrées octet pour octet, à deux exceptions près, toutes deux dans astra_meadow_joined.py : une ligne qui affiche la durée d’exécution de sa première section, et le balayage des 160 000 agencements, exécuté une fois et non répété. Un treizième, arith.py, affiche chaque valeur dérivée des leurs.2072913222304 Les cellules de la troisième génération sont décodées avec le décodeur du billet sur les routes, si bien que les deux billets lisent les mêmes cartes de la même façon.177

Deux unités reviennent. Une cellule est le carré de carte de 16 pixels sur 16 des consoles portables, et une tuile celui de Kiradex, 16 texels de côté, de sorte que les deux se comparent une pour une. Les secondes à la fréquence d’images des consoles utilisent 2^24 ÷ 280 896, soit 59,7275 images par seconde.204

Seize bits par cellule, dont quatre pour la hauteur

Une cellule de carte de la troisième génération est une valeur de 16 bits. Les dix bits de poids faible désignent le metatile, les deux suivants la collision et les quatre de poids fort l’élévation : MAPGRID_ELEVATION_MASK 0xF000 // Bits 12-15. L’en-tête nomme quatre des seize valeurs (son cinquième nom, ELEVATION_INVALID, est hors de cette plage) : ELEVATION_TRANSITION = 0, ELEVATION_SURF = 1, ELEVATION_DEFAULT = 3 et ELEVATION_MULTI_LEVEL = 15.31 Porymap, l’éditeur de cartes qu’utilise la communauté des décompilations, explique le champ en termes simples : « Elevation is how the game determines whether or not an object is on the same level as something else. » (l’élévation est la manière dont le jeu détermine si un objet se trouve ou non au même niveau qu’autre chose). Le type transition « allows the player to move between different elevations. The most common use case is for stairs. » (permet au joueur de passer d’une élévation à l’autre ; l’usage le plus courant concerne les escaliers). Et le type multiniveau « is used for bridges » (sert aux ponts) et « remembers the player’s previous elevation » (mémorise l’élévation précédente du joueur).32

Le jeu n’utilise que peu des seize. Comptées sur chaque agencement utilisé par une carte, une fois chacun, les cellules d’Émeraude se trouvent 157 795 fois à l’élévation 0, 58 262 fois à 1, 28 fois à 2, 80 178 à 3, 3 652 à 4, 2 832 à 5, 55 à 6, 845 à 7, 112 à 9 et 523 à 15. Les élévations 8 et 10 à 14 ne servent jamais.7 Sur le sol extérieur (routes, bourgs, villes et routes maritimes ; le sol est une cellule de collision 0, qui n’est pas de l’eau selon le test du moteur lui-même, MetatileBehavior_IsSurfableWaterOrUnderwater, qui lit une table d’indicateurs dans metatile_behavior.c, et qui n’est pas à l’élévation 1, la valeur de surf), Émeraude place 34 315 cellules à l’élévation 3, 2 240 à 5, 1 006 à 4, 835 à 7, 109 à 9, 2 427 à la valeur de transition 0 et 261 à 15. Sur ces 261, 248 sont les tabliers des ponts sous lesquels passe un surfeur (section 4), 4 sont les ponts de rondins de Cimetronelle, et 9 sont du sol ordinaire, MB_NORMAL : 6 sur la Route 119, 1 sur la Route 120 et 2 à Bourg-en-Vol.733 Le premier jet de ce billet reprenait son test d’eau au script du billet sur les routes, qui cherchait les mots OCEAN et POND n’importe où dans le nom d’un comportement et comptait donc chaque cellule MB_BRIDGE_OVER_OCEAN et chaque cellule de pont sur étang comme de l’eau ; la relecture par le second moteur l’a repéré, et chaque décompte de ce billet qui dépend de la question de savoir quelles cellules sont du sol a été recalculé avec le test du moteur. Dans Émeraude, cela a fait passer 552 cellules extérieures du côté du sol, dont 300 tabliers de pont stockés à 4, 248 à 15 et 4 à la valeur de transition 0, les cellules aux extrémités de deux ponts de la Route 110 que comptent les escaliers ci-dessous, et les escaliers ont bougé avec elles ; dans Rouge Feu, qui n’a aucun comportement de pont, rien n’a bougé.74 Les cellules de Rouge Feu n’utilisent que 0, 1, 3, 4 et 5.7 Lue à la lumière des noms de l’en-tête, l’élévation 3, la valeur par défaut, est le sol ; 1 est de l’eau portant un surfeur ; 0, la valeur de transition, est un sol qui n’appartient à aucun niveau ; et le reste est le sol surélevé d’une poignée de cartes.317 Tout ce qui est à 0 n’est pas escalier. Sur les 2 427 cellules de sol extérieures à 0 d’Émeraude, les escaliers sont les 169 qui forment des taches touchant deux niveaux (décomptées ci-dessous), et les 2 258 autres sont du sol de transition dans des taches qui touchent un seul niveau ou aucun. Les cellules de rebord n’en font pas partie : la plupart des cellules de rebord sont elles aussi stockées à 0 (section 2), mais chacune est stockée bloquée, et le décompte du sol exclut les cellules bloquées.78134

Un seul niveau est la norme

Barres empilées des agencements extérieurs selon le nombre d'élévations de sol utilisées : Émeraude, 68 agencements, 4 sans aucune, 46 avec une, 12 avec deux, 6 avec trois ou plus ; Rouge Feu, 76 agencements, 4 sans aucune, 63 avec une, 9 avec deux, aucun avec trois. En dessous, parmi les paires adjacentes de cellules extérieures praticables sur un niveau de sol, 170 des 61 197 d'Émeraude et 122 des 61 461 de Rouge Feu changent de niveau sans cellule bloquée entre elles.

Niveaux de sol par carte extérieure, et rareté des cellules praticables voisines de hauteurs différentes ; tracé par figures/make_figures.py à partir de gen3_elevation.txt.

Sur les 68 agencements extérieurs d’Émeraude, 50 utilisent un niveau de sol ou aucun (46 un, 4 aucun), 12 en utilisent deux et 6 trois ou plus : Algatia (3, 4, 5, 7 et 9), la Route 114 (3, 4, 5 et 7), Éternara (3, 5 et 7), et la Route 116, la Route 120 et le nord-ouest du Parc Safari, trois chacun.7 Rouge Feu ne dépasse jamais deux : sur ses 76 agencements extérieurs, 63 utilisent un niveau de sol, 9 deux et 4 aucun.7 En proportion, 73,5 % des cartes extérieures d’Émeraude et 88,2 % de celles de Rouge Feu sont plates pour autant que la marche puisse en juger.4 Selon ma lecture, les six cartes d’Émeraude à trois niveaux ou plus sont ses pièces maîtresses, et un deuxième niveau est un atout qu’une carte doit mériter, pas un réglage par défaut.

La hauteur change sur une paroi, pas sur un nombre

Le moteur pourrait laisser deux cellules praticables voisines à des hauteurs différentes, sans rien entre elles que le nombre, et la règle de marche ci-dessous refuserait le pas. Émeraude ne le fait presque jamais. Sur chaque agencement extérieur, en comptant les paires de cellules de sol praticables adjacentes qui se trouvent toutes deux sur un niveau de sol (cellules de transition et multiniveaux mises à part), 170 paires se situent à deux niveaux différents, contre 61 027 paires au même niveau, soit 0,28 %, dans 14 agencements ; Rouge Feu en a 122 contre 61 339, 0,20 %, dans 8.74 Les paires de niveaux sont surtout 3 contre 5 (97 dans Émeraude) et 3 contre 4 (42 dans Émeraude, 88 dans Rouge Feu).7 Le script ne compte que les paires qui se touchent ; selon ma lecture, partout ailleurs un changement de niveau passe par un escalier ou par une cellule bloquée entre les deux côtés, une paroi rocheuse que le joueur peut voir, ce que fait aussi la rangée de mur de Kiradex.724 À l’extérieur, 99,7 % des paires praticables adjacentes sur un niveau de sol d’Émeraude et 99,8 % de celles de Rouge Feu se trouvent donc sur un même niveau.4

L’élévation 15 : la valeur des ponts, et rare

La valeur multiniveau est rare. Treize des 441 fichiers d’agencement d’Émeraude l’utilisent, dont 12 agencements qu’utilise une carte, 523 cellules en tout, la Route 110 à elle seule 185 ; Rouge Feu ne l’utilise dans aucun de ses 365.7 Cela concorde avec les « thirteen of 441 layouts » (treize agencements sur 441) du billet sur les structures.25 Ce qui se trouve sous l’élévation 15 dans Émeraude est pour moitié environ du pont, 252 des 523 cellules (48,2 %) : MB_BRIDGE_OVER_OCEAN 201 cellules, MB_CAVE 114, MB_NORMAL 81, MB_OCEAN_WATER 76, MB_BRIDGE_OVER_POND_HIGH 31, MB_BRIDGE_OVER_POND_MED 16 et MB_FORTREE_BRIDGE 4.7344 Selon ma lecture, les cellules de grotte et d’eau à 15 sont la même idée hors des ponts, un sol sur lequel un marcheur peut se trouver à l’une ou l’autre de deux hauteurs ; la section 4 compte les ponts.

La règle de marche, en deux fonctions

Toute la règle tient en deux courtes fonctions de src/event_object_movement.c. Avant un pas, et une fois vérifiés les bits de collision propres à la cellule, IsElevationMismatchAt ne signale aucune incompatibilité si l’élévation du marcheur est 0, ou si celle de la cellule cible est 0 ou 15 ; sinon, une élévation différente est une collision.3 Au début de chaque pas puis à sa fin, ObjectEventUpdateElevation revient sans rien changer si la cellule où l’on entre ou celle que l’on quitte est à 15. Sinon, elle met la currentElevation du marcheur à celle de la cellule, 0 compris, et ne met à jour previousElevation, la valeur qui choisit la priorité d’affichage du marcheur, que si la cellule n’est ni à 0 ni à 15.3

Il en découle tout le tour de passe-passe de l’escalier. Un marcheur qui pose le pied sur une cellule de transition prend l’élévation 0, et un marcheur à 0 n’est incompatible avec rien, si bien que le pas suivant peut aller sur l’un ou l’autre niveau. L’escalier ne relie pas les deux niveaux en se trouvant sur l’un d’eux ; il les relie en n’appartenant à aucun. Le pont est le cas inverse : sur une cellule à 15, le marcheur garde la hauteur avec laquelle il est arrivé, si bien que le même tablier est un sol pour qui y est monté depuis la rive haute, et rien du tout pour qui arrive de l’eau en dessous.332

Ce qu’est un escalier dans les données

Un escalier, dans la troisième génération, n’est pas un type de tuile. C’est une petite tache de cellules de transition qui touche deux niveaux de sol. Comptés comme des taches 4-connexes de cellules praticables à l’élévation 0 touchant deux niveaux ou plus, les agencements extérieurs d’Émeraude comptent 84 escaliers, 169 cellules ; 73 des 84 (86,9 %) font 1 sur 1, 1 sur 2 ou 2 sur 1 cellules (26, 26 et 21 d’entre eux), et les plus grands sont une tache de 3 sur 4, une de 5 sur 3 et une de 1 sur 6. Ils relient les niveaux 3 et 4 (57 escaliers), 3 et 5 (17), 5 et 7 (4), 4 et 5 (4), 7 et 9 (1), et 3 et 7 (1). Quatre des 84 sont des escaliers pour la règle de marche et non pour l’œil : des taches de transition de deux cellules aux extrémités de ponts, sur la Route 110 en (21, 13) et (28, 91) et sur la Route 120 en (7, 15) et (28, 15), là où un tablier stocké à 4 rejoint une rive à 3 ; le filtre d’eau du premier jet avait écarté les tabliers, et avec eux le second niveau que touchent ces taches, et le test du moteur les rétablit. Rouge Feu en a 30, 59 cellules, dont 26 de 2 sur 1, reliant 3 et 4 (20) et 3 et 5 (10).84

Les escaliers d’Émeraude ne portent aucun comportement d’escalier. Leurs cellules sont MB_NORMAL (97), MB_SAND (56) ou MB_NO_RUNNING (10), plus les quatre cellules MB_BRIDGE_OVER_OCEAN aux extrémités des ponts de la Route 110, un MB_MOUNTAIN_TOP et un MB_BUMPY_SLOPE ; le seul comportement de l’en-tête dont le nom contient « STAIRS » est MB_STAIRS_OUTSIDE_ABANDONED_SHIP, que MetatileBehavior_IsNorthArrowWarp compte comme un warp. Un escalier coûte dans Émeraude un pas ordinaire, aux 16 images par cellule de la marche.834

Ceux de Rouge Feu en portent un : 49 de leurs 59 cellules (83,1 %) sont MB_ROCK_STAIRS, et un pas vers le nord depuis une cellule d’escalier de roche, ou vers le sud pour y monter, ce que teste PlayerIsMovingOnRockStairs, fait passer le joueur à PlayerWalkSlow ou PlayerRunSlow. Rejoué image par image à partir de UpdateWalkSlowAnim et UpdateRunSlowAnim, cela donne 23 images par cellule à la marche au lieu de 16, 1,44 fois plus long, et 11 à la course au lieu de 8, 1,38 fois.83564 À chaque pas d’une montée, la différence est de 7 images à la marche, environ 0,12 seconde, et de 3 images à la course, environ 0,05 seconde.4 Selon ma lecture, Rouge Feu dépense cette fraction de seconde pour qu’une montée se ressente comme telle, et Émeraude ne s’en donne pas la peine.

La règle, testée sur chaque escalier

Le billet sur les structures renvoyait à une règle de marche écrite pour Kiradex dans son dossier moteur, pour le jour où une carte aurait besoin de hauteur : un canStep(to:height:) qui autorise un pas vers la même hauteur, vers une transition ou vers un pont, et un height(after:was:) qui renvoie la hauteur du marcheur « unchanged on a transition or a bridge » (inchangée sur une transition ou un pont).1825 Elle ressemble à la règle d’Émeraude. Elle en diffère d’une ligne : Émeraude met l’élévation du marcheur à 0 sur une cellule de transition, et l’esquisse conserve l’ancienne.318

Schéma de quatre cellules en ligne, élévation 3, 3, un escalier à 0, et 4. Avec la règle d'Émeraude, l'élévation du marcheur vaut 3, 3, 0, 4 et le dernier pas est autorisé ; avec l'esquisse du dossier moteur, elle vaut 3, 3, 3 et le pas vers 4 est refusé. Mesurée sur chaque escalier extérieur, la règle d'Émeraude en gravit 84 sur 84 dans Émeraude et 30 sur 30 dans Rouge Feu ; l'esquisse en gravit 0 sur 114.

Un escalier, deux règles ; tracé par figures/make_figures.py à partir du test de règles de gen3_elevation.txt.

measure_gen3_elevation.py teste les deux. Pour chacun des 114 escaliers, il place un marcheur sur une cellule du niveau inférieur de l’escalier et cherche en largeur sur des paires formées d’une cellule et de l’élévation du marcheur, sous chaque règle tour à tour, s’il atteint quelque part dans la carte une cellule du niveau supérieur voisine de l’escalier. La règle d’Émeraude gravit les 84 escaliers extérieurs d’Émeraude et les 30 de Rouge Feu. L’esquisse n’en gravit aucun, car un marcheur qui atteint l’escalier à 3 est toujours à 3 lorsqu’il rencontre le 4 au-dessus.10 Le script consigne les cinq premiers échecs de chaque jeu à titre d’exemple : pour Émeraude, cinq escaliers de Cimetronelle, et pour Rouge Feu, cinq dans la zone est du Parc Safari, tous entre les niveaux 3 et 4.10 La section 9 donne la règle corrigée ; l’esquisse n’a jamais été construite, et le dossier moteur la range à l’étape 10 de son ordre de travail, « only when a map uses them » (seulement quand une carte s’en sert), si bien que rien dans l’app n’est cassé par elle aujourd’hui.18

2. Ce qu’est un rebord dans les données

Le nom suggère une descente, et le graphisme en dessine une : une surface éclairée au-dessus d’une lèvre qui s’assombrit (la section 3 la mesure). Les données disent autre chose.

Troisième génération : un comportement qui désigne une direction

Dans Émeraude, un rebord est un comportement de metatile, pas une hauteur. Quand le joueur pousse contre une cellule, GetLedgeJumpDirection cherche son orientation dans une table de quatre tests, MetatileBehavior_IsJumpSouth, IsJumpNorth, IsJumpWest et IsJumpEast, qui reconnaissent chacun un comportement, et renvoie DIR_NONE sauf si le comportement de la cellule est celui de la direction du déplacement ; dans ce cas, le joueur obtient COLLISION_LEDGE_JUMP, et le jeu comptabilise le saut avec IncrementGameStat(GAME_STAT_JUMPED_DOWN_LEDGES).312 La vérification du rebord intervient après la lecture de la collision de la cellule et l’emporte sur elle, et elle le doit : chacune des 1 023 cellules des cartes d’Émeraude qui portent un comportement de saut est stockée bloquée, collision 1.1213 L’en-tête définit huit comportements de saut, dont nord, nord-est et nord-ouest, et les quatre tests comprennent un saut vers le nord, si bien que le moteur sait sauter vers le nord ; aucun metatile des 70 jeux de tuiles d’Émeraude ne porte l’un des trois comportements orientés vers le nord (0 sur 232 metatiles de saut), donc aucune carte ne le lui demande.3429

Les cartes portent bien deux comportements diagonaux, MB_JUMP_SOUTHWEST sur 44 cellules et MB_JUMP_SOUTHEAST sur 33. D’après leurs noms et leur graphisme (la section 3 en mesure six, dessinées comme les rebords sud, une surface éclairée au-dessus d’une lèvre sombre), ce sont des pièces d’angle, là où une rangée de rebord se termine ou tourne. Aucun code ne les lit. Recherchés dans les dossiers src/ et include/ du jeu, les quatre noms diagonaux apparaissent dans la liste de l’en-tête et à un seul autre endroit, une table d’indicateurs de tuile dans metatile_behavior.c dont le code commente lui-même l’indicateur par « Set but never read » (positionné mais jamais lu) ; aucun test, aucun code de déplacement, rien d’autre. Faute de test de rebord qui leur corresponde, elles retombent sur leur collision, et les 77 sont toutes stockées bloquées. Les pièces d’angle d’Émeraude sont donc des angles dessinés que personne ne saute : une fin pleine de rebord, pas une descente en diagonale.1334 Les angles de Cristal sont différents, comme le montre la section sur la deuxième génération ci-dessous : ils se sautent. Ce billet ne compte comme cellule de rebord d’Émeraude qu’une cellule que le moteur peut faire sauter, l’un des quatre comportements droits, 946 cellules ; les 77 pièces d’angle sont comptées à part partout où elles apparaissent. L’en-tête de Rouge Feu ne définit que les quatre comportements droits, et aucun metatile ni aucune cellule de carte de Rouge Feu ne porte de valeur là où Émeraude range ses diagonales.13

Ce qui se trouve sous le comportement est la surprise. Pour chaque cellule de rebord droite ayant une cellule de chaque côté, measure_gen3_elevation.py lit trois élévations : la cellule de départ, la cellule de rebord et la cellule de réception.1

Barres empilées des élévations de départ, de rebord et de réception des cellules de rebord droites ayant des cellules des deux côtés. Émeraude, 944 cellules : départ et réception égaux pour 784 (83,1 %), en tête 3-0-3 avec 598 et 3-3-3 avec 131 ; différents pour 160, en tête 0-0-3 avec 96, dont 132 ont une cellule de transition d'un côté et 28 relient deux niveaux de sol, 22 en 5-0-3 et 6 en 3-0-5. Rouge Feu, 1 042 cellules : 3-0-3 904, 0-0-0 80, 0-0-3 58 ; égaux pour 984 (94,4 %), et les 58 qui diffèrent ont toutes une cellule de transition au départ.

Élévations de départ, de rebord et de réception de chaque cellule de rebord droite ; tracé par figures/make_figures.py à partir de gen3_elevation.txt.

Dans Émeraude, 784 des 944 sont à l’élévation 0, et 784 ont la même élévation au départ et à la réception, 83,1 % ; le triplet le plus fréquent est départ 3, rebord 0, réception 3, 598 fois, puis 3, 3, 3, 131 fois, et 0, 0, 3, 96 fois.14 Les deux 784 sont des ensembles différents qui se trouvent avoir la même taille : 131 cellules de rebord sont à 3 entre deux cellules à 3, et parmi les cellules à 0 figurent 96 dont le départ est lui-même une cellule de transition.1 Dans Rouge Feu, les 1 042 cellules de rebord sont toutes à 0, et 984 d’entre elles (94,4 %) ont des élévations de départ et de réception égales : 904 sont 3, 0, 3, 80 sont 0, 0, 0, et les 58 autres sont 0, 0, 3.14

Les 160 cellules d’Émeraude qui diffèrent se répartissent en deux groupes. 132 ont une cellule de transition au départ ou à la réception, si bien qu’un côté du saut n’appartient à aucun niveau : les 96 en 0, 0, 3 et 22 en 0, 3, 3 en font partie. Décodées cellule par cellule, 128 des 132 ont un départ stocké bloqué, si bien qu’aucun marcheur ne se tient derrière le rebord pour le sauter ; les 4 dont le départ est ouvert atterrissent toutes sur 3, et aucune n’est en extérieur (deux dans l’arène de Vermilava, une dans l’arène de Cimetronelle, une au B2F de la Route Victoire). Les 28 autres, 3,0 % des 944, relient deux niveaux de sol différents : 22 sont départ 5, rebord 0, réception 3, et 6 sont départ 3, rebord 0, réception 5. La relecture par le second moteur les a trouvées dans la sortie, et astra_ledge_triples.py décode chacune : elles se trouvent à Nénucrique (8, dont le rebord sud en colonne 48, rangée 9, dont le départ est MB_NORMAL à 5 et la réception MB_NORMAL à 3), sur la Route 115 (10), sur la Route 120 (2) et dans les zones nord et sud du Parc Safari (2 et 6), et les 28 ont toutes un départ praticable et une réception praticable. Rouge Feu n’en a aucune : ses 58 qui diffèrent ont toutes la cellule de transition au départ.24

Le moteur n’a donc pas besoin d’une hauteur pour faire un rebord, et il n’en lit pas. Le test de rebord lit le comportement de la cellule et jamais son élévation ; le saut déplace le marcheur de deux cellules le long d’un arc (section 3) ; et à la réception, ObjectEventUpdateElevation, la même fonction que la section 1 décrit pour un pas, donne au marcheur l’élévation que stocke la cellule de réception, quelle qu’elle soit. Sur la plupart des rebords, c’est la hauteur qu’il a quittée ; sur les 28 d’Émeraude qui relient deux niveaux, c’est l’autre niveau ; et sur les 132 qui ont une cellule de transition d’un côté, c’est ce que stocke la réception, le 3 du sol pour 118 d’entre eux, la valeur de surf 1 pour les 12 de la Route 118 dont la réception est de l’eau de mer, 0 pour un et 5 pour un, bien qu’un marcheur ne la prenne que sur 4 des 132, les quatre en intérieur qui atterrissent sur 3, puisque les 128 autres n’ont pas de départ ouvert.31230 Pour le dire simplement, un rebord est une porte à sens unique dans le graphe de marche qui porte les habits d’une falaise, et la falaise est facultative. C’est la lecture à laquelle le billet hommage était arrivé à partir de la mécanique, à savoir qu’une descente d’une cellule « has no z axis, only a one-way edge in the walk graph » (n’a pas d’axe z, seulement une arête à sens unique dans le graphe de marche), et les données la confirment : l’arête n’a pas besoin d’axe z, et là où la carte en stocke un de chaque côté, comme pour les 28, le moteur reprend la valeur de la cellule de réception sans aucune règle propre.271

Jamais vers le haut, surtout vers le sud

Barres à cent pour cent des cellules de rebord, celles que chaque moteur fait sauter, par direction dans quatre jeux. Émeraude, 946 cellules : sud 69 %, ouest 18 %, est 13 %. Rouge Feu, 1 042 : sud 92 %, ouest et est pour le reste. Rouge, 758 sur ses cartes du monde extérieur : bas 94 %. Cristal, 1 148 sur 167 cartes : bas 84 %, angles bas, qui se sautent, 5 %, gauche 7 %, droite 5 %. Une note sous les barres : les 77 pièces d'angle d'Émeraude ne sont pas comptées, car aucun code ne les lit et chacune est bloquée. Aucun rebord d'aucun des quatre jeux ne se franchit vers le haut de l'écran.

L’orientation des rebords dans les quatre jeux, en comptant les cellules que chaque moteur fait sauter ; tracé par figures/make_figures.py à partir de gen3_elevation.txt, r4_corner_cells.txt et gen12_ledges.txt.

Aucun rebord des cartes lues dans l’un ou l’autre des quatre jeux ne se saute vers le haut de l’écran. Émeraude compte 946 cellules de rebord : sud 657, ouest 169, est 120, nord 0, et à côté les 77 pièces d’angle, 44 sud-ouest et 33 sud-est, qui ne sont pas des rebords.131 Rouge Feu en compte 1 042 : sud 962, ouest 41, est 39.1 La table des rebords de Rouge a 8 entrées, 3 vers le bas, 2 vers la gauche et 3 vers la droite, et ses 34 cartes sur le jeu de tuiles OVERWORLD contiennent 758 cellules de rebord : 709 vers le bas, 26 vers la gauche, 23 vers la droite.536 Les 167 cartes de Cristal que lit le décodeur des routes contiennent 1 148 cellules de saut : HOP_DOWN 964, HOP_LEFT 76, HOP_RIGHT 56, HOP_DOWN_LEFT 30 et HOP_DOWN_RIGHT 22 ; son fichier de constantes marque COLL_HOP_UP et les deux angles hauts « ; unused » (inutilisé), et aucun n’apparaît dans une carte lue, même si la table de la routine de saut y enverrait un joueur vers le haut comme dans toute autre direction.51437 Plein sud, ou vers le bas de l’écran, représente 69,5 % des cellules de rebord d’Émeraude, 92,3 % de celles de Rouge Feu, 93,5 % de celles de Rouge et 84,0 % de celles de Cristal ; avec les angles bas de Cristal, qui se sautent, sa part atteint 88,5 %.4

Des rangées d’environ quatre

Les rebords viennent en courtes rangées. Les 233 rangées droites d’Émeraude et les 189 de Rouge Feu ont toutes deux une médiane de 4 cellules ; la plus longue fait 17 dans Émeraude et 55 dans Rouge Feu.14 Parmi les rangées d’Émeraude, 40 n’ont qu’une cellule, 38 deux, 34 trois, 31 quatre et 35 cinq, et seules 18 dépassent 7.1 Le billet sur les routes a trouvé les premières routes agencées de la même façon : les 12 cellules de rebord que le moteur peut faire sauter sur la Route 101 d’Émeraude forment trois rangées de quatre ; la treizième cellule que le billet sur les routes comptait d’abord est l’une des 77 pièces d’angle bloquées, et le billet sur les routes l’exclut depuis sa correction du 5 octobre 2026.1713

Où sont les rebords : sur toutes les routes, et dans les villes de Kanto

Par type de carte, Émeraude place 679 cellules de rebord sur des routes (21 de ses 41 agencements de route), 187 en souterrain, 48 en intérieur et 32 dans une seule ville, Nénucrique, 1 de ses 9 agencements de ville ; ses 7 bourgs n’en ont aucune.13 Le billet hommage comptait d’abord chaque cellule portant un comportement de saut, pièces d’angle comprises, et comptés ainsi les chiffres sont 726, 215, 48 et 34, qui correspondent à ce qu’il a d’abord publié ; depuis sa correction du 5 octobre 2026, il compte les cellules que le moteur peut faire sauter, 679, 187, 48 et 32, et les deux billets concordent désormais. Les 77 pièces d’angle font toute la différence entre les deux décomptes.12713 Rouge Feu est différent. Il place 139 cellules de rebord dans 7 de ses 19 agencements de ville, Jadielle 39, Argenta 35, Parmanie 20, Azuria 19, Céladopole 14, Six Island 8 et Safrania 4, et 803 sur 24 de ses 57 agencements de route, avec 100 de plus en souterrain et aucune en intérieur.1 Dans Rouge, Jadielle (36), Argenta (27), Parmanie (22), Azuria (19) et Céladopole (15) en ont aussi.5 Une règle voulant que les villes n’aient pas de rebords est donc celle de Hoenn, pas celle de la série. Ce que partagent les quatre jeux, c’est la direction, pas l’emplacement ; la section 6 dit ce que cela change dans un billet précédent de cette série.

Ce que fait gagner un rebord

Un rebord ne mérite sa cellule que si le détour est long. Pour chaque rebord droit extérieur ayant du sol des deux côtés, measure_gen3_elevation.py cherche le plus court trajet du départ à la réception sans sauter, dans quatre directions, selon la règle d’élévation d’Émeraude, à l’intérieur de la carte du rebord.19

Résumés en boîtes, sur une échelle logarithmique, du plus court trajet du départ d'un rebord à sa réception sans sauter. Émeraude, 280 cellules de rebord avec un détour : minimum 4, quartiles 6, 12 et 24, maximum 62 ; 269 sur 549 n'en ont aucun. Rouge Feu, 581 avec un détour : minimum 4, quartiles 6, 10 et 20, maximum 170 ; 299 sur 880 n'en ont aucun. Une ligne marque les 2 cellules du saut. En dessous, les 17 emplacements de descente de Kiradex en points empilés : 7 à 4 tuiles de détour, 5 à 6, 3 à 8, un à 9,41 et un à 10.

Le détour face au saut, dans Émeraude et Rouge Feu à l’extérieur et sur la terrasse de Kiradex ; tracé par figures/make_figures.py à partir de gen3_elevation.txt et kiradex_elevation.txt.

Dans Émeraude, cela couvre 549 cellules de rebord. Pour 269 d’entre elles, 49,0 %, il n’existe aucun détour dans la carte : le rebord est le seul moyen de passer de ce côté à l’autre sans quitter la carte. Pour les 280 autres, le détour fait de 4 à 62 cellules, quartiles 6, 12 et 24, contre les 2 du saut ; 175 d’entre eux font 10 cellules ou plus, 93 font 20 ou plus, et seuls 41 font 4 ou moins.194 Rouge Feu a 880 cellules de ce type, 299 sans détour (34,0 %), le reste de 4 à 170 cellules de détour, quartiles 6, 10 et 20.194 Parmi les rebords droits extérieurs qui ont un détour, le rebord médian de Rouge Feu comme d’Émeraude remplace donc un trajet cinq à six fois plus long que lui, 10 cellules dans Rouge Feu et 12 dans Émeraude contre les 2 du saut, et pour la moitié des 549 mesurés dans Émeraude il n’existe aucun détour dans la carte.4 Le décompte ne penche pas d’un côté. La recherche avance dans quatre directions, comme le fait l’entrée des consoles portables elles-mêmes, et sur ce point elle suit le jeu. Elle ignore les personnages et les objets, ce qui ne peut que rendre un détour plus court que ce que permet le jeu, ou en trouver un là où le jeu n’en offre aucun. Et elle ne quitte pas la carte, ce qui ne peut que rendre un détour plus long, ou compter comme inexistant un détour qui passe par une carte voisine. Ces deux derniers effets tirent en sens contraires, et l’ampleur de chacun sur le décompte n’est pas mesurée ici.1920

Première génération : une table de paires de tuiles, touche enfoncée

Rouge n’a aucun comportement de rebord. HandleLedges revient aussitôt si un saut ou un lancer de canne est déjà en cours ou si le jeu de tuiles courant n’est pas OVERWORLD, puis compare trois éléments à la table LedgeTiles : la direction vers laquelle le joueur regarde, la tuile sur laquelle il se tient et la tuile devant lui. En cas de correspondance, il exige en plus que la direction correspondante soit maintenue sur la croix directionnelle avant de simuler deux pressions de cette direction, qui font passer le joueur.36 Un rebord de la première génération est donc une paire de tuiles et une direction, huit entrées en tout, et seulement sur le jeu de tuiles OVERWORLD.536 Le décompte ci-dessus lit une tuile de 8 sur 8 par cellule, celle d’en bas à gauche, ce qui est le modèle de cellule de la première génération du billet sur les routes.517

Deuxième génération : la lèvre, et des angles qui vont dans les deux sens

Cristal marque la cellule où se tient le joueur, la lèvre, plutôt que la cellule au-delà : un octet de collision dans la plage des rebords (HI_NYBBLE_LEDGES). Sa routine .TryJump, tentée seulement après le refus d’un pas ordinaire, lit wPlayerTileCollision, et cet octet est la tuile sous le joueur : GetMovementPermissions le remplit à partir des coordonnées du joueur sur la carte, sous le commentaire « get coords of current tile » (obtenir les coordonnées de la tuile courante), et c’est ce même octet que lit .CheckTile pour laisser un courant ou une cascade emporter le joueur hors de la tuile où il se tient. .TryJump combine ensuite par un ET l’orientation du joueur avec une entrée de .ledge_table, si bien qu’une lèvre d’angle, HOP_DOWN_RIGHT, se saute vers le bas ou vers la droite, selon la direction où regarde le joueur.3738 Contrairement aux pièces d’angle d’Émeraude, les angles de Cristal sont des rebords. Le billet sur les routes a constaté qu’un saut de côté depuis un angle est le seul saut du chemin du retour de la Route 32.17

Cristal dessine aussi des hauts de falaise plus minces qu’une cellule. 1 417 des cellules lues portent UP_WALL, un mur sur le seul bord supérieur de la tuile, 7 portent LEFT_WALL et 5 RIGHT_WALL.5 Le billet sur les routes décrit comment GetMovementPermissions refuse un pas à travers le côté muré d’une telle tuile ainsi qu’un pas qui y entre, et comment, sur la Route 32, ces murs allongent le plus court trajet de 110 cellules à 132 à l’aller et 128 au retour ; le décompte de ce billet porte sur les mêmes murs dans l’ensemble des 167 cartes lues.175 Selon ma lecture, un mur unilatéral est l’autre moitié de la même idée : une arête entre deux cellules praticables que la marche ne peut pas franchir, dessinée sur la bordure de la tuile au lieu de consacrer toute une cellule à une paroi. Un rebord est une arête franchie dans un seul sens ; un mur unilatéral est une arête franchie dans aucun.

3. Le saut : durée, arc, ombre, poussière et son

Si un rebord est une arête, le saut est ce qui donne à cette arête l’air d’une descente. Chaque génération y consacre le même temps et dessine les mêmes quelques éléments.

Deux cellules en 32 images, dans Rouge, Cristal et Émeraude

measure_jump_timing.py lit les tables de saut dans le code par expressions régulières et les rejoue image par image.6

  • Rouge. PlayerJumpingYScreenCoords compte 16 valeurs y à l’écran : 56, 54, 52, 50, 49, 48, 48, 48, 49, 50, 51, 52, 54, 56, 60, 60. _HandleMidJump lit une entrée à chaque passage de OverworldLoop, boucle qui appelle DelayFrame deux fois par passage, et le joueur se déplace de deux cellules, parce que HandleLedges simule deux pressions de la direction, chacune étant un pas de 8 passages ; les deux cellules prennent donc 16 passages, 32 images. À la lecture du code, passage par passage, le passage qui trouve le rebord ne déplace rien, car CheckTilePassable refuse toujours la tuile de rebord ; ce sont les 16 passages suivants qui déplacent le joueur. Lors des 15 premiers, _HandleMidJump lit les entrées 1 à 15 dans l’ordre, une par passage. Au seizième, l’index a atteint 15, la valeur suivante, 16, n’est pas inférieure à 16, et aucune entrée n’est lue, si bien que le sprite garde le y fixé par la quinzième entrée, 60. On lit donc 15 entrées, aucune deux fois, et la seizième, un second 60, ne l’est jamais ; le y qu’elle fixerait est celui que le sprite a déjà. Le décompte du script, 16 entrées de deux images chacune, donne les mêmes 32 images parce que 16 est aussi le nombre de passages qui déplacent le joueur. Le joueur est au repos à y 60 et monte à 48, soit 12 pixels. Les 32 images sont le déplacement. Une fois le compteur de marche épuisé, au passage qui suit le seizième, lequel s’ouvre comme tout passage sur ses deux propres appels à DelayFrame, _HandleMidJump appelle Delay3, trois images de DelayFrames, et n’efface qu’ensuite les touches maintenues, pressées et relâchées, l’index et l’indicateur de rebord, puis cesse d’ignorer la croix directionnelle, que HandleLedges avait réglée pour ignorer toutes les touches. Depuis le passage qui a pris la pression, le saut de Rouge immobilise donc le joueur au moins 37 images, 0,619 seconde, avant que ses commandes ne comptent de nouveau : les 32 du déplacement, les 2 qui ouvrent le passage suivant et les 3 du nettoyage.6393640414
  • Cristal. Le pas de saut lit 16 décalages, deux images par tick : −4, −6, −8, −10, −11, −12, −12, −12, −11, −10, −9, −8, −6, −4, 0, 0, sur 32 images et 32 pixels, deux cellules, avec 12 pixels de hauteur au sommet.642
  • Émeraude. JUMP_DISTANCE_FAR dure 32 images et avance d’un pixel par image, 32 pixels, deux cellules. Sa hauteur provient de sJumpY_High, lu à timer >> 1, et culmine à −12 aux images 10 à 15. La table est identique à celle de Cristal, entrée pour entrée.63

Les trois déplacent donc le joueur de deux cellules en 32 images, 0,536 seconde, en s’élevant de 12 pixels sur une cellule de 16 ; c’est le déplacement, et le nettoyage de trois images qui le suit dans Rouge est le seul coût au-delà du déplacement relevé ici, car les réceptions de Cristal et d’Émeraude n’ont pas été suivies au-delà.64 Le saut ne change pas avec l’allure. PlayerJumpLedge d’Émeraude utilise toujours le saut long, et PlayerNotOnBikeMoving le déclenche dès que le pas suivant est un rebord, puis revient, avant même de lire le bouton de course, si bien qu’un joueur qui court saute dans les mêmes 32 images ; la recherche à la course du billet sur les routes compte pour cette raison chaque saut à 32 images, à la marche comme à la course.1217 Deux pas de marche font aussi 32 images, aux 16 images par cellule auxquelles marchent les trois générations,17 donc à la marche un rebord coûte le temps des deux cellules qu’il franchit et fait gagner le détour.64 La course, c’est 8 images par cellule,17 donc à la course le saut coûte 16 images de plus que de courir sur ses deux cellules, et ne fait gagner du temps que là où le détour dépasse 4 cellules : 239 des 280 rebords d’Émeraude qui ont un détour, et 485 des 581 de Rouge Feu.194

Hauteur au-dessus du sol en fonction du temps. Le saut du canon, identique dans Cristal et Émeraude, parcourt 16 décalages en 32 images, 0,536 seconde, en partant à 4 pixels du sol, culmine à 12 et atterrit ; l'arc proposé par le cahier des charges pour Kiradex, en pointillés et montré à la marche actuelle, monte de 0 à 10 texels et redescend en 0,5 seconde par pas de texels entiers ; à la course, le cahier des charges parcourt le même arc dans le temps de deux tuiles de course. L'ombre reste sur la ligne zéro dans les deux cas.

La table de saut du canon et l’arc que propose le cahier des charges ; tracé par figures/make_figures.py à partir de jump_timing.txt ; la courbe en pointillés est une proposition, pas une mesure.

L’ombre reste au sol

Chaque génération dessine une ombre sous le saut et la laisse au sol pendant que le sprite s’élève. Rouge charge LedgeHoppingShadow, une tuile de 1 bit, en mémoire vidéo et l’écrit dans quatre emplacements de sprite avec les retournements qui forment une ombre ronde.36 Le JumpStep de Cristal fait apparaître un objet ombre pour le sauteur.42 Le InitJumpRegular d’Émeraude appelle DoShadowFieldEffect, et UpdateShadowFieldEffect place l’ombre à chaque image au y du marcheur plus un décalage ; le saut lui-même vit dans le y2 du sprite, si bien que l’ombre reste là où seraient les pieds pendant que la silhouette s’élève.315 L’ombre du joueur est SHADOW_SIZE_M, une image de 16 pixels de large sur 8 de haut.16

Selon ma lecture, c’est l’ombre qui dit à l’œil que la silhouette a quitté le sol au lieu de monter vers le haut de l’écran. Sans elle, une élévation de 12 pixels sur une carte vue de dessus se lit comme un pas vers le nord.

La poussière, et un son

La réception d’Émeraude sur un sol ordinaire déclenche FLDEFF_DUST via GroundEffect_JumpLandingDust : trois images de 16 sur 8 pixels, de 8 ticks chacune. Une réception dans les hautes herbes ou dans l’eau déclenche plutôt leurs effets propres.16 Chaque jeu joue un son au départ du saut : SFX_LEDGE dans Rouge, SFX_JUMP_OVER_LEDGE dans Cristal, SE_LEDGE dans Émeraude.363712

Comment Émeraude dessine un rebord sud

measure_ledge_art.py effectue le rendu des 33 metatiles à comportement de saut du jeu de tuiles primaire partagé d’Émeraude, 27 rebords droits et 6 pièces d’angle (quatorze jeux de tuiles secondaires en portent 199 de plus, non rendus ici), à partir de tiles.png, des palettes du jeu de tuiles et de metatiles.bin, et affiche pour chaque rangée de pixels la luminance moyenne sur les pixels que dessinent les deux couches. Chaque entrée de tuile qui dessine un pixel utilise la palette 2, 3 ou 5, toutes parmi les six que possède un jeu de tuiles primaire (la palette 0 n’apparaît que sur la tuile vide), si bien que le rendu les dessine dans les couleurs propres au jeu de tuiles, et non dans celles empruntées au jeu de tuiles secondaire d’une carte. Le rendu est dérivé d’un graphisme protégé par le droit d’auteur et ne sert qu’à l’analyse ; le graphique ci-dessous en trace les chiffres, et aucun graphisme de jeu n’apparaît dans ce billet.43

Luminance moyenne de chacune des 16 rangées de pixels des 15 metatiles orientés sud à comportement de saut du jeu de tuiles primaire partagé d'Émeraude, 9 rebords sud et 6 pièces d'angle bloquées, une ligne fine par tuile et une ligne épaisse pour leur moyenne : les huit rangées du haut se situent entre 130 et 205, la moyenne entre 163 et 176 ; à partir de la rangée 8, les valeurs chutent jusqu'à leur point le plus sombre à la rangée 13 ou 14, entre 88 et 108, puis remontent un peu à la rangée 15.

Comment un rebord sud est éclairé, en chiffres ; tracé par figures/make_figures.py à partir de ledge_art.txt.

Les 33 sont toutes de type de couche 1, Covered, que DrawMetatile place sur les couches d’arrière-plan inférieure et médiane de la carte, BG3 et BG2, aux priorités 3 et 2. La table d’élévation donne au sprite d’un marcheur la priorité 0, 1 ou 2, et sur la Game Boy Advance un sprite dont la priorité égale celle d’un arrière-plan est dessiné par-dessus, si bien que les rebords sont dessinés sous tout marcheur dont la priorité provient de cette table.433144345 Sur les 15 orientés sud (9 rebords sud, plus les 3 pièces d’angle sud-ouest et les 3 sud-est, dont la section 2 montre qu’elles sont bloquées et jamais sautées mais dessinées de la même manière), les huit rangées de pixels du haut sont la surface propre du sol, herbe, sable ou terre, avec une luminance par rangée entre 130 et 205 ; les huit rangées du bas sont une lèvre rocheuse dont la luminance chute jusqu’à son point le plus sombre à la rangée 13 ou 14, entre 88 et 108, puis se relève un peu à la dernière rangée.434 La moyenne des quinze passe de 169 sur la moitié supérieure à 113 sur la moitié inférieure.4 Les 18 tuiles orientées ouest et est ne montrent aucune chute de ce genre : leur moitié supérieure est entre 14 points plus sombre et 22 points plus claire que leur moitié inférieure, contre 37 à 89 points plus claire pour les tuiles orientées sud.434

C’est exactement l’aspect que le billet hommage a inscrit sur sa liste « must not resemble » (ne doit pas ressembler à) pour la descente de Kiradex : « a grass lip with a light top edge and a dark shadow line. » (une lèvre d’herbe au bord supérieur clair, avec une ligne d’ombre sombre).27 La mécanique peut s’emprunter librement ; ce dessin, non, et la section 9 dessine la descente autrement.

4. Les ponts, et la hauteur comme scène

La plupart des ponts sont du sol

Émeraude compte 702 cellules de pont réparties sur neuf comportements de pont en cinq familles (le moteur en nomme onze ; MB_BRIDGE_OVER_POND_LOW et MB_UNUSED_BRIDGE n’apparaissent dans aucun agencement utilisé par une carte) : MB_BRIDGE_OVER_OCEAN 609, MB_BRIDGE_OVER_POND_HIGH 35 plus 4 cellules sur ses deux comportements de bord, MB_FORTREE_BRIDGE 27, MB_BRIDGE_OVER_POND_MED 17 plus 4 sur ses deux, et MB_BIKE_BRIDGE_OVER_BARRIER 6. Rouge Feu n’a aucun comportement de pont dans les agencements utilisés par une carte.9

Barres horizontales empilées des cellules de pont d'Émeraude par comportement et élévation stockée. Au-dessus de la mer, 609 cellules : 201 multiniveaux, 288 fixées à 4, 120 entre 0 et 3. Étang haut, 39 : 31 multiniveaux. Ponts de rondins, 27 : 4 multiniveaux, 23 à 4. Étang moyen, 21 : 16 multiniveaux. Pont pour vélo, 6, toutes à 4. Au total, 252 des 702 cellules, 35,9 %, sont multiniveaux.

Les cellules de pont d’Émeraude par élévation stockée ; tracé par figures/make_figures.py à partir de gen3_elevation.txt.

Seules 252 des 702 (35,9 %) sont multiniveaux, à l’élévation 15 ; 329 se trouvent à une élévation fixe de 4, et les 121 autres à 0, 1 ou 3.94 Les ponts au-dessus de la mer se répartissent en trois : 201 cellules à 15, 288 à 4 et 120 entre 0 et 3.9 248 des 252 cellules de pont multiniveaux se trouvent sur les Routes 110, 119 et 120, où un surfeur peut passer dessous ; les 4 autres sont les ponts de rondins de Cimetronelle à la valeur multiniveau, sous lesquels passe un marcheur (voir plus bas le son de Cimetronelle). Si l’on compte toutes les cellules à l’élévation 15, pont ou non, les huit agencements qui en comptent le plus comprennent trois agencements extérieurs, la Route 110 (185), la Route 120 (48) et la Route 119 (22), les autres étant des grottes, un couloir de la Zone de Combat et la Route Victoire. Si l’on ne compte que les cellules de pont, les trois mêmes routes en ont 185, 47 et 16, les 248 ci-dessus ; les 7 autres cellules à 15 des Routes 119 et 120 sont du sol ordinaire, MB_NORMAL, pas un pont.730 Le billet sur les structures décrivait le cas de la Route 119 d’après le manuel de Porymap, une cellule de pont qui permet à un joueur de marcher au-dessus d’un surfeur passant dessous.2532 Sur les 450 autres, les 329 à l’élévation 4 sont des tabliers à hauteur fixe sous lesquels rien ne passe : 294 sur la Route 110, 23 des 27 cellules de pont de rondins de Cimetronelle et 12 sur la Route 120. Les 121 restantes ne sont pas des tabliers. 69 sont stockées bloquées, toutes sur la Route 110 (68 à 0 et 1 à 3), et GetCollisionAtCoords refuse un pas vers une cellule bloquée avant de lire la moindre élévation ; 47 sont des cellules ouvertes stockées à la valeur de surf 1 (46 sur la Route 110, 1 sur la Route 120), le comportement de pont posé sur des cellules à la hauteur de l’eau, où un surfeur à 1 peut entrer et un marcheur à 3 ou 4 non, puisque IsElevationMismatchAt refuse une cellule dont l’élévation stockée diffère de celle du marcheur, sauf si le marcheur est à la valeur de transition ou la cellule à la valeur de transition ou multiniveau ; 4 sont les cellules de transition aux extrémités de deux ponts de la Route 110 que la section 1 compte comme escaliers ; et 1 est une cellule intérieure à 3, dans la Union Room. Selon ma lecture, un pont au-dessus d’une eau où personne ne nage est du sol dessiné en planches, et les données stockent les 329 de cette façon.9303

Dessiné sur deux couches, trié par une table

Sur les 702 cellules de pont, 685 sont de type de couche Normal et 17 Covered.94 Le monde extérieur dessine la carte sur trois arrière-plans, BG1 en priorité 1, BG2 en priorité 2 et BG3 en priorité 3, et DrawMetatile place la couche inférieure d’un metatile Normal sur BG2, celle du milieu, et sa couche supérieure sur BG1, celle du dessus, sous un commentaire qui précise qu’elle « covers object event sprites » (recouvre les sprites des événements d’objet).3144 Qui est dessiné au-dessus du tablier dépend d’une table de seize entrées indexée par l’élévation du marcheur, sElevationToPriority = {2, 2, 2, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 0, 0, 2} : un marcheur à une élévation paire de 4 à 12 est dessiné en priorité de sprite 1, et un surfeur à 1 en priorité 2.3 L’égalité est tranchée par le matériel, pas par le code du jeu : GBATEK, la référence technique de base de la Game Boy Advance, indique que lorsqu’une priorité de sprite égale celle d’un arrière-plan, le sprite « is displayed on top of that BG layer » (s’affiche par-dessus cette couche d’arrière-plan).45 Le marcheur en priorité 1 est donc dessiné aussi par-dessus la couche supérieure, et le surfeur en priorité 2 par-dessus la couche médiane et sous la couche supérieure, là où se trouve le graphisme haut d’un tablier Normal. Le même tablier est dessiné au-dessus d’un surfeur et sous un marcheur qui s’y tient, sans que le tablier sache lequel est lequel.

La hauteur d’un pont se lit en dessous

Émeraude indique au joueur la hauteur d’un pont sur étang par le reflet. Sur un pont d’étang, le reflet du marcheur dans l’eau descend sous lui d’une valeur tirée de bridgeReflectionVerticalOffsets : 12, 28 ou 44 pixels pour les types bas, moyen et haut, et le reflet est chargé avec une palette sombre au lieu de celle du marcheur.15 Seuls 28 et 44 apparaissent en jeu. MetatileBehavior_GetBridgeType marque le type bas « (Unused) » (inutilisé), et aucun agencement utilisé par une carte ne le porte ; les types moyen et haut sont ceux de la Route 120, d’après les commentaires de la même fonction. Les ponts au-dessus de la mer, les 609 cellules MB_BRIDGE_OVER_OCEAN, renvoient le type 0, qui ne reçoit aucun décalage et le reflet habituel du marcheur.33915 Le code l’explique pour le pont haut de la Route 120 : « the reflection is a solid dark blue color. This is so the sprite blends in with the dark water metatile underneath the bridge. » (le reflet est d’un bleu foncé uni, afin que le sprite se fonde dans le metatile d’eau sombre sous le pont).15 Le code charge cette palette sombre pour le pont d’étang moyen comme pour le haut, et pas seulement pour le haut.15

Les ponts de rondins de Cimetronelle répondent au pas. La planche sous le joueur est dessinée enfoncée et celle qu’il vient de quitter remonte sur une minuterie de 16 images, et SE_BRIDGE_WALK ne joue que si l’élévation du joueur est paire, ce que le commentaire du code glose ainsi : « Make sure player isn’t below bridge » (s’assurer que le joueur n’est pas sous le pont) ; un marcheur en dessous ne fait aucun bruit.46 Le code note aussi, dans un commentaire placé à côté d’un interrupteur BUGFIX, que la planche ne s’enfonce pas au premier pas sur un pont depuis autre chose qu’une autre planche.46 Selon ma lecture, ce sont les deux manières dont un jeu vu de dessus montre la hauteur sans vue de côté : ce qui se passe sous la chose (un reflet repoussé plus bas) et ce qui se passe dessus (une planche qui cède et un son que seul le tablier produit).

La hauteur comme scène : le téléphérique

Quand Émeraude a besoin d’un grand changement de hauteur, il cesse tout simplement de faire marcher. Le téléphérique entre la Route 112 et le Mont Chimnée est une scène à part entière. Rejouée à partir de src/cable_car.c, la cabine avance de 0,14 et 0,067 pixel par image à l’horizontale et vers le haut, une pente de 0,48 ; la météo passe du soleil à la cendre à l’image 350 à la montée, et de la cendre au soleil à l’image 265 à la descente ; et le fondu commence à l’image 570, 9,54 secondes, avant le warp vers le sommet.6474 Selon ma lecture, une montagne est trop haute pour la hauteur honnête de la grille de tuiles, un ou deux niveaux, si bien que le jeu fait de l’ascension un court film avec sa propre météo, un choix de conception qu’une ville de collectionneurs pourrait reprendre pour tout trajet qui dépasse une simple marche à monter.

5. Les jeux SNES et les références modernes

La recherche sur les structures a lu ces jeux pour sa propre question, la hauteur à laquelle se dressent les choses ; cette section les relit pour la question de ce billet, la manière dont un marcheur change de hauteur, avec des sources de nouveau archivées pour ce billet. Rien de tout cela n’est mesuré ici ; ce sont les propres mots ou le propre code de chaque source.20

Final Fantasy VI : deux niveaux z et un indicateur de transition

Final Fantasy VI conserve pour l’équipe un niveau z, haut ou bas, et deux indicateurs par tuile, « passable on lower z-level » (praticable au niveau z inférieur) et « passable on upper z-level » (praticable au niveau z supérieur). Les notes du désassemblage sur la mémoire de terrain ajoutent que « if both of these are set, this tile can be a transition between upper and lower » (si les deux sont positionnés, cette tuile peut servir de transition entre le haut et le bas), et que les indicateurs de priorité de sprite sont « not active for bridge tiles » (inactifs pour les tuiles de pont). Les escaliers sont deux indicateurs de plus, « tile uses up/left movement (stairs) » (la tuile utilise un déplacement haut/gauche, escaliers) et « up/right movement (stairs) » (déplacement haut/droite, escaliers).48 Selon ma lecture, ces deux-là font qu’un pas de côté sur un escalier monte en diagonale, et l’ensemble est la conception d’Émeraude avec deux niveaux au lieu de seize : une tuile praticable aux deux hauteurs est la transition, et la tuile de pont désactive la règle d’affichage qui placerait sinon le marcheur sous le tablier.

The Legend of Zelda: A Link to the Past, tel que l’écrit la réimplémentation zelda3 de snesrev, conserve les attributs de tuile d’un donjon sur deux plans. Dans son code du joueur, la vérification de l’endroit où atterrirait un bloc poussé lit dung_bg2_attr_table[(y & ~7) * 8 + (x & 0x3f) + (link_is_on_lower_level ? 0x1000 : 0)], et le test d’éclaboussure du marteau ajoute le même 0x1000 quand Link est au niveau inférieur, si bien qu’une même position est une tuile différente à chaque niveau.49 Dungeon_HandleLayerChange met link_is_on_lower_level = 1 pour un escalier intérieur à une salle, sauf si son type est 2, et un autre chemin d’escalier l’inverse.49 Je n’ai lu que le code du joueur archivé pour ce billet, pas la détection de tuiles de la réimplémentation, si bien que les autres endroits où les deux plans sont lus ne sont pas vérifiés ici. C’est du code de réimplémentation sans source rédigée, et je ne l’ai lu que pour la forme de l’idée : le marcheur porte le niveau, et la carte répond différemment pour chacun.

CrossCode : la hauteur compte, le saut non

Radical Fish Games a bâti CrossCode sur une vraie hauteur, et ses développeurs ont écrit ce que cela coûte. La hauteur, écrivaient-ils, « is definitely an important part of CrossCode, jumping is not. » (est sans conteste une part importante de CrossCode, le saut non). Leur saut automatique « jumps at the last possible moment in front of the gap » (saute au dernier moment possible devant le vide).50 Leur recherche de chemin marque à la main les « jump-up-edges » (arêtes de saut vers le haut), là où le level designer déclare une montée possible, et calcule automatiquement les « jump-down-edges » (arêtes de saut vers le bas).51 Un lecteur a suggéré dans les commentaires de ce billet de marquer les hauteurs avec des couleurs plus distinctes, et lachsen, de l’équipe, a répondu le 4 octobre 2013 : « That level was pushing the whole 3D situation a bit too much. » (ce niveau poussait un peu trop loin toute la situation 3D). Et : « For future environment we’ll use different colors to mark the heights more explicitly. » (pour les environnements à venir, nous utiliserons des couleurs différentes pour marquer les hauteurs plus explicitement).50 La recherche sur les structures a aussi lu l’éditeur de cartes communautaire de CrossCode, qui dessine la paroi de chaque niveau sur level.height / 16 rangées de tuiles ; cette source a été lue pour le billet sur les structures et n’a pas été de nouveau archivée pour celui-ci.26

C’est l’avertissement sur lequel la recherche sur les structures a refusé les rebords : une hauteur libre est difficile à lire vue de dessus.26 Selon ma lecture, ces mêmes billets portent l’autre moitié de la leçon : un saut vers le bas est une arête que le moteur peut calculer, et un saut vers le haut est une décision que quelqu’un prend lieu par lieu. Les quatre jeux mesurés ici ne prennent jamais cette décision : aucun rebord des cartes lues ne monte vers le haut de l’écran (section 2).15

Sea of Stars : loin des tuiles, à dessein

Thierry Boulanger, de Sabotage Studio, a déclaré à Screen Rant en août 2023 que le deuxième pilier du jeu était « unshackled traversal. The idea that you can just hoist up, jump down off of everything, » (un déplacement sans entraves, l’idée qu’on peut se hisser partout et sauter de tout) et l’a décrit comme « going as far away as possible from tile-based movement » (aller aussi loin que possible du déplacement par tuiles). Les niveaux, disait-il, devaient « to all read well with different levels of height, with the light and everything, and that you still know where to go. » (tous bien se lire avec différents niveaux de hauteur, avec la lumière et tout le reste, et qu’on sache quand même où aller).52 C’est une seule interview, et le récit du concepteur lui-même. J’y lis l’autre extrémité du spectre par rapport à Kiradex : l’escalade libre y est un pilier du jeu, et le coût qu’il nomme, rendre la hauteur lisible par la lumière, est le même que celui qu’a nommé l’équipe de CrossCode.

Eastward

La recherche sur les structures n’a trouvé aucune déclaration de développeur sur le système d’élévation d’Eastward, et la recherche menée pour ce billet n’a pas pu être lancée. Je ne cite rien à son sujet.2026

6. La terrasse de Kiradex, mesurée

Tout ce qui figure dans cette section est mesuré sur la ville telle qu’elle est livrée : l’export de la forge, Kiradex/Resources/World/town.json dans le dépôt Kiradex, 40 sur 30 tuiles, l’arrivée en colonne 19, rangée 13, fichier daté du 3 octobre 2026, ouvert en lecture seule.1124 La marche est celle de l’app : TileMap.path cherche dans huit directions, un pas en diagonale coûte √2 et n’est autorisé que si les deux tuiles entre lesquelles il passe sont praticables, si bien que personne ne coupe l’angle d’un mur. C’est le contrat de marche que le billet sur les routes a fixé pour l’app et le serveur, et chaque longueur ci-dessous est un coût sur ce graphe, en tuiles.5317

Deux niveaux, dessinés

Le mur est la rangée 11 de la ville : 29 tuiles bloquées et cinq volées d’escalier, en x 3 (une tuile de large), 10 (une), 17 (le grand escalier, cinq de large), 28 (une) et 36 (une). Le niveau supérieur compte 216 tuiles praticables et l’inférieur 482.11 Une volée revient toutes les 7 ou 8 tuiles : les volées en x 3 et 10 sont à 7 tuiles l’une de l’autre, le bord ouest du grand escalier, en x 17, est à 7 tuiles à l’est de la volée en 10, son bord est, en x 21, à 7 tuiles à l’ouest de la volée en 28, et les volées en 28 et 36 sont à 8 tuiles l’une de l’autre, avec 6, 6, 6 et 7 tuiles de mur entre elles et 2 de plus à chaque extrémité.4 Dans les lettres propres à la forge, le mur est W, « the terrace’s wall: the upper town stands a step above the lower, and this is the face of that step, seen from the lower side » (le mur de la terrasse : la ville haute se trouve une marche au-dessus de la ville basse, et ceci est la face de cette marche, vue d’en bas), et un escalier est /, « a stair through the wall (plaza stone to the feet) » (un escalier qui traverse le mur, de la pierre de place sous les pieds) ; dans les lettres exportées que lisent l’app et le serveur, les tuiles du mur sont bloquées et les escaliers sont du pavage.24

La terrasse n’a rien changé à la marche. Depuis l’arrivée, les quatre portes du haut sont à 18,07, 10,07, 8,24 (la halle) et 16,49 tuiles, et les trois portes du bas à 20,07 (la boutique de cartes), 12,41 et 13,41 ; chaque trajet a la même longueur au retour, comme tout trajet sur un graphe sans arête à sens unique.11 Chacun de ces trajets compte 7 pas ou plus, et l’app fait courir tout chemin de 6 pas ou plus, à runPace, 1,6 fois les 4 tuiles par seconde de la marche, soit 6,4 en nominal.54 Dans le code actuel, la halle est donc à environ 1,3 seconde de l’arrivée et la boutique de cartes à 3,1 ; à la marche, ce serait 2,1 et 5,0.4 Chaque durée de cette section correspond au code actuel à cette course nominale. Le modèle du même code établi dans le billet sur le mouvement, à 60 hertz, trouve la course plus lente que sa constante, 6,00 tuiles par seconde sur les pas droits, parce que le dépassement de chaque tuile est jeté, si bien que ces durées sont des bornes inférieures.55

Où pourrait aller une descente, et ce qu’elle ferait gagner

Schéma de la rangée 11 de la ville de Kiradex, 40 tuiles : la clôture à chaque extrémité, 29 tuiles de mur et les cinq volées en x 3, 10, 17 à 21, 28 et 36. Au-dessus, des barres pour les 17 emplacements où le départ et la réception d'une descente sont tous deux praticables, le détour par les escaliers de 4 à 10 tuiles, et des étiquettes de 0,59 tuile en x 8, 9, 16 et 22, les seuls emplacements où une descente raccourcit l'un des 16 trajets d'une porte du haut vers l'arrivée ou vers une porte du bas ; chaque trajet qu'une descente raccourcit aboutit à une porte du bas, et aucun n'aboutit à l'arrivée.

Le mur de la terrasse, les emplacements possibles d’une descente et ce que chacun ferait gagner : 0,59 tuile en x 8, 9, 16 et 22, sur un trajet d’une porte du haut vers une porte du bas, et rien sur un trajet vers l’arrivée ; tracé par figures/make_figures.py à partir de kiradex_elevation.txt et de la rangée de mur de town.json.

measure_kiradex_elevation.py modélise une descente comme le rebord du canon : une arête orientée de la tuile de départ en rangée 10, plein sud, par-dessus la tuile de mur bloquée, jusqu’à la tuile de réception en rangée 12, coût 2, et rien ne la remonte.11 Il existe 17 emplacements où le départ et la réception sont tous deux praticables : x 1, 2, 4, 5, 6, 8, 9, 16, 22, 29 à 34, 37 et 38. Sans descente, le détour du départ à la réception par les escaliers les plus proches fait 4 à 10 tuiles : 4 pour sept d’entre eux, 10 en x 32, le plus éloigné d’une volée.11

Le script ajoute ensuite une descente à la fois et parcourt chaque trajet depuis chacune des quatre portes du haut jusqu’à la cour d’arrivée et jusqu’à chacune des trois portes du bas, 16 trajets. Une descente en x 8 ou x 9 raccourcit deux des 16 trajets de 0,59 tuile chacun, tous deux depuis la maison en (5, 6), l’un vers la porte du bas en (15, 20) et l’autre vers la porte du bas en (24, 20). Une descente en x 16, à côté du bord ouest du grand escalier, raccourcit l’un de ces deux trajets, de la maison en (5, 6) à la porte du bas en (24, 20), de 0,59, et une descente en x 22, à côté de son bord est, en raccourcit un autre, de la maison en (31, 5) à la porte du bas en (15, 20), de 0,59. Les 13 autres emplacements n’en raccourcissent aucun. Trois seulement des 16 trajets peuvent donc être raccourcis, chacun de 0,59 tuile et chacun d’une porte du haut vers une porte du bas, et aucune descente seule, où qu’elle se trouve dans le mur, ne raccourcit l’un des quatre trajets vers la cour d’arrivée.11 Des rangées de descentes en x 4 à 6 et en x 30 à 33, les longues portions de mur nu où, selon ma lecture, une descente de terrasse paraîtrait la plus naturelle, ne raccourcissent aucun trajet et ne changent aucun des 16 trajets de remontée.11 Chaque trajet qu’une descente raccourcit compte 19 pas ou plus, il se fait donc en courant, et à la course nominale, la descente étant franchie à l’allure de course comme le fixe le point 4 du cahier des charges, 0,59 tuile représente environ 0,09 seconde.4

Deux variantes sondent les alternatives évidentes. Transformer les deux volées extérieures d’une tuile, en x 3 et x 36, en descentes ne fait rien gagner à la descente, puisqu’une descente remplace exactement l’escalier, et ajoute 4,83 tuiles à un trajet de remontée, celui qui va de la porte de la boutique de cartes à la maison au-dessus, 18,83 tuiles aujourd’hui et 23,66 sans la volée ; supprimer ces volées sans aucune descente, à titre de témoin, coûte les mêmes 4,83 dans les deux sens.23 Rendre au pavage les parterres de fleurs de la cour de part et d’autre du grand escalier et placer des descentes au-dessus fait gagner 2,93 tuiles sur les 16 trajets descendants, dont 2,34 proviennent du seul pavage, qui fait gagner les mêmes 2,34 à la remontée.23 Le mieux qu’une descente puisse donc offrir sur la Grand-Place est 0,59 tuile sur un trajet, environ 0,09 seconde en courant, contre un détour extérieur médian de 10 à 12 cellules dans Rouge Feu et Émeraude (section 2).1119 La Grand-Place a déjà ce à quoi sert un rebord : des escaliers assez proches pour qu’aucun trajet ne fasse un long détour.

La rangée de toit praticable

Émeraude laisse un marcheur monter sur la rangée supérieure du toit d’un bâtiment et le dessine derrière le faîtage ; le billet sur les structures l’a listé comme manquant dans Kiradex : « the layer would draw it correctly, the letters forbid it. » (la couche le dessinerait correctement, ce sont les lettres qui l’interdisent).25 Les sept bâtiments de Kiradex ont 37 cellules de rangée supérieure de toit, 5 chacun et 7 pour la halle, et les 37 seraient accessibles depuis l’arrivée si leurs lettres étaient praticables.114 Pour chaque bâtiment, la règle de profondeur place déjà un marcheur sur cette rangée derrière le bâtiment : les quatre bâtiments du haut ont leur rangée supérieure en rangée 1 pour des bases en rangées 5 et 6, et les trois du bas en rangées 14 et 16 pour une base en rangée 20.1153 Les ouvrir raccourcit 8 trajets de porte à porte de 0,59 tuile chacun, tous en passant derrière un faîtage : la maison en (5, 6) vers la porte du bas en (24, 20), par exemple, passe de 31,49 tuiles à 30,90, et le plus long des huit, de la porte du haut en (31, 5) à la boutique de cartes, de 35,97 à 35,38.1123

Un pont sur l’étang

L’étang du parc s’étend de x 2 à 7, rangées 23 à 27. Une passerelle nord-sud en x 4, longue de cinq tuiles d’eau, ramène le trajet de (4, 22) à (4, 28) de 12,83 tuiles à 6,00, 53,2 % plus court, et à la course nominale actuelle, puisque les deux trajets se font en courant (12 pas et 6), d’environ 2,0 secondes à 0,9 ; en x 5, également cinq tuiles d’eau, de 10,83 à 6,00. Les autres colonnes : x 2, trois tuiles d’eau, 18,24 à 4,00 ; x 3, quatre tuiles, 15,83 à 5,00 ; x 6, quatre tuiles, 8,41 à 5,00 ; x 7, deux tuiles de (7, 23) à (7, 26), 5,00 à 3,00.114 Personne ne nage dans Kiradex, donc le tablier est du sol (section 4).

La promenade des Prés : un portillon ou une rangée de descentes

Le billet sur les routes a tiré son chemin du retour plus court d’une allée bordée de haies munie d’un portillon à sens unique, et a laissé les descentes à sens unique à ce billet.17 Ses chiffres restent tels que publiés : sur le graphe partagé à huit directions, avec quatre haies en travers du pré, le chemin du retour du ponton du Bord du lac à l’arrivée fait 88,07 tuiles, la fourchette d’aller du cahier des charges va de 110 à 120 tuiles, et 4 111 agencements à quatre haies tombent dans cette fourchette, chacun avec un retour valant 0,73 à 0,80 fois l’aller.17

Deux plans schématiques du pré de 24 sur 60 tuiles du cahier des charges des routes, pour un jeu d'ouvertures tiré au sort, 18, 2, 15 et 8. À gauche, le modèle du portillon : quatre haies avec des ouvertures de 2 tuiles et une allée bordée de haies sur le côté est, dont le portillon n'admet les marcheurs que depuis le nord ; aller de 59,41 à 85,43 tuiles sur les 400 agencements tirés, celui-ci 76,77, retour 59,00. À droite, le modèle à descentes : les haies deviennent des murs de terrasse dont les ouvertures sont conservées comme escaliers, avec une rangée de 2 tuiles de descentes à sens unique dans les colonnes de l'allée ; les mêmes trajets sur le pré seul, une différence de 0,00 dans les deux sens pour les 400 agencements tirés. Une ligne en dessous ajoute le résultat de la grille reliée : retour de 88,07 dans les deux cas, et aller plus court avec les descentes pour 114 des 400.

La promenade des Prés avec un portillon et avec des descentes ; schéma tracé par figures/make_figures.py à partir des constantes d’agencement et de la sortie de probe_meadow_drops.py, le premier de ses 400 agencements tirés, avec la ligne de la grille reliée tirée de astra_meadow_joined.txt.

probe_meadow_drops.py se demande si des descentes peuvent faire le travail du portillon. Il modélise le pré seul, 24 colonnes sur 60 rangées, d’un bord à l’autre, avec les quatre haies du cahier des charges des routes aux rangées 12, 24, 36 et 48 du pré, chacune percée d’une ouverture de 2 tuiles. Dans le modèle du portillon, la colonne 21 est la haie de l’allée, les colonnes 22 et 23 sont l’allée, où l’on n’entre que par le bord nord, d’où l’on ne ressort jamais vers le nord, et qui ne s’ouvre sur le pré qu’à son extrémité sud. Dans le modèle à descentes, les quatre haies deviennent des murs de terrasse sur toute la largeur, chacun gardant son ouverture de 2 tuiles comme escalier, la haie de l’allée disparaît, et chaque mur porte une rangée de 2 tuiles de descentes là où se trouvait l’allée, colonnes 22 et 23 : depuis la tuile du dessus, un pas droit vers le sud atterrit deux tuiles plus bas pour un coût de 2, et rien ne les remonte.21 Il parcourt les deux sur le graphe à huit directions de l’app, à l’aller du bord sud au bord nord et au retour du nord au sud, pour 400 agencements des quatre positions d’ouverture tirés par un générateur aléatoire à graine (graine 6) parmi les 160 000 qu’a balayés le billet sur les routes, soit 0,25 %.214

Sur le pré seul, les deux modèles donnent exactement les mêmes trajets. Le retour fait 59,00 tuiles dans chaque agencement avec l’un comme avec l’autre ; l’aller va de 59,41 à 85,43 tuiles, médiane 66,80, avec l’un comme avec l’autre ; et la différence, descentes moins portillon, vaut 0,00 dans les deux sens pour les 400.21 Les descentes n’ont besoin ni de haie d’allée ni de portillon. L’égalité en tuiles ne vaut égalité en secondes que si une descente prend le temps de ses deux tuiles à l’allure du marcheur, et le chemin du retour, 51 pas simples et 4 descentes, se fait toujours en courant ; le point 4 de la section 9 règle la question sur ces mêmes 400 agencements.4

Le premier jet de ce billet lisait ce résultat comme réglant aussi l’itinéraire complet, au motif que les descentes se trouvent dans les colonnes de l’allée et que le reste de l’itinéraire est inchangé. La relecture par le second moteur a montré que ce raisonnement était faux, et la mesure qui l’a remplacé figure ici. Reliée à la Grand-Place et au Bord du lac, comme les relie le measure_meadow_gate.py du billet sur les routes, la conception à descentes ouvre le pré sur la Grand-Place le long de ses 24 colonnes, puisque la haie de l’allée a disparu, et le chemin le moins coûteux pour sortir de la Grand-Place peut changer. astra_meadow_joined.py place les descentes sur cette grille reliée et la parcourt de l’arrivée au ponton, aller et retour.22 Sur l’agencement que désignait la relecture, ouvertures 19, 1, 1 et 17 au décalage 4 du cahier des charges, l’aller fait 114,15 tuiles avec le portillon et 111,67 avec les descentes, 2,49 de moins, parce que l’itinéraire aller entre dans le pré par la colonne 26 de la Grand-Place, sous l’ancienne allée, au lieu de la colonne 11 ; le retour fait 88,07 dans les deux cas.224 Sur les 400 agencements tirés par la sonde, le retour fait 88,07 sur chacun avec les deux modèles, et l’aller est plus court avec les descentes pour 114 des 400 et plus long pour aucun ; 17 des 400 se situent dans les fourchettes du cahier des charges des routes avec le portillon, un serpentement du pré de 78 à 90 et un aller de 110 à 120, et pour 4 de ces 17 les descentes modifient l’aller, de 1,66 à 3,31 tuiles, les quatre restant dans la fourchette, avec un retour valant 0,745 à 0,789 fois l’aller.224 Sur l’ensemble des 160 000 positions d’ouverture, parcourues sur la grille reliée avec descentes, le retour fait 88,07 sur chacune et l’aller va de 89,73 à 134,44 tuiles. Rapportée aux fourchettes du cahier des charges des routes lui-même, le serpentement et l’aller, la conception à descentes accepte 4 607 agencements, tous à l’objectif de 0,8 ou en dessous, avec un retour valant 0,734 à 0,800 fois l’aller. Les 4 111 du portillon n’en font pas simplement partie : parcourus avec descentes, 3 076 des 4 111 conservent leur aller, 1 035 en sortent plus courts, jusqu’à 5,31 tuiles, et aucun plus long ; 4 103 restent dans la fourchette et 8 passent juste sous 110, jusqu’à 109,67 ; les 504 autres des 4 607 sont des agencements dont le portillon portait l’aller au-delà de 120 et que les descentes ramènent dans la fourchette.224 Les deux conceptions concordent donc sur le chemin du retour et sur l’objectif, et diffèrent sur les positions d’ouverture qui passent, et la vérification 2 du cahier des charges est écrite d’après les chiffres propres à la conception à descentes, et non d’après ceux du portillon. Les décomptes de rebords de ce billet concordent aussi avec ceux du billet sur les routes là où ils se recoupent : la Route 1 de Rouge compte 42 cellules de rebord dans les scripts des deux billets, et le saut dure 32 images dans les deux.5176

Ce que les données resserrent dans deux billets précédents

Deux phrases publiées plus tôt dans cette série en disaient plus que ce que les mesures présentées ici permettent d’affirmer. Celle du billet sur les structures reste telle que publiée, et je ne modifie pas ce billet ; j’énonce une fois, ici, le constat qui la concerne. Celle du billet hommage a été corrigée le 5 octobre 2026, après ces mesures, et le paragraphe qui lui est consacré plus bas dit ce qu’elle disait et ce qu’elle dit maintenant.

Le billet sur les structures répondait à une question sur les bâtiments à plusieurs étages par « Reserve per-cell elevation for terraces, ledges and bridges on the ground, where Emerald uses a transition value for stairs and a multi-level value for a bridge cell. » (réservez l’élévation par cellule aux terrasses, rebords et ponts au sol, là où Émeraude utilise une valeur de transition pour les escaliers et une valeur multiniveau pour une cellule de pont).25 Cela vaut là où une tuile est praticable à deux hauteurs, une passerelle au-dessus d’un chemin. Cela ne vaut pas pour les rebords ni pour la plupart des ponts, et la propre terrasse de Kiradex, une face bloquée traversée d’escaliers, montre qu’une terrasse dessinée ainsi n’en a pas besoin non plus. Un rebord n’a pas besoin d’élévation par cellule : dans Rouge Feu, chaque cellule de rebord est à la valeur de transition et 94,4 % des cellules de rebord droites ayant une cellule de chaque côté relient des élévations égales, et dans Émeraude 83,1 % ; un rebord est une arête orientée.1 Et un pont n’a besoin d’élévation que là où quelqu’un passe dessous : 252 des 702 cellules de pont d’Émeraude sont multiniveaux, 329 des 450 autres sont des tabliers à une élévation fixe de 4, du sol dessiné en planches, et les 121 restantes sont des cellules stockées bloquées, des cellules à la hauteur de l’eau, quatre escaliers d’extrémité de pont et une cellule intérieure (section 4).930 L’esquisse (cellule, hauteur) du dossier moteur à laquelle renvoie ce billet a en outre besoin de la correction de la section 1 avant de pouvoir gravir un escalier.10

Le billet hommage disait d’abord des rebords : « The town, where people live and the player arrives, never has one. » (la ville, où vivent les gens et où arrive le joueur, n’en a jamais).27 C’est vrai d’Émeraude, dont les 7 agencements de bourg n’ont aucune cellule de rebord, et pas de Kanto : Rouge Feu a des cellules de rebord dans 7 de ses 19 agencements de ville, 139 en tout, et Rouge à Jadielle, Argenta, Parmanie, Azuria et Céladopole, 119 cellules pour les cinq.154 Depuis sa correction du 5 octobre 2026, la phrase se lit « In Hoenn, the town, where people live and the player arrives, never has one. » (à Hoenn, la ville, où vivent les gens et où arrive le joueur, n’en a jamais), ce que les données confirment, et les décomptes d’Émeraude du billet hommage, corrigés le même jour pour ne retenir que les cellules que le moteur peut faire sauter, concordent avec ceux de ce billet (section 2).27113 La décision que le billet hommage en tirait, pas de descente dans la ville de Kiradex, tient toujours dans le cahier des charges de ce billet, mais en vertu des chiffres propres à Kiradex (les 0,59 tuile ci-dessus), et non des villes du canon, qui ne suivent pas une seule règle : celles de Hoenn n’ont pas de rebords, celles de Kanto en ont.

7. Le métier, en règles chiffrées

Chaque règle ci-dessous, sauf la dernière, est un fait mesuré dans les sections 1 à 6, accompagné de la lecture de conception que j’en tire. Les chiffres sont mesurés dans les jeux que nomme chaque ligne, Émeraude et Rouge Feu pour la plupart, les quatre là où la ligne le précise ; les lectures sont les miennes. La dernière ligne, le pli, est d’une autre nature : ses faits viennent de la documentation d’Apple, et sa règle est ma proposition de la section 8, qu’aucune capture n’a encore testée.

Élément Règle Source
Niveaux Un niveau est la norme, deux sont un atout, trois une pièce maîtresse. 50 des 68 agencements extérieurs d’Émeraude et 67 des 76 de Rouge Feu utilisent au plus un niveau de sol ; Rouge Feu n’en utilise jamais trois. La Grand-Place de Kiradex en a deux et n’a pas besoin d’un troisième. Section 17
Falaises La hauteur change sur une paroi, pas sur un nombre. À l’extérieur, 99.7% (Émeraude) et 99.8% (Rouge Feu) des paires praticables adjacentes sur un niveau de sol se trouvent sur un même niveau. Dessinez un changement de niveau comme une face bloquée traversée par un escalier, ce que fait déjà le build 35. Section 1724
Escaliers Un escalier fait le plus souvent une ou deux cellules et coûte un pas. 73 des 84 escaliers extérieurs d’Émeraude font 1 sur 1, 1 sur 2 ou 2 sur 1 ; Émeraude les parcourt à 16 images par cellule, les escaliers de roche de Rouge Feu à 23. Les volées de Kiradex ont une tuile de profondeur ; gardez-y la vitesse de marche. Section 186
La règle de marche Sur un escalier, le marcheur n’appartient à aucun niveau. Émeraude met l’élévation du marcheur à 0 sur une cellule de transition, ce qui explique que le pas suivant puisse aller sur l’un ou l’autre niveau ; une règle qui garde l’ancienne hauteur bloque les 114 escaliers extérieurs d’Émeraude et de Rouge Feu. Section 1310
Rebords Un rebord est une arête à sens unique qui n’a pas besoin de hauteur. 83.1% (Émeraude) et 94.4% (Rouge Feu) des cellules de rebord droites ayant une cellule de chaque côté relient des élévations stockées égales ; 28 des 944 d’Émeraude relient deux niveaux de sol, et aucune de Rouge Feu ; dans Rouge Feu, chaque cellule de rebord est une cellule de transition. Le moteur lit le comportement de la cellule, jamais son élévation, et donne au marcheur celle de la cellule de réception. Modélisez-le comme une arête du graphe de marche, pas comme une hauteur. Section 2123
Direction Les rebords descendent ou vont de côté, jamais vers le haut, et surtout vers le sud. Aucun rebord des cartes lues dans les quatre jeux ne monte vers le haut de l’écran ; plein sud représente 69.5% à 93.5% des cellules de rebord de chaque jeu, en comptant les cellules que chaque moteur fait sauter. Les 77 pièces d’angle diagonales d’Émeraude sont dessinées et bloquées, pas sautées ; les angles de Cristal se sautent. Section 215
Emplacement Un rebord mérite sa place là où le détour est long. Le détour extérieur médian dans Rouge Feu et Émeraude est de 10 à 12 cellules contre les 2 d’un saut, et la moitié des 549 cellules de rebord droites extérieures mesurées dans Émeraude n’en ont aucun dans leur carte ; sur une carte avec des escaliers toutes les 7 ou 8 tuiles, une descente fait gagner moins d’une tuile. Sections 2 et 61911
Rangées Les rangées font environ quatre cellules. La rangée droite médiane est de 4 dans Émeraude comme dans Rouge Feu. Section 21
Le saut Le saut prend le temps de deux pas de marche, quelle que soit l’allure. 32 images de déplacement pour deux cellules, 0.536 seconde, dans Rouge, Cristal et Émeraude (Rouge ajoute au moins trois images de nettoyage avant l’entrée suivante), 12 pixels de haut sur une cellule de 16 ; dans Émeraude, un coureur saute dans les mêmes 32 images, deux fois le temps de courir sur deux cellules. À la marche de Kiradex, 4 tuiles par seconde, deux tuiles font 0.5 seconde. La section 9 garde la moitié de cette règle qui concerne la marche et explique pourquoi la descente de Kiradex ne garde pas la moitié « quelle que soit l’allure ». Section 361254
L’ombre L’ombre reste au sol. Rouge, Cristal et Émeraude en dessinent chacun une pendant le saut et la maintiennent au niveau du sol pendant que le sprite s’élève ; Émeraude ajoute un nuage de réception de trois images. Section 336421516
Lisibilité Une arête à sens unique doit avoir l’air à sens unique des deux côtés. Les 15 metatiles orientés sud du jeu de tuiles primaire partagé d’Émeraude éclairent la surface en haut et assombrissent la lèvre vers leurs rangées du bas (les jeux de tuiles secondaires n’ont pas été rendus) ; l’équipe de CrossCode, à qui l’on disait que ses hauteurs étaient difficiles à lire, a annoncé qu’elle les marquerait par la couleur. C’est le dessin, et non un panneau, qui porte la règle. Sections 3 et 54350
Ponts N’utilisez des cellules multiniveaux que là où quelqu’un passe dessous. 35.9% des cellules de pont d’Émeraude sont multiniveaux, et elles se trouvent là où quelqu’un passe dessous : un surfeur sur trois routes, un marcheur sous les ponts de rondins de Cimetronelle. Un tablier au-dessus d’une eau où personne n’entre est du sol. Section 49
Hauteur des ponts La hauteur d’un pont se lit en dessous et dessus : sur les ponts d’étang de la Route 120, un reflet 28 ou 44 pixels plus bas selon la hauteur du pont (le type bas de 12 pixels du code est inutilisé, et les ponts sur la mer ne reçoivent aucun décalage), une planche qui cède sur les ponts de rondins de Cimetronelle, un son seulement sur le tablier. Section 41546
Grandes ascensions Les grands changements de hauteur sont des scènes, pas des tuiles. Le téléphérique d’Émeraude est une scène de 9.5 secondes avec son propre changement de météo. Section 4647
Le pli Le pli n’existe vraiment qu’à demi ouvert. La région de division est active quand l’iPhone Duo est partiellement ouvert et inactive quand il est complètement ouvert, et Apple demande aux développeurs de repérer ce qui s’y trouve et qui est difficile à voir ou à toucher. Ma proposition, non testée : une rangée que personne n’a besoin de toucher, comme la face d’un mur, est la seule chose qui ait sa place là. Section 8, une proposition5657

8. La manière Apple : un marcheur qui décolle, un graphe à arêtes à sens unique, et le pli

Le moteur sous Kiradex World est celui qu’a posé le premier billet : une scène RealityKit utilisée comme moteur de rendu 2D, une caméra orthographique à un nombre entier de pixels d’écran par texel, chaque matériau non éclairé et découpé.58 Rien de ce que propose ce billet n’exige un nouveau framework. Il faut trois modifications dans du code existant, et une lecture d’une API que l’app appelle déjà. Rien de tout cela n’a été construit ni chronométré ; chaque coût ci-dessous est nommé et signalé comme non mesuré.

Où se tient un marcheur, et ce qu’un saut ne doit pas déplacer

PlazaRig.place fixe à chaque image la position d’une entité de marcheur à partir d’un point au sol que lui transmet advance, un point sur la droite entre le centre de la tuile quittée et celui de la tuile où l’on entre : x et y arrondis à des unités de monde entières, pour que les marcheurs se tiennent sur des pixels entiers, et z tiré de TileMap.depth(atWorldY:) pour ce point au sol, soit 1 + (1 - y / (height × 16)) × 0.5, d’autant plus proche de la caméra que le marcheur se tient bas à l’écran.5453 Les objets comme les bâtiments et les arbres sont dessinés à la profondeur de leur rangée de base moins 0,001, si bien qu’un marcheur sur une rangée derrière la base d’un bâtiment est caché par lui, et qu’un marcheur sur la rangée de base se tient devant.53 Cette seule fonction décide qui est dessiné par-dessus qui dans toute la ville, ce qui explique que la rangée de toit praticable de la section 6 n’exige aucune modification du moteur.11

L’ombre du marcheur est un plan ModelEntity de 12 sur 4, ajouté comme enfant de l’entité du marcheur et placé sous les pieds, un cheveu derrière la silhouette.54 L’entité du marcheur est la silhouette elle-même : l’image de la planche de personnage est le matériau propre de cette entité, et le commentaire du code appelle l’ombre « The blob under the feet, a child of the figure. » (la tache sous les pieds, un enfant de la silhouette).54 Tout ce qui soulève la silhouette soulève donc l’ombre avec elle. Un saut construit en ajoutant l’arc au y de l’entité du marcheur emporterait l’ombre dans les airs, la seule chose que Rouge, Cristal et Émeraude évitent tous (section 3), et placerait aussi le marcheur à la mauvaise profondeur si z était calculé à partir du y soulevé. Le saut obéit donc à deux règles qui relèvent de la structure, pas du graphisme : calculer z à partir du point au sol avant d’ajouter toute élévation, comme Émeraude garde son arc dans y2 et sa position au sol dans y ; et garder l’ombre sur le point au sol, soit en abaissant à chaque image le y local de l’ombre de la valeur d’élévation, soit en donnant à la silhouette une entité enfant à elle, soulevée à côté de l’ombre.1554 Aucune des deux règles n’immobilise quoi que ce soit. Une descente emporte le marcheur deux rangées plus au sud, si bien que le point au sol, la profondeur qui en est tirée et l’ombre se déplacent tous pendant le saut, comme à chaque pas ; ce qui doit rester hors des trois, c’est l’élévation. La vérification 4 du cahier des charges consigne chacun d’eux par rapport au point au sol.

La marche elle-même fait avancer à chaque image la progression d’un pas de dt × tilesPerSecond × pace ÷ length. tilesPerSecond vaut 4 ; l’allure est runPace, 1,6, quand le marcheur court, et 1 sinon, et walk(to:) active la course pour tout chemin de 6 pas ou plus ; la longueur vaut √2 pour un pas en diagonale et 1 pour tout le reste.54 En l’état du code, le pas d’une descente sur deux rangées recevrait donc une longueur de 1 et serait franchi en 0,25 seconde à la marche et 0,16 à la course, la moitié du temps des deux tuiles qu’il couvre.4 Le cahier des charges modifie cette ligne pour que la longueur d’une descente soit 2 (section 9, point 4). Une descente prend alors 0,5 seconde à la marche, 30 images à 60 hertz, 0,933 fois les 0,536 du canon, et 0,31 seconde à la course nominale de 6,4 tuiles par seconde.4 Ce sont des chiffres nominaux, distance divisée par vitesse. advance ajoute l’incrément de chaque image à une valeur de progression et jette le dépassement quand un pas s’achève, si bien que l’arithmétique propre au rig tourne un peu plus lentement que ses constantes : rejoué en Float à 60 hertz, un pas de course droit fait 10 images, et non 9,375, un pas en diagonale 14, et une descente de deux tuiles 19 images, 0,317 seconde, contre les 20 images de deux pas de course ; à la marche, un pas fait 15 images et une descente 30, exactement les chiffres nominaux. C’est le même pas de course de 10 images qu’a trouvé le modèle de ce code dans le billet sur le mouvement, 6,00 tuiles par seconde là où la constante dit 6,4.54554 Si le cahier des charges du billet sur le mouvement aboutit, une marche à 1 pixel par tick et 16 ticks par tuile et une course à 2 pixels par tick et 8 ticks par tuile à 60 hertz, la même règle donne une descente de 32 ticks à la marche, le nombre d’images du canon, et de 16 à la course.554

Des arêtes à sens unique dans le graphe de marche

TileMap.path est une recherche du moins coûteux d’abord sur huit mouvements, une diagonale coûtant Float(2).squareRoot() et étant ignorée sauf si les deux tuiles entre lesquelles elle passe sont praticables.53 Une descente est un mouvement de plus : depuis une tuile de départ, une arête vers une tuile de réception deux rangées plus bas, coût 2, et aucune arête de retour. Dans le code, c’est un dictionnaire du départ vers la réception, lu à partir d’une clé facultative drops dans l’export de la forge, et deux lignes dans la boucle qui ajoutent l’arête quand la tuile en cours d’expansion est un départ. La recherche n’a besoin d’aucune autre modification, car une recherche du moins coûteux d’abord gère déjà des arêtes de coûts différents ; le script de portillon du billet sur les routes modélise son portillon de cette façon, et la sonde et le script Kiradex de ce billet modélisent les descentes de cette façon.172111

Le serveur est la moitié la plus difficile. Le client envoie un message move par tuile franchie, ["t": "move", "tile": [tile.x, tile.y], "facing": facing].59 Le serveur accepte un mouvement si la tuile de destination est praticable, sans vérifier qu’elle est voisine de la précédente ; les seules autres vérifications d’un mouvement sont une orientation valide et une limite de débit.59 Le serveur actuel accepterait donc une réception à deux tuiles du départ sans savoir qu’une descente existe, et accepterait tout autant un saut de retour vers le haut. Son propre Plaza.path cherche dans quatre directions, bien que sa docstring le décrive comme « the same walk the app takes » (la même marche que celle de l’app).59 Le cahier des charges du billet sur les routes fait déjà passer le serveur au graphe à huit directions du client ; ce cahier des charges ajoute les descentes à ce graphe et demande au serveur de vérifier que chaque mouvement est un pas ou une descente, ce qui est la parité que teste la vérification 12 du cahier des charges des routes.17

Le pli : deux API, et une rangée qui peut se trouver dessous

L’iPhone Duo se plie, et à demi ouvert, le pli traverse la vue. Apple fournit à SwiftUI deux éléments pour cela. GeometryProxy.reservedRegions(kind:options:layoutDirectionBehavior:) « Returns an array of reserved regions that match the selection options you specify » (renvoie un tableau des régions réservées correspondant aux options de sélection indiquées), et l’un des types de région est « An area where content splits into separate regions, such as at the fold of a hinge. » (une zone où le contenu se scinde en régions distinctes, comme au pli d’une charnière). Sa page de documentation indique iOS 27.1 et iPadOS 27.1, marqués bêta, ainsi que Mac Catalyst, macOS, tvOS, visionOS et watchOS 27.1.57 View.onHingeChange(isEnabled:_:) « Adds an action to perform when the hinge context of the view hierarchy changes, » (ajoute une action à exécuter quand le contexte de charnière de la hiérarchie de vues change), avec les mêmes plateformes.60 Le guide d’Apple sur la préparation d’une app indique quand le pli compte : « a reserved region that represents the fold is active when iPhone Duo is partially open, but inactive when it is fully open. » (une région réservée qui représente le pli est active quand l’iPhone Duo est partiellement ouvert, mais inactive quand il est complètement ouvert). La même page demande aux développeurs : « Identify elements or controls in your views that appear in the fold, and are difficult to see or interact with. » (repérez les éléments ou commandes de vos vues qui apparaissent dans le pli et sont difficiles à voir ou à manipuler).56 Et les Human Interface Guidelines : « Avoid extreme layout changes as people fold the device. » (évitez les changements de mise en page extrêmes quand on plie l’appareil).61

Kiradex lit déjà les deux. Fold.read demande reservedRegions(kind: .division) et prend la première région active, derrière #available(iOS 27.1, *) et une vérification à la compilation du SDK 27.1, avec le commentaire « Reserved regions are in the 27.1 SDK only; a build from the 27.0 SDK the App Store takes sees no fold » (les régions réservées n’existent que dans le SDK 27.1 ; un build issu du SDK 27.0 qu’accepte l’App Store ne voit aucun pli).62 Un modificateur HingeReads compte les rappels onHingeChange et, après chacun, relit la région quatre fois, en dormant successivement 0,1, 0,4, 1,0 et 2,5 secondes, si bien que les lectures tombent environ 0,1, 0,5, 1,5 et 4,0 secondes après le rappel, parce que la région « arrives a few layouts after the hinge moves » (arrive quelques mises en page après le mouvement de la charnière).624 Et le follow de la caméra maintient le joueur au centre du côté le plus large du pli, et non de la vue.54

Pour une terrasse, le pli ajoute une considération. À demi ouvert, une bande de la ville se trouve sous le pli, et ce qu’un collectionneur a le plus besoin d’y voir ou d’y toucher, ce sont les portes, les escaliers, le départ d’une descente et sa propre silhouette. La face d’un mur est la seule rangée d’une terrasse que personne n’a besoin de toucher. Selon ma lecture, cela fait d’un mur de terrasse la chose naturelle à laisser couvrir par le pli une fois la caméra posée, et rien qu’il faille poursuivre pendant que le collectionneur marche, puisque les HIG demandent d’éviter les changements de mise en page extrêmes quand l’appareil se plie. C’est une proposition, et la vérification 8 du cahier des charges la teste.

Aucun iPhone Duo n’était disponible pour ce billet. La vérification du pli est une capture sur le simulateur d’iPhone Duo, dont le Device Hub propose les poses Closed, Book et Open ; le billet de cette série sur le simulateur a trouvé une division inactive de 40 points de large au milieu de l’écran ouvert, « that turns active in the Book pose. » (qui devient active dans la pose Book).63 Que le matériel signale la même région au même moment reste non vérifié tant qu’un appareil n’est pas disponible.

Ce que cela coûte, et ce qui n’est pas mesuré

Rien dans cette section n’a été chronométré. Un saut ajoute le décalage d’un quad et le décalage d’une ombre par image pour un marcheur ; une descente ajoute une arête par départ à la recherche que le rig exécute déjà pour planifier chaque trajet ;54 une rangée de toit praticable est une nouvelle lettre. Leur coût en temps d’image reste non mesuré ; les vérifications du cahier des charges mesurent le comportement, pas le coût. La règle de capture du premier billet s’applique à chaque capture que demande le cahier des charges : sur le simulateur, les images RealityKit ne sont fidèles que si elles sont capturées depuis l’intérieur du bundle de test.58

9. Le cahier des charges : ce que Kiradex construit et les vérifications à passer

Synthèse de l’auteur. Ce qui suit est ma proposition, tirée des sections 1 à 8 et rédigée comme un diff par rapport à ce qui est livré aujourd’hui, lu au commit Kiradex 334fbfe le 5 octobre 2026 (l’arborescence de travail de l’app était en cours de réécriture ce jour-là, si bien que chaque ligne citée dans cette section est celle de ce commit) : la ville à deux niveaux du build 35 (town.json du 3 octobre 2026), TileMap, PlazaRig, le serveur de la place, et le cahier des charges du billet sur les routes pour la promenade des Prés.2017 Il ne nomme ni ne dessine rien qui vienne d’un jeu Pokémon. Là où il emprunte une mécanique, la règle de la section 7 en indique l’origine ; l’aspect est propre à Kiradex, et la liste « must not resemble » (ne doit pas ressembler à) du billet hommage s’applique : pas de « grass lip with a light top edge and a dark shadow line, » (lèvre d’herbe au bord supérieur clair, avec une ligne d’ombre sombre), pas la courbe de saut du canon, pas son son.27 Chaque longueur est un coût sur la marche à huit directions de l’app, en tuiles, et chaque durée précise son allure : le code actuel marche à 4 tuiles par seconde et court à 1,6 fois cette vitesse, soit 6,4 en nominal, sur tout chemin de 6 pas ou plus ; le cahier des charges du billet sur le mouvement, s’il aboutit, marche à 16 ticks par tuile et court à 8, à 60 ticks par seconde, soit 3,75 et 7,5 tuiles par seconde.535455 Rien de tout cela n’a été construit.

La décision sur les rebords, et ce qui a changé depuis la recherche sur les structures

La recherche sur les structures a refusé les rebords parce qu’une hauteur libre est difficile à lire vue de dessus, ce qui est l’avertissement de CrossCode dans les propres mots de ses développeurs (section 5).2650 Deux choses ont changé depuis.

D’abord, les données montrent qu’un rebord n’a pas besoin de hauteur. C’est une arête à sens unique qui relie le plus souvent deux cellules de même élévation stockée : 94,4 % des rebords de Rouge Feu et 83,1 % des cellules de rebord droites d’Émeraude ayant une cellule de chaque côté relient des élévations égales, Rouge Feu stocke chaque cellule de rebord à la valeur de transition et aucun de ses rebords ne relie deux niveaux de sol, et les 28 rebords d’Émeraude qui changent bel et bien de niveau le tiennent de la cellule de réception, non d’une règle propre au rebord (section 2).12 Une descente coûte donc au moteur une arête orientée, pas un axe z, et la raison du refus, la hauteur libre, ne s’applique pas à elle. Ensuite, le travail sur les routes a trouvé la seule tâche que seul un élément à sens unique peut accomplir : sur une grille praticable dans les deux sens, le plus court retour est le plus court aller, donc un chemin du retour plus court exige une arête qui ne va que dans un sens.17

Donc : les descentes, oui, comme arêtes orientées ; la hauteur par cellule, toujours non. Reste refusé tout ce que couvrait la raison d’origine : l’escalade, le saut libre, toute descente vers le haut de l’écran, et la hauteur par cellule avant qu’une tuile soit praticable à deux hauteurs.

Leur place n’est pas sur la Grand-Place. Les volées de la Grand-Place se succèdent déjà toutes les 7 ou 8 tuiles, et une descente n’importe où dans son mur fait gagner au plus 0,59 tuile sur un trajet vers une porte (section 6).11 Les villes du canon ne servent de guide ni dans un sens ni dans l’autre, puisque celles de Hoenn n’ont pas de rebords et que celles de Kanto en ont (section 6) ; ce sont les chiffres propres à Kiradex qui tranchent.15 Les descentes vont au bord de la place, dans la promenade des Prés, où elles remplacent le portillon de la haie du cahier des charges des routes, conservent son chemin du retour de 88,07 tuiles et raccourcissent l’aller sur certains agencements, si bien que la conception est tenue aux fourchettes du cahier des charges des routes plutôt qu’aux longueurs exactes du portillon (section 6, et la vérification 2 ci-dessous).2122

1. Les descentes comme arêtes à sens unique dans le graphe de marche

  • Données. L’export de la forge gagne une clé facultative drops, une liste de paires de tuiles de départ et de réception. TileMap la lit dans drops: [SIMD2<Int>: SIMD2<Int>], du départ vers la réception. Un export sans la clé se comporte exactement comme aujourd’hui.20
  • L’arête. Dans path, une tuile de départ gagne un mouvement de plus : vers sa tuile de réception, deux rangées plus bas, coût 2. Il n’y a aucune arête de retour. On n’entre dans une descente que par un pas droit dans sa direction ; un pas en diagonale qui la traverserait est refusé, comme le saut du canon ne va jamais que dans la direction où regarde le joueur (section 2).620
  • Le pas. path renvoie des tuiles, si bien qu’un trajet qui emprunte une descente la porte comme une seule entrée, la tuile de réception, juste après le départ : un pas de (0, 2), sur lequel s’appuie la modification d’advance du point 4.5354
  • Le mur. La cellule de mur entre le départ et la réception reste bloquée. Une descente ne rend jamais une cellule praticable ; elle ajoute une arête par-dessus.
  • Direction. Vers le sud uniquement. Aucun rebord des cartes lues dans les quatre jeux ne monte vers le haut de l’écran (section 7, Direction), et sur les neuf routes cartographiées par le billet sur les routes, le trajet vers la ville précédente est le plus court. La promenade des Prés de Kiradex court du nord au sud, la maison à l’extrémité sud, donc le sud est le chemin du retour.117

Vérification de recette 1, les descentes sont à sens unique. Un test unitaire sur une carte de test comportant une descente. path renvoie des tuiles, pas un coût, si bien que le test additionne les coûts de pas des tuiles renvoyées, 1 pour un pas droit, √2 pour une diagonale et 2 pour une descente : du dessus de la descente vers le dessous, le chemin emprunte la descente et la traversée totalise 2 ; du dessous vers le dessus, il ne l’emprunte pas ; et le seul pas de descente dans un chemin renvoyé est l’arête (0, 2) partant de son départ. Depuis la tuile en diagonale au-dessus du départ, la réception totalise donc √2 + 2, une diagonale jusqu’au départ puis la descente, et depuis la tuile à côté du départ elle totalise 3, un pas droit jusqu’au départ puis la descente ; un chemin qui atteint la réception depuis la tuile à côté du départ en un seul pas, une colonne de côté et deux rangées plus bas, est une descente prise en diagonale, et fait échouer le test.

2. Murs de terrasse et descentes dans la promenade des Prés

  • Murs de terrasse. Les quatre haies que le cahier des charges des routes pose en travers du pré, à ses rangées locales 12, 24, 36 et 48, deviennent des murs de soutènement dessinés avec le kit de face de mur de la Grand-Place elle-même (props.wall_face dans la forge), chacun conservant son ouverture de 2 tuiles comme volée d’escalier (props.stair). L’allée bordée de haies et son portillon sont abandonnés.1764
  • Descentes. Dans chaque mur, une rangée de 2 tuiles de descentes là où se trouvait l’allée, colonnes 22 et 23 du pré, orientées au sud vers la Grand-Place. Deux tuiles, c’est la moitié de la rangée droite médiane de quatre dans Émeraude et Rouge Feu (section 2), et cela correspond à l’allée qu’elles remplacent.121
  • Leur aspect. Une bordure de pierre basse dans la gamme de pierre de la forge, avec une lèvre entaillée et une marque de marche usée sur la tuile de réception, dessinée comme partie de la face du mur, pour que la descente se lise comme le point bas du mur plutôt que comme un bord d’herbe. L’assise supérieure de la bordure est d’un cran plus claire que le chaperon du mur pour que, depuis le pré, elle se lise comme « lower here » (plus bas ici). C’est la réponse de Kiradex à la règle de lisibilité de la section 7, tirée de la pierre de la ville elle-même, et non de la lèvre du canon.2027

Vérification de recette 2, le pré respecte les chiffres des routes. La vérification de distance du cahier des charges des routes, exécutée sur la Grand-Place, la promenade des Prés et le Bord du lac reliés, avec des descentes à la place du portillon, comme l’exécute astra_meadow_joined.py (section 6) : pour les positions d’ouverture que choisit la forge, le retour du ponton à l’arrivée fait 88,07 tuiles, l’aller se situe entre 110 et 120, et le retour vaut 0,8 fois l’aller ou moins. La vérification n’exige pas que les descentes reproduisent les longueurs du portillon, car une fois reliées elles ne le font pas : sans la haie de l’allée, le pré est ouvert sur la Grand-Place le long de ses 24 colonnes, et l’aller est plus court sur 1 035 des 4 111 agencements acceptés par le portillon. Le 4 111 est le chiffre du portillon et reste celui du billet sur les routes ; le chiffre propre à la conception à descentes, issu du balayage des 160 000 positions d’ouverture sous les mêmes fourchettes, est de 4 607 agencements, avec un retour de 88,07 sur chacun et valant 0,734 à 0,800 fois l’aller. La forge choisit dans cet ensemble, et la vérification reproduit les trois chiffres sur la carte construite.17224

3. Le serveur parcourt le même graphe

Le cahier des charges des routes fait déjà passer le Plaza.path du serveur à la recherche à huit directions du client, à √2, sans couper les angles.17 Ce cahier des charges y ajoute les descentes : le serveur lit la même liste drops dans sa copie de chaque zone et ajoute les mêmes arêtes à sens unique. Le serveur actuel accepte toute destination praticable sans vérifier la contiguïté (section 8), si bien qu’une réception à deux tuiles du départ passerait, tout comme un saut de retour vers le haut.59 Avec le travail de parité du cahier des charges des routes, chaque mouvement doit être soit un pas vers une tuile voisine, soit une descente d’un départ vers sa réception.

Vérification de recette 3, parité du serveur. Un test serveur fait franchir une descente dans les deux sens à un collectionneur, sur la même carte de test que la vérification 1 : la recherche du serveur renvoie les mêmes tuiles que celle de l’app, avec le même coût de pas total, et un message move vers le nord à travers la descente, d’une tuile de réception à son départ, est refusé.

4. Le saut

  • Durée. Une descente prend le temps de ses deux tuiles à l’allure propre du marcheur. La modification tient en une ligne dans la règle de longueur de pas du rig (advance, ligne 659 à 334fbfe) : un pas de (0, 2) reçoit une longueur de 2 au lieu de 1, et l’allure de course s’y applique comme à tout autre pas (section 8). Dans le code actuel, cela fait 0,5 seconde à la marche et 0,31 à la course nominale ; avec le cahier des charges du billet sur le mouvement, 32 ticks à la marche, le nombre d’images du canon, et 16 à la course, 2 pixels par tick, comme se déplace sa course.54554
  • La course. C’est le seul endroit où le cahier des charges s’écarte délibérément du canon. Le saut d’Émeraude dure les mêmes 32 images à la course (section 3), deux fois ce que prend la course sur ses deux cellules, et Émeraude peut se le permettre, parce que ses rebords droits extérieurs qui ont un détour remplacent une marche médiane de 12 cellules (10 pour Rouge Feu). Les descentes du pré ne remplacent aucun détour : elles remplacent une allée de même longueur, et le chemin du retour qu’elles servent, 51 pas simples et 4 descentes, se fait toujours en courant. Maintenues à 0,5 seconde de marche quelle que soit l’allure, les quatre descentes rendraient ce retour en courant plus lent de 0,75 seconde que l’allée du portillon dans le code actuel (9,97 secondes contre 9,22) et de 64 ticks avec le cahier des charges du mouvement (536 contre 472), et sur 96 des 400 agencements tirés dans le code actuel, et 169 avec le cahier des charges du mouvement, le retour ne serait plus plus rapide que l’aller, ce qui est toute la raison d’être des descentes. À l’allure de la démarche, le retour est plus rapide que l’aller sur les 400 dans les deux cas, et prend le temps du portillon dans l’arithmétique nominale, distance divisée par vitesse, 9,22 secondes dans le code actuel. Rejoués dans l’arithmétique Float propre au rig à 60 hertz, où le dépassement de chaque pas est jeté (section 8), les deux sont proches mais pas égaux : 59 pas de course par le portillon font 590 images et 51 pas plus 4 descentes en font 586, une descente prenant 19 images là où deux pas de course en prennent 20. Le cahier des charges n’exige pas la parité en images ; la vérification 4 énonce la durée de la descente sous les deux formes.121921544
  • Allure. walk(to:) garde sa règle, la course pour un chemin de 6 pas ou plus, et une descente compte pour un pas dans ce décompte. Chaque trajet qu’une descente raccourcit en section 6 compte 19 pas ou plus, et le retour du pré 55, si bien qu’aucun trajet mesuré ici ne change d’allure à cause d’une descente.544
  • Arc. Celui de Kiradex, pas la table en 16 pas du canon : une parabole culminant à 10 texels, échantillonnée à chaque image et arrondie au texel entier, puisque le rig place déjà les marcheurs sur des pixels entiers. Dix texels sur une tuile de 16 texels, c’est un arc plus bas que les 12 pixels sur 16 du canon (section 3, et la courbe en pointillés de sa figure).544
  • Images. Quatre nouvelles images de rig par orientation dans le rig.py de la forge : accroupi, envol, chute et réception. Le rig n’a aucun saut aujourd’hui.64
  • Ombre. L’ombre de 12 sur 4 est un enfant de l’entité du marcheur, et l’entité du marcheur est la silhouette, si bien que soulever la silhouette la soulève (section 8). Soit place ajoute l’élévation au y de l’entité et fixe à chaque image le y local de l’ombre à sa valeur au repos moins l’élévation, soit la silhouette passe dans une entité enfant à elle, seule soulevée. Dans les deux cas, l’ombre suit le point au sol pendant le saut, à sa taille habituelle (section 7, L’ombre).54
  • Profondeur. Calculer z à partir du point au sol qu’advance transmet à place, avant d’ajouter l’élévation, comme Émeraude garde l’arc dans y2 et la position au sol dans y (section 3).1554
  • Réception. Un nuage de deux images dans la gamme de pierre de la forge.
  • Son. Un son court propre à Kiradex au départ, dérivé d’aucun jeu.

Vérification de recette 4, le saut. Un journal du rig sur une descente, une ligne par image, avec le point au sol qu’advance transmet à place, l’élévation, le y que place calcule à partir du point au sol sans élévation (le y au sol), le y monde dessiné de la silhouette, le y monde de l’ombre et le z de l’entité du marcheur. Il s’exécute deux fois sur une carte de test, une fois sur un chemin assez court pour être marché et une fois sur un chemin de 6 pas ou plus, et réussit quand, à chaque image des deux :

  • le y dessiné de la silhouette moins le y au sol égale l’élévation, qui culmine à 10 texels ;
  • le y monde de l’ombre moins le y au sol égale le décalage au repos de l’ombre, la même valeur que lorsque le marcheur est immobile, si bien qu’une ombre qui s’élève avec la silhouette échoue à chaque image où l’élévation dépasse 0 ;
  • le z de l’entité du marcheur égale map.depth(atWorldY:) du y du point au sol, si bien qu’un z tiré du y soulevé échoue : sur une carte de 30 rangées comme la Grand-Place, il s’écarte de 0,0104 à un sommet de 10 texels, plus de dix fois les 0,001 qui trient un marcheur par rapport à la rangée de base d’un objet ;534
  • et la descente prend 30 images à 60 hertz à la marche, 0,5 seconde, et 19 images à la course, 0,317 seconde, soit le rejeu Float du rig pour 0,3125 nominal, chacune à une image près, dans le code actuel (exactement 32 et 16 ticks avec le cahier des charges du mouvement).

Rien dans la vérification n’exige que le y au sol, l’ombre ou z restent constants : la descente emporte les trois deux rangées vers le sud, comme tout pas les emporte d’une.

5. La rangée de toit praticable

Donnez à la rangée supérieure du toit de chaque bâtiment une lettre praticable propre dans le swift_rows de la forge, ajoutez-la à TileMap.Tile comme praticable et non déclencheur, et ajoutez-la à l’ensemble WALKABLE du serveur. Le buildings.py de la forge cesse de compter cette rangée parmi les cellules bloquées d’un bâtiment. La règle de profondeur dessine déjà un marcheur sur cette rangée derrière le bâtiment (section 6), si bien que rien ne change dans le moteur.11536459 Le dossier proposait ^ comme lettre, inutilisée dans les lettres exportées ; la passe des bois de la forge utilise pourtant ^ en interne, comme espace réservé qu’elle efface avant l’export, si bien que la forge devrait prendre une lettre qui n’y apparaît nulle part.2064 Les 8 trajets qu’elle raccourcit de 0,59 tuile sont un effet secondaire, pas la raison ; la raison est qu’un bâtiment dont l’arrière est praticable se lit comme un bâtiment dans un lieu, et non comme un bloc sur un plateau.11

Vérification de recette 5, la rangée de toit. Les lettres exportées portent la nouvelle lettre sur exactement 37 cellules, et une capture montre un collectionneur sur la rangée supérieure de sa propre maison, la tête au-dessus du faîtage et le corps caché derrière.

6. Une passerelle sur l’étang

Une passerelle en planches nord-sud en x 4, rangées 23 à 27, reliant la pelouse de la rue basse à la pelouse sud du parc. Les tuiles du tablier sont une lettre praticable dessinée comme du sol, les garde-corps des côtés est et ouest étant dessinés comme des objets, si bien que le pont n’a besoin d’aucune occultation à mi-corps. Il n’a pas d’élévation, car personne ne passe dessous (section 7, Ponts). L’animation de l’eau doit ignorer le tablier. Une planche sous le marcheur peut s’enfoncer d’un texel puis remonter, la version Kiradex du pont qui répond au pas (section 4).114620

Vérification de recette 6, le pont. path de (4, 22) à (4, 28) renvoie des tuiles dont les coûts de pas totalisent 6,00, contre 12,83 aujourd’hui ; sur les quatre images d’eau de l’atlas, aucune tuile du tablier ne change ; et l’export n’a pas de clé elevation.

7. La hauteur par cellule : différée, et déjà corrigée pour le jour où elle viendra

La recherche (cellule, hauteur) du dossier moteur n’est nécessaire à rien dans les points 1 à 6. Gardez-la en attente jusqu’à ce qu’une carte ait une tuile praticable à deux hauteurs, une passerelle au-dessus d’un chemin.18 Le moment venu, corrigez la règle de transition (section 7, La règle de marche) : après un pas, la hauteur du marcheur devient l’élévation de la cellule, 0 compris, sauf si la cellule où l’on entre ou celle que l’on quitte est multiniveau ; et gardez un niveau d’affichage séparé qui ne se met à jour que lorsque la cellule n’est ni à 0 ni à 15, comme le fait previousElevation dans Émeraude.3 Le canStep du dossier moteur correspond déjà à l’IsElevationMismatchAt d’Émeraude et reste tel quel ; seul height(after:was:) change, et il a besoin de la cellule quittée en plus de la cellule où l’on entre :1820

// Sketch: has not been compiled or run in the app.
func height(after cell: SIMD2<Int>, from here: SIMD2<Int>, was height: UInt8) -> UInt8 {
    guard let elevation else { return height }
    let there = elevation[cell.y * width + cell.x], left = elevation[here.y * width + here.x]
    return there == Self.multiLevel || left == Self.multiLevel ? height : there
}

Ceci est une esquisse. Elle n’a été ni compilée ni exécutée dans l’app. Sa logique est la règle que measure_gen3_elevation.py rejoue comme celle d’Émeraude, qui gravit les 114 escaliers extérieurs d’Émeraude et de Rouge Feu ; l’esquisse qu’elle remplace n’en gravit aucun.10

Vérification de recette 7, pas de hauteur inutilisée. Une vérification de la forge fait échouer tout export qui porte une clé elevation alors qu’aucune de ses tuiles n’est praticable à deux niveaux. Quand la hauteur par cellule sera construite, un test unitaire sur une carte de test comportant un escalier d’une cellule entre les niveaux 3 et 4 ira du niveau inférieur au niveau supérieur avec la nouvelle règle, et échouera avec l’ancienne.

8. Le pli au-dessus d’une terrasse

Quand la région de division est active et traverse la vue, la caméra peut se poser de sorte que le pli couvre une rangée de mur de la promenade des Prés, et jamais un escalier, le départ d’une descente, une porte ou le joueur. Ce placement supplémentaire n’a lieu que lorsque le collectionneur s’arrête ; pendant qu’il marche, la caméra garde la règle actuelle, le joueur au centre du côté le plus large du pli, et ne se décale jamais pour le mur.566154

Vérification de recette 8, le pli. Sur le simulateur d’iPhone Duo, dans la pose Book du Device Hub, où la division devient active, une capture prise depuis l’intérieur du bundle de test, le collectionneur se tenant à chaque escalier et au départ de chaque descente de la promenade des Prés, ne montre aucune porte, aucun escalier, aucun départ de descente ni aucune tuile du joueur sous le pli.6358 Aucun iPhone Duo n’était disponible pour ce billet ; il s’agit d’une vérification sur simulateur, et la même capture sur le matériel reste à faire tant qu’aucun appareil n’est disponible.

9. Noms et graphisme

La descente, la bordure, les images du saut, son son et la passerelle sont dessinés dans la forge à partir de la palette et du kit propres à Kiradex, et nommés avec les mots propres à Kiradex.27

Vérification de recette 9, noms et graphisme. Chaque nouveau nom passe la liste d’exclusion que réclame le cahier des charges des routes, qui n’existe pas encore et dont la construction revient au cahier des charges des routes, et une revue de la descente et du pont au regard de la liste « must not resemble » (ne doit pas ressembler à) du billet hommage, consignée avec des captures des deux, n’y trouve rien.1727

Hors de ce cahier des charges

  • Des descentes sur la Grand-Place : elles y font gagner au plus 0,59 tuile (section 6).11
  • Des descentes vers le haut de l’écran, qu’aucune carte lue des quatre jeux ne comporte, et des descentes de côté, dont le retour vers le sud du pré n’a pas besoin.1
  • La hauteur par cellule avant qu’une tuile soit praticable à deux hauteurs (point 7).
  • Des ponts avec élévation : personne ne passe sous le pont de l’étang.9
  • L’escalade et le saut libre : le coût que décrivent l’équipe de CrossCode et le directeur de Sea of Stars, une hauteur qu’il faut lire par la lumière et la couleur, n’apporte rien dont une ville de collectionneurs ait besoin (section 5).5052
  • Une scène de téléphérique ou tout autre trajet où la hauteur devient une scène : rien dans le cahier des charges des routes ne monte assez haut pour en avoir besoin.
  • L’aspect des rebords, la table de saut ou le son d’un jeu quel qu’il soit.27

Points clés

Si vous dessinez le graphisme

  • Dessinez un changement de niveau comme une paroi que le marcheur ne peut pas franchir, traversée par un escalier. À l’extérieur, plus de 99,7 % des paires praticables adjacentes sur un niveau de sol d’Émeraude et de Rouge Feu se trouvent sur un même niveau ; la hauteur vit dans la paroi rocheuse, pas dans le nombre.7
  • Faites qu’une arête à sens unique ait l’air à sens unique des deux côtés. Les rebords sud du jeu de tuiles primaire partagé d’Émeraude sont clairs sur leurs huit rangées du haut et tombent à leur point le plus sombre à la rangée 13 ou 14 ; trouvez votre propre façon de dire « lower here » (plus bas ici), et ne copiez pas cette lèvre.4327
  • Laissez l’ombre au sol quand quelque chose le quitte. Rouge, Cristal et Émeraude le font tous, et c’est ce qui distingue un saut d’un pas vers le nord.364215
  • Montrez la hauteur d’un pont en dessous et dessus : un reflet repoussé plus bas, une planche qui cède, un son que seul le tablier produit.1546

Si vous construisez le moteur

  • Modélisez un rebord comme une arête orientée du graphe de marche, pas comme une hauteur. Dans Rouge Feu, chaque cellule de rebord est une cellule de transition et 94,4 % des droites ayant une cellule de chaque côté relient des élévations égales ; les 28 rebords d’Émeraude qui relient deux niveaux prennent l’élévation de la cellule de réception comme n’importe quel pas, si bien que même là, le rebord n’en stocke aucune.123
  • Si vous stockez une hauteur, placez le marcheur à « aucun niveau » sur un escalier. La règle d’Émeraude gravit les 114 escaliers extérieurs d’Émeraude et de Rouge Feu ; une règle qui garde l’ancienne hauteur sur une transition n’en gravit aucun.310
  • Ne stockez de hauteur par cellule que là où une tuile est praticable à deux hauteurs. Seules 252 des 702 cellules de pont d’Émeraude en ont besoin, et aucun rebord.91
  • Tenez l’arc du saut à l’écart de la position au sol du marcheur, pour que la profondeur et l’ombre ne le voient jamais.1554
  • Faites parcourir au serveur le même graphe qu’au client, arêtes à sens unique comprises, et vérifiez que chaque mouvement est un pas ou une descente.5917

Si vous concevez la boucle de jeu

  • Placez un rebord là où le détour est long. Le détour extérieur médian dans Rouge Feu et Émeraude est de 10 à 12 cellules contre les 2 d’un saut ; sur une carte avec des escaliers toutes les 7 ou 8 tuiles, une descente fait gagner moins d’une tuile.1911
  • Orientez les descentes vers le bas de l’écran ou de côté, et sur une route, dans le sens du chemin du retour. Aucun rebord des cartes lues dans Rouge, Cristal, Émeraude ou Rouge Feu ne monte vers le haut de l’écran.15 Sur les neuf routes cartographiées par le billet sur les routes, le trajet vers la ville précédente est le plus court, et sur trois des quatre premières routes qu’il a lues, chaque rebord regarde vers la ville de départ ; la Route 29 de Cristal, dont les rebords regardent surtout en travers de la route, fait exception, et son chemin du retour est malgré tout plus court.17
  • Faites des grandes ascensions une scène. Le téléphérique d’Émeraude, ce sont 9,5 secondes de film avec sa propre météo, pas un escalier.647

Questions fréquentes

Comment les Pokémon en 2D gèrent-ils l’élévation ?

Dans la troisième génération, chaque cellule de carte stocke une élévation sur quatre bits à côté de son metatile et de sa collision. Un marcheur ne peut aller que sur une cellule à sa propre élévation, sauf si le marcheur ou la cellule est à 0, la valeur de transition utilisée pour les escaliers, ou si la cellule est à 15, la valeur multiniveau utilisée pour les ponts. Sur un escalier, l’élévation du marcheur devient 0, si bien que le pas suivant peut aller vers l’un ou l’autre niveau ; sur un pont, le marcheur garde la hauteur avec laquelle il est arrivé. La plupart des cartes extérieures utilisent au plus un niveau de sol : 50 des 68 d’Émeraude et 67 des 76 de Rouge Feu.3137

Comment fonctionnent les rebords dans Pokémon ?

Dans la troisième génération, un rebord est une cellule dont le comportement désigne une direction de déplacement droite ; pousser contre elle dans ce sens fait sauter le joueur de deux cellules, et aucune autre direction ne la franchit. Émeraude dessine aussi des pièces d’angle à comportement de saut diagonal, mais aucun code ne les lit, et elles sont bloquées. Dans Cristal, le rebord est la lèvre sur laquelle se tient le joueur, et ses angles se sautent dans l’un ou l’autre sens ; dans Rouge, c’est une paire de tuiles dans une table. Dans Rouge Feu, chaque cellule de rebord est stockée à la valeur de transition et 94,4 % relient un départ et une réception à la même élévation ; dans Émeraude, c’est 83,1 %, et 28 sur 944 relient deux niveaux de sol. Le moteur ne lit jamais l’élévation d’un rebord, et après le saut le marcheur prend celle de la cellule de réception, si bien qu’un rebord est une arête à sens unique qui n’exige aucune différence de hauteur. Aucun rebord des cartes lues dans Rouge, Cristal, Émeraude ou Rouge Feu ne se franchit vers le haut de l’écran ; la plupart regardent vers le sud.121312353736

Combien de temps dure un saut de rebord dans Pokémon ?

32 images de déplacement, 0,536 seconde aux 59,73 images par seconde des consoles portables, pour deux cellules, dans Rouge, Cristal et Émeraude, et dans Émeraude à la marche comme à la course ; Rouge attend ensuite au moins cinq images de plus, les deux qui ouvrent son passage suivant et les trois de Delay3, avant d’effacer l’état maintenu, pressé et relâché de la croix directionnelle et de laisser de nouveau compter les commandes du joueur, soit au moins 37 en tout. Le sprite s’élève de 12 pixels sur une cellule de 16 pendant qu’une ombre reste au sol ; les tables de hauteur de Cristal et d’Émeraude sont identiques entrée pour entrée.61239404

Comment fonctionnent les ponts dans Pokémon Émeraude, avec un joueur qui marche au-dessus d’un surfeur ?

Seules 252 des 702 cellules de pont d’Émeraude, 35,9 %, portent la valeur multiniveau 15, et elles se trouvent là où un surfeur, ou à Cimetronelle un marcheur, passe dessous, 248 des 252 sur les Routes 110, 119 et 120. Sur une cellule multiniveau, un marcheur garde l’élévation avec laquelle il est arrivé, si bien que celui qui est monté sur le tablier à pied reste en haut et que celui qui est arrivé en surfant reste en bas, et une table de priorités de seize entrées, avec la règle d’égalité du matériel, dessine le premier au-dessus de la couche supérieure d’un tablier Normal et le second en dessous. Sur les 450 autres cellules de pont, 329 sont des tabliers à une élévation fixe de 4 sous lesquels rien ne passe ; les 121 restantes sont 69 cellules stockées bloquées, 47 cellules ouvertes stockées à la valeur de surf 1, où un surfeur peut aller et un marcheur sur le tablier non, les quatre cellules de transition aux extrémités de deux ponts de la Route 110, et une cellule intérieure à 3.9307345

Comment faire des escaliers dans un jeu de tuiles vu de dessus ?

Faites comme Émeraude : un escalier fait le plus souvent une ou deux cellules, relie deux niveaux à travers une paroi, et coûte un pas ordinaire. 73 des 84 escaliers extérieurs d’Émeraude font 1 sur 1, 1 sur 2 ou 2 sur 1 cellules, sans aucun comportement d’escalier ; Rouge Feu ralentit la marche sur ses escaliers de roche de 16 à 23 images par cellule. Si votre règle de marche stocke une hauteur, l’escalier ne doit appartenir à aucun niveau, sinon personne ne le gravit.8610

Un jeu en pixel art vu de dessus doit-il avoir des rebords ou des sauts ?

Des rebords, là où un raccourci de retour à sens unique vaut une cellule : la moitié des 549 cellules de rebord droites extérieures mesurées dans Émeraude n’ont aucun détour dans leur carte, et pour les autres, un saut de 2 cellules remplace un détour médian de 12, un gain de 10. Le saut libre et l’escalade sont une autre conception, avec un coût que leurs auteurs nomment : l’équipe de CrossCode, à qui l’on disait que ses hauteurs étaient difficiles à lire, a annoncé qu’elle les marquerait par la couleur, et le directeur de Sea of Stars décrit des niveaux qui devaient se lire « with the light and everything » (avec la lumière et tout le reste).1945052

Les mécaniques, les chiffres et les méthodes de fonctionnement échappent au droit d’auteur ; les tuiles, sprites et sons précis sont protégés par le droit d’auteur, et les noms et marques par le droit des marques. Le premier billet de cette série traite de cette limite, avec la Circular 33 du Copyright Office américain.58 Ce cahier des charges emprunte la règle (une arête à sens unique, environ une demi-seconde à la marche, une ombre au sol) et dessine la descente, ses images et son son dans la forge propre à Kiradex, au regard de la liste du billet hommage de ce à quoi elle ne doit pas ressembler.2720


Comment ce billet a été réalisé. Le dossier de recherche qui le sous-tend a été compilé le 5 octobre 2026 à partir de clones superficiels des quatre décompilations pret, mesurés par des scripts Python conservés avec leurs sorties, sept au départ et cinq de plus ajoutés en relecture, l’un des sept reconstruit après que la relecture par le second moteur a trouvé son filtre de sol fautif, et à partir de copies archivées du manuel de Porymap, de deux billets de Radical Fish Games, des notes de terrain du désassemblage de FF6, du code du joueur de la réimplémentation zelda3, d’une interview de Screen Rant et de quatre pages de la documentation d’Apple. Pour ce jet, j’ai relancé les douze scripts dans une copie de travail du dossier de preuves et retrouvé leurs sorties enregistrées octet pour octet, sauf dans astra_meadow_joined.py, où une ligne affiche le temps réel écoulé de sa première section et où le balayage des 160 000 agencements a été exécuté une fois, et un treizième, arith.py, affiche chaque valeur dérivée, en reparcourant les graphes de deux des scripts là où une durée exige les pas d’un trajet. Chaque chiffre Pokémon du texte est la sortie d’un script, et chaque note nomme le script. La proposition de la section 9 est la mienne et signalée comme telle ; rien n’en a été construit, et rien n’en a tourné sur un iPhone Duo.

Sur ce site : Des mondes en pixel art sur iPhone est le premier billet de cette série, avec la recette RealityKit, la règle de capture et la limite juridique ; Des structures en pixel art : maisons, halls et intérieurs sur iPhone a construit la ville que mesure ce billet, lui a donné sa terrasse au build 35 et a refusé les rebords le premier ; Rendre hommage aux anciens Pokémon sans les copier a resserré ce refus et fixé la liste de ce à quoi la descente ne doit pas ressembler ; Routes en pixel art : connexions de cartes et quartiers sur iPhone a conçu la promenade des Prés dont les descentes remplacent le portillon de la haie ; Le mouvement en pixel art : marche, caméra et portes sur iPhone contient la marche sur laquelle repose la durée du saut ; Des personnages en pixel art : personnages et éditeur sur iPhone est le collectionneur qui saute ; et Xcode 27.1 beta : votre app dans le simulateur iPhone Duo couvre le simulateur et la pose Book dans laquelle s’exécute la vérification du pli.

Sources


  1. Mesure de l’auteur, 5 octobre 2026 : measure_gen3_elevation.py dans le dossier de preuves de l’auteur pour ce billet, sortie gen3_elevation.txt et gen3_elevation.json, sections E (rebords : chaque cellule portant un comportement MB_JUMP_*, par comportement, sur chaque agencement utilisé par une carte, une fois chacun, ce qui inclut les 77 pièces d’angle diagonales d’Émeraude, séparées des cellules qui se sautent dans la note 13 ; longueurs des rangées droites ; et pour chaque cellule de rebord droite ayant une cellule de chaque côté, les élévations de la cellule de départ, de la cellule de rebord et de la cellule de réception) et J (cellules portant un comportement MB_JUMP_* quelconque et leurs agencements par map_type, et les bourgs et villes qui en ont ; pour Rouge Feu, toutes se sautent, et les décomptes d’Émeraude par type de carte pour les cellules qui se sautent figurent dans la note 13). Entrées : pret pokeemerald à 731ad5b et pokefirered à 037335f, data/maps/*/map.json, data/layouts/layouts.json, le map.bin de chaque agencement (bits 0 à 9 metatile, 10 et 11 collision, 12 à 15 élévation) et le metatile_attributes.bin primaire ou secondaire, décodés avec le measure_gen3_routes.py du billet sur les routes. Après la relecture par le second moteur, le test de sol du script a été reconstruit à partir du test d’eau du moteur lui-même (note 7) ; les sections E et J n’en dépendent pas et sont inchangées, et le script a été relancé pour ce jet avec une sortie identique pour elles. ↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩

  2. Mesure de l’auteur, 5 octobre 2026, ajoutée après la relecture par le second moteur : astra_ledge_triples.py dans le dossier de preuves de l’auteur pour ce billet, sortie astra_ledge_triples.txt, avec le même décodeur et les trois mêmes cellules que la section E de measure_gen3_elevation.py (le départ derrière une cellule MB_JUMP_* droite, la réception au-delà). Les 944 cellules de rebord droites d’Émeraude ayant une cellule de chaque côté : 784 avec des élévations de départ et de réception égales, 132 avec une cellule de transition au départ ou à la réception, et 28 dont le départ et la réception se trouvent tous deux sur un niveau de sol et diffèrent, 22 d’entre elles (5, 0, 3) et 6 (3, 0, 5), à Nénucrique (8, dont le rebord sud en (48, 9), la cellule que désignait la relecture), sur la Route 115 (10), sur la Route 120 (2) et dans les zones nord (2) et sud (6) du Parc Safari, chacune avec un départ et une réception MB_NORMAL praticables ; les 1 042 de Rouge Feu : 984, 58 et 0. Relancé pour ce jet dans une copie de travail avec une sortie identique. ↩↩↩↩↩↩↩↩↩

  3. pret, pokeemerald/src/event_object_movement.c à 731ad5b, lu le 5 octobre 2026 : GetCollisionAtCoords (à partir de la ligne 4641 : d’abord les bits de collision de la cellule, puis IsElevationMismatchAt), IsElevationMismatchAt (à partir de la ligne 7673), sElevationToPriority (ligne 7695, 2, 2, 2, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 0, 0, 2, appliquée à partir de previousElevation à la ligne 7711), ObjectEventUpdateElevation (à partir de la ligne 7725, appelée via UpdateObjectEventElevationAndPriority au début et à la fin d’un pas, lignes 8075 et 8096), GetLedgeJumpDirection (lignes 7631 à 7654), InitJumpRegular appelant DoShadowFieldEffect (ligne 5423), sJumpY_High (ligne 8393), et les mises à jour de coordonnées et d’élévation propres au saut : InitJump (à partir de la ligne 5400) appelle ShiftObjectEventCoords au début du saut (ligne 5411), UpdateJumpAnim (à partir de la ligne 5428) l’appelle de nouveau à JUMP_HALFWAY (ligne 5442) et appelle ShiftStillObjectEventCoords à JUMP_FINISHED (ligne 5448), chacun levant le déclencheur d’effet de sol qui fait appeler UpdateObjectEventElevationAndPriority (ligne 7703) par DoGroundEffects_OnBeginStep (à partir de la ligne 8064) ou DoGroundEffects_OnFinishStep (à partir de la ligne 8085), si bien que le saut se termine par ObjectEventUpdateElevation attribuant au marcheur l’élévation de la cellule de réception (ligne 7733), sans aucun test de celle du départ, https://github.com/pret/pokeemerald/blob/master/src/event_object_movement.c. ↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩

  4. Calculs de l’auteur à partir des valeurs mesurées dans le texte : arith.py à côté du jet de ce billet, sortie arith.txt, qui lit les sorties du dossier de preuves de l’auteur pour ce billet. Il affiche : la fréquence d’images, 2^24 ÷ 280 896 = 59,7275 hertz ; les 32 images du saut en 0,5358 seconde et les 570 du téléphérique en 9,543 ; les escaliers de roche de Rouge Feu en 23 ÷ 16 = 1,4375 et 11 ÷ 8 = 1,375 ; les parts d’agencements extérieurs à un niveau de sol au plus (50 sur 68, 73,5 % ; 67 sur 76, 88,2 %) ; les paires de falaise sur l’ensemble des paires adjacentes (170 sur 61 197, 0,278 % ; 122 sur 61 461, 0,198 %) et les parts au même niveau (99,72 %, 99,80 %) ; les escaliers d’une ou deux cellules (73 sur 84, 86,9 %) et les cellules d’escalier de roche de Rouge Feu (49 sur 59, 83,1 %) ; les parts de direction des rebords (Émeraude, en comptant les cellules que le moteur fait sauter, sud 657 sur 946, 69,5 %, ouest 17,9 %, est 12,7 %, à côté de 77 pièces d’angle diagonales, 1 023 cellules portant un comportement de saut quelconque en tout ; Rouge Feu 962 sur 1 042, 92,3 % ; Rouge 709 sur 758, 93,5 % ; Cristal 964 sur 1 148, 84,0 %, 88,5 % avec les angles bas, qui se sautent) ; les cellules de rebord d’Émeraude qui se sautent par type de carte (routes 679 sur 21 agencements, souterrain 187, intérieur 48, Nénucrique 32) à côté des décomptes avec pièces d’angle (726, 215, 48, 34) ; les cellules à l’élévation 15 sous un comportement de pont (252 sur 523, 48,2 %) ; les cellules de sol extérieures d’Émeraude à 0 hors escaliers (2 258) ; les parts de départ et de réception égaux (784 sur 944, 83,05 % ; 984 sur 1 042, 94,43 %) ; les rangées médianes ; les parts de détour (269 sur 549, 49,0 % ; 299 sur 880, 34,0 %) et les médianes face aux 2 du saut ; les cellules de rebord des cinq villes de Rouge (119) ; les parts de pont (252 sur 702, 35,9 % ; 329 à 4 ; 121 à 0, 1 ou 3 ; types de couche 685 Normal et 17 Covered) ; les statistiques par rangée du graphisme des rebords (plage des huit rangées du haut des 15 tuiles orientées sud 130,1 à 204,5, valeurs les plus sombres 87,9 à 107,6 à la rangée 13 ou 14, moitié haute moins moitié basse 36,9 à 89,4, moyenne 169,4 sur la moitié haute et 112,7 sur la basse ; les 18 tuiles orientées ouest et est −14,4 à 21,8) ; et pour Kiradex, un saut de deux tuiles à 4 tuiles par seconde (0,5 seconde, 30 images à 60 hertz, 0,933 fois celui du canon), les arcs en 12 ÷ 16 et 10 ÷ 16, l’espacement des volées (7, 7, 7, 8), les secondes à 4 tuiles par seconde pour les trajets vers les portes (la halle 2,06, la boutique de cartes 5,02), le meilleur gain d’une descente (0,147) et le coût des volées extérieures (1,208), le gain de la passerelle (6,83 tuiles, 53,2 % ; 3,21 à 1,50 seconde), et l’échantillon du pré (400 sur 20^4 = 160 000, 0,25 %). Un saut de deux tuiles aux 16 ticks par tuile proposés par le billet sur le mouvement fait 2 × 16 = 32 ticks. Les lignes sur les cellules de rebord d’Émeraude qui se sautent, la part de pont à 15 et le sol à 0 hors escaliers ont été ajoutées après le quatrième tour de relecture, en lisant r4_corner_cells.txt ; deux lignes antérieures ont été réétiquetées comme comptant chaque cellule portant un comportement de saut, et le reste de la sortie est inchangé (l’ancien script et l’ancienne sortie sont conservés sous arith.pre-r4.py et arith.pre-r4.txt). Les lignes ajoutées après le premier tour de relecture (l’ancienne sortie est conservée sous arith.pre-r1.txt, et ses lignes sont inchangées) précisent leur vitesse : le code actuel, avec tilesPerSecond (4), runPace (1,6) et la règle de course à 6 pas lus dans PlazaRig.swift, une course nominale de 6,4 tuiles par seconde ; ou le cahier des charges du billet sur le mouvement, 16 ticks par tuile à la marche et 8 à la course, 23 et 12 pour une diagonale, à 60 ticks par seconde. Pour chronométrer un trajet, elles reparcourent les graphes de measure_kiradex_elevation.py et de probe_meadow_drops.py, importés en lecture seule, et décomposent chaque coût le plus court en pas droits, diagonales et descentes. Elles affichent : un pas de (0, 2) en l’état du code, 0,25 seconde à la marche et 0,156 à la course, et avec une longueur de 2, 0,5 et 0,3125 (30 images à 60 hertz à la marche), ou 32 et 16 ticks avec le cahier des charges du mouvement ; le canon à la course (8 images par cellule, le saut 16 images de plus que la course sur ses deux cellules, un gain seulement au-delà d’un détour de 4 cellules, ce qu’ont 239 des 280 rebords d’Émeraude avec détour et 485 des 581 de Rouge Feu) ; les sept trajets de l’arrivée aux portes en 7 à 18 pas, tous en courant, la halle en 1,29 seconde et la boutique de cartes en 3,14 à la course nominale (2,06 et 5,02 à la marche) ; les trajets que raccourcissent les descentes de 0,59 tuile, 19 à 29 pas, chacun gagnant 0,092 seconde à la course nominale avec la descente à l’allure de course, et perdant 0,096 avec un saut fixe de 0,5 seconde (4 ticks gagnés, ou 12 perdus, avec le cahier des charges du mouvement) ; la passerelle en x 4, 12 pas et 6, 2,00 secondes et 0,94 à la course nominale ; le retour du pré avec descentes, 51 pas simples et 4 descentes (aucun agencement tiré n’a de colonne traversant les quatre ouvertures), couru en 9,22 secondes avec les descentes à l’allure de course, le temps du portillon lui-même, ou en 9,97 avec des sauts fixes de 0,5 seconde, et en 472, 472 ou 536 ticks avec le cahier des charges du mouvement ; les agencements où ce retour n’est pas plus rapide que l’aller, 96 et 169 sur 400 avec un saut fixe et 0 et 0 avec le saut à l’allure de la démarche ; l’erreur de profondeur d’un z tiré d’un y soulevé, 0,5 ÷ (30 × 16) = 0,00104 par unité de monde, 0,0104 pour une élévation de 10 texels ; les attentes cumulées de HingeReads (0,1, 0,5, 1,5, 4,0 secondes) ; le mur entre les volées (6, 6, 6 et 7 tuiles, 2 à chaque extrémité, 29 en tout) ; et les 2 427 cellules de sol extérieures d’Émeraude à 0 face à ses 169 cellules d’escalier. Lignes ajoutées après la relecture par le second moteur (l’ancien script et l’ancienne sortie sont conservés sous arith.pre-astra.py et arith.pre-astra.txt ; les lignes d’escaliers et de paires ci-dessus ont bougé avec le recensement, et toutes les autres lignes antérieures sont inchangées) : le rapprochement du filtre de sol (1 851 cellules d’Émeraude sur lesquelles le filtre par nom et le test du moteur divergent, 668 d’entre elles à l’extérieur et 552 de celles-ci du sol selon le test du moteur ; 248 + 13 = 261 à l’élévation 15 et 300 + 706 = 1 006 à 4 ; les 1 182 cellules MB_NO_SURFACING que le filtre par nom avait classées en sol, aucune à l’extérieur ; les quatre escaliers qu’ajoute le filtre du moteur ; Rouge Feu 0) ; les classes de triplets de rebord calculées à partir de la section E et vérifiées par rapport à astra_ledge_triples.txt (Émeraude 784 égales, 132 avec une cellule de transition d’un côté, 28 reliant deux niveaux de sol ; Rouge Feu 984, 58, 0) ; PlazaRig.advance rejoué en Float32 à 60 hertz avec le dépassement jeté, 15 et 10 images par pas droit à la marche et à la course, 22 et 14 par diagonale, 30 et 19 par descente de deux tuiles (0,500 et 0,317 seconde), le retour du pré en 590 images par le portillon contre 586 avec descentes ; les 32 + 3 = 35 images de Rouge, 0,586 seconde, l’ancien décompte, que remplacent les dernières lignes ci-dessous ; et les chiffres de la grille reliée lus dans astra_meadow_joined.txt. Lignes ajoutées après la troisième lecture attentive (l’ancien script et l’ancienne sortie sont conservés sous arith.pre-cr3.py et arith.pre-cr3.txt ; toutes les lignes antérieures sont inchangées) : les 132 cellules de rebord à côté de transition selon ce que stocke la réception, à partir des triplets de la section E (3 pour 118, 1 pour 12, 0 pour 1, 5 pour 1), vérifiées par rapport à cr3_bridge_ledge_cells.txt, et les 549 cellules extérieures à départ ouvert en 521 + 28 ; les 450 cellules de pont qui ne sont pas multiniveaux en 329 + 69 + 47 + 4 + 1, par rapport aux 702 et 252 de la section D ; 552 = 300 + 248 + 4 ; les neuf comportements de pont ayant des cellules face aux onze du moteur, en cinq familles ; les différences des quatre agencements modifiés tirées de astra_meadow_joined.json, arrondies après la soustraction (1,66, 3,31, 1,66 et 2,49 tuiles), à côté du 1,65 que donne la soustraction des valeurs à deux décimales ; et la luminance moyenne par rangée des 15 tuiles orientées sud sur les huit rangées du haut, 162,9 à 175,5. Lignes ajoutées après les signalements des traducteurs (l’ancien script et l’ancienne sortie sont conservés sous arith.pre-t1.py et arith.pre-t1.txt ; chaque ligne antérieure est inchangée) : les escaliers de roche de Rouge Feu, 23 − 16 = 7 images de plus par pas à la marche, 0,117 seconde, et 11 − 8 = 3 à la course, 0,050 seconde, lus dans jump_timing.txt ; les volées de la terrasse d’après kiradex_elevation.txt, chaque écart étant mesuré du bord est d’une volée au bord ouest de la suivante, x 3 à 10, 10 à 17, 21 à 28 et 28 à 36, soit 7, 7, 7 et 8 tuiles ; et les cellules de rebord d’Émeraude par type de carte d’après r4_corner_cells.txt, celles qui se sautent (679, 187, 48, 32) face à toutes les cellules portant un comportement de saut (726, 215, 48, 34), routes, souterrain, intérieur et ville, avec des écarts de 47, 28, 0 et 2, 77 en tout. Lignes ajoutées après une troisième série de signalements (le script et la sortie d’avant sont conservés sous arith.pre-t1b.py et arith.pre-t1b.txt ; chaque ligne antérieure est inchangée) : le saut de Rouge compté par passage, 16 passages qui déplacent le joueur et 15 entrées de table lues, 32 images, et depuis le passage qui a pris la pression 32 + 2 + 3 = 37 images, 0,619 seconde, le 2 étant les appels à DelayFrame qui ouvrent le passage exécutant le nettoyage. ↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩

  5. Mesure de l’auteur, 5 octobre 2026 : measure_gen12_ledges.py dans le dossier de preuves de l’auteur pour ce billet, sorties gen12_ledges.txt et gen12_ledges.json, réutilisant les décodeurs de cellule du measure_gen12_routes.py du billet sur les routes. Rouge (pret pokered à d2704a6) : chaque carte dont l’en-tête nomme le jeu de tuiles OVERWORLD, 34 cartes, une tuile de 8 sur 8 par cellule (celle d’en bas à gauche) comparée à data/tilesets/ledge_tiles.asm, les cellules de rebord par direction et par rangée, et les 8 entrées de la table par direction. Cristal (pret pokecrystal à 5beda23) : les 167 cartes que lit le décodeur des routes, octets de collision par quadrant supposés en ordre ligne par ligne, les cellules HOP_* par type et les cellules à mur unilatéral UP_WALL, LEFT_WALL et RIGHT_WALL. Relancé pour ce jet avec une sortie identique. ↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩

  6. Mesure de l’auteur, 5 octobre 2026 : measure_jump_timing.py dans le dossier de preuves de l’auteur pour ce billet, sortie jump_timing.txt. Il lit par expression régulière et rejoue image par image : le PlayerJumpingYScreenCoords de Rouge (16 entrées, deux images chacune) ; les .y_offsets de Cristal dans engine/overworld/map_objects.asm (16 ticks de deux images) ; sJumpY_High et JUMP_DISTANCE_FAR d’Émeraude dans src/event_object_movement.c (32 images, un pixel par image, lu à timer >> 1) ; UpdateWalkSlowAnim et UpdateRunSlowAnim de Rouge Feu face à la marche et à la course normales ; et le src/cable_car.c d’Émeraude (le déplacement de la cabine par image, les délais de météo et le fondu au minuteur 570). Relancé pour ce jet avec une sortie identique. ↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩

  7. Mesure de l’auteur, 5 octobre 2026 : measure_gen3_elevation.py dans le dossier de preuves de l’auteur pour ce billet, sortie gen3_elevation.txt, sections A (histogrammes d’élévation sur chaque agencement utilisé par une carte et sur les cellules de sol des agencements extérieurs ; « extérieur » désigne un map_type ROUTE, TOWN, CITY ou OCEAN_ROUTE, « sol » une cellule de collision 0, qui n’est pas de l’eau selon le test du moteur lui-même et qui n’est pas à l’élévation 1, la valeur de surf, soit les trois mêmes tests dans le même ordre que dans le texte ; le script écarte aussi les comportements MB_JUMP_*, ce qui ne retire aucune cellule, puisque chaque cellule de rebord extérieure est stockée bloquée), B (niveaux de sol, élévations autres que 0, 1 et 15, par agencement extérieur), C (élévation 15 : fichiers d’agencement, cellules, agencements qui en ont le plus, et comportements en dessous), F (cellules de sol praticables 4-adjacentes à deux niveaux différents face aux paires au même niveau) et K (la classification du sol). Entrées comme pour la note 1. Le test d’eau est celui du moteur, lu dans le code C par l’utilitaire engine_terrain.py : dans Émeraude, MetatileBehavior_IsSurfableWaterOrUnderwater (src/metatile_behavior.c ligne 280) renvoie le bit TILE_FLAG_SURFABLE de sTileBitAttributes (lignes 9 à 128), 16 comportements ; dans Rouge Feu, MetatileBehavior_IsSurfable (ligne 204) lit sBehaviorSurfable (lignes 5 à 17), 11 ; l’ensemble des ponts est MetatileBehavior_IsBridgeOverWater (ligne 773), MetatileBehavior_IsFortreeBridge (ligne 1003) et la paire de bords du pont d’étang moyen de MetatileBehavior_GetBridgeType (ligne 788), dont la section K confirme qu’il s’agit des onze mêmes noms que ceux de l’en-tête. Le test de sol du premier jet reprenait le filtre par nom du billet sur les routes, qui qualifie un comportement d’eau quand son nom contient OCEAN ou POND (entre autres mots), si bien que les comportements de pont comptaient comme de l’eau et MB_NO_SURFACING et MB_UNUSED_6F comme du sol ; la relecture par le second moteur l’a repéré, et l’ancien script et les anciennes sorties sont conservés sous measure_gen3_elevation.pre-astra.py, gen3_elevation.pre-astra.txt et gen3_elevation.pre-astra.json. La section K liste les 1 851 cellules d’Émeraude des agencements utilisés sur lesquelles les deux tests divergent (668 à l’extérieur, dont 552 du sol selon le test du moteur) et les 0 de Rouge Feu. Le changement a fait passer le sol extérieur d’Émeraude à 0 de 2 423 à 2 427, à 4 de 706 à 1 006 et à 15 de 13 à 261, les paires au même niveau de 60 535 à 61 027 avec les 170 paires de falaise inchangées, et les escaliers de 80 à 84 (notes 8 et 10) ; les sections B, C, D, E, I et J et tous les chiffres de Rouge Feu sont inchangés. Le script indique C_all_layout_files_with_15: 13 of 441 pour Émeraude et 0 of 365 pour Rouge Feu. Ajoutés après les signalements des traducteurs, deux scripts qui importent celui-ci sans le modifier : t1_land_clauses.py (sortie t1_land_clauses.txt) établit que, parmi les cellules extérieures de collision 0 qui ne sont pas de l’eau, le test d’élévation en retire 885 dans Émeraude (dont 761 MB_MOUNTAIN_TOP et 46 MB_BRIDGE_OVER_OCEAN) et 10 dans Rouge Feu, et le test de rebord aucune, puisque les 760 cellules extérieures d’Émeraude portant un comportement de saut et les 942 de Rouge Feu sont toutes stockées bloquées, ce qui laisse les 41 193 et 36 981 cellules de sol que comptent les histogrammes ; et t1_elev15_cells.py (sortie t1_elev15_cells.txt) répartit chaque cellule à 15 par agencement entre cellules de pont et autres : à l’extérieur, 252 cellules de pont (Route 110 185, Route 120 47, Route 119 16, Cimetronelle 4) et 9 cellules MB_NORMAL (Route 119 6, Route 120 1, Bourg-en-Vol 2), toutes les 261 étant du sol. ↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩

  8. Mesure de l’auteur, 5 octobre 2026 : measure_gen3_elevation.py, section G, dans le dossier de preuves de l’auteur pour ce billet : les escaliers, définis comme des taches 4-connexes de cellules de sol praticables à l’élévation 0 qui touchent deux niveaux de sol ou plus, avec leurs rectangles englobants, leurs nombres de cellules, leurs comportements et les paires de niveaux qu’ils relient, sur chaque agencement extérieur d’Émeraude et de Rouge Feu. Entrées comme pour la note 1. Avec le test de sol du moteur (note 7), Émeraude compte 84 escaliers de 169 cellules, contre 80 de 161 dans le premier jet : les quatre ajoutés sont des taches de transition de deux cellules aux extrémités de ponts, Route 110 en (21, 13) et (28, 91), toutes deux MB_BRIDGE_OVER_OCEAN, et Route 120 en (7, 15) et (28, 15), toutes deux MB_NORMAL, chacune reliant les niveaux 3 et 4 ; aucun escalier n’a été retiré, et les 30 de Rouge Feu sont inchangés. ↩↩↩↩↩↩↩↩

  9. Mesure de l’auteur, 5 octobre 2026 : measure_gen3_elevation.py, section D, dans le dossier de preuves de l’auteur pour ce billet : chaque cellule portant un comportement de pont dans les agencements d’Émeraude, avec son élévation et le type de couche de son metatile ; Rouge Feu n’en signale aucune. Le dossier qui sous-tend ce billet donne les types de couche comme 683 Normal et 17 Covered ; la sortie du script totalise 685 Normal et 17 Covered, 702, et ce billet utilise le chiffre du script. ↩↩↩↩↩↩↩↩↩↩↩↩

  10. Mesure de l’auteur, 5 octobre 2026 : measure_gen3_elevation.py, section H, dans le dossier de preuves de l’auteur pour ce billet. Pour chacun des 84 escaliers d’Émeraude et des 30 de Rouge Feu de la note 8, une recherche en largeur sur des paires (cellule, élévation du marcheur) à partir d’une cellule du niveau le plus bas de l’escalier, sous deux règles : celle d’Émeraude (un pas est refusé quand l’élévation du marcheur n’est pas 0 et que celle de la cible n’est ni 0 ni 15 et diffère ; après le pas, l’élévation du marcheur est celle de la cible, sauf si la cible ou la cellule quittée est à 15) et l’esquisse du dossier moteur (autorisé si la hauteur est 0 ou si la cible est à 0, 15 ou à la même hauteur ; après le pas, la hauteur est inchangée sur 0 ou 15). Un escalier compte comme gravi si une cellule quelconque de son niveau le plus haut voisine de lui est atteinte. Sortie H_rule_test : la règle d’Émeraude en gravit 84 et 30, l’esquisse est bloquée sur 84 et 30 (80 et 30 avant le test de sol du moteur) ; les cinq premiers échecs de chaque jeu sont listés. ↩↩↩↩↩↩↩↩↩

  11. Mesure de l’auteur, 5 octobre 2026 : measure_kiradex_elevation.py dans le dossier de preuves de l’auteur pour ce billet, sortie kiradex_elevation.txt. Il n’ouvre que le Kiradex/Resources/World/town.json du dépôt Kiradex (40 sur 30, arrivée en (19, 13), l’heure de modification du fichier étant affichée à la première ligne de la sortie), en lecture seule, et le parcourt avec le graphe de l’app : huit mouvements, une diagonale coûtant √2 et autorisée seulement si les deux tuiles entre lesquelles elle passe sont praticables, selon les lettres de TileMap.Tile.isWalkable. Une descente est une arête à sens unique de la rangée 10 à la rangée 12 par-dessus la rangée de mur 11, coût 2. Sections : la rangée de mur et les tuiles praticables par niveau ; l’arrivée vers chaque porte et retour ; les emplacements candidats de descente et leur détour ; le gain de chaque descente seule et de rangées en x 4 à 6 et 30 à 33 sur les 16 trajets des quatre portes du haut vers l’arrivée et les trois portes du bas, et les trajets de remontée ; les rangées supérieures de toit, leur accessibilité et la règle de profondeur ; une passerelle nord-sud à chaque colonne de l’étang. Relancé pour ce jet avec une sortie identique, horodatage du fichier compris. Les trajets que raccourcit chaque descente seule sont affichés par t1_kiradex_trips.py, sortie t1_kiradex_trips.txt, ajouté après les signalements des traducteurs ; il importe ce script sans le modifier et affiche le même horodatage de fichier : en x 8 et 9, de la maison en (5, 6) aux portes du bas en (15, 20) et (24, 20) ; en x 16, de la maison en (5, 6) à la porte du bas en (24, 20) ; en x 22, de la maison en (31, 5) à la porte du bas en (15, 20) ; chacun de 0,59 tuile, trois trajets distincts en tout, et aucun trajet vers l’arrivée à aucun des 17 emplacements. ↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩

  12. pret, pokeemerald/src/field_player_avatar.c à 731ad5b, lu le 5 octobre 2026 : la vérification de rebord qui appelle GetLedgeJumpDirection (ligne 746), IncrementGameStat(GAME_STAT_JUMPED_DOWN_LEDGES) et le renvoi de COLLISION_LEDGE_JUMP (lignes 701 et 702), PlayerJumpLedge (ligne 1032, toujours le saut long) et PlaySE(SE_LEDGE) (ligne 1034) ; PlayerNotOnBikeMoving (à partir de la ligne 608), qui, sur COLLISION_LEDGE_JUMP, appelle PlayerJumpLedge et revient (lignes 614 à 617) avant son test du bouton B maintenu qui choisit PlayerRun (lignes 658 à 661), si bien que le saut d’un joueur qui court est le même saut ; la vérification de rebord s’exécute après GetCollisionAtCoords (ligne 695) et renvoie COLLISION_LEDGE_JUMP quelle qu’ait été cette collision, sauf si un surfeur met pied à terre (lignes 696 à 702), et ShouldJumpLedge (à partir de la ligne 744) est le seul appelant de GetLedgeJumpDirection, qui se trouve aux lignes 7631 à 7654 de src/event_object_movement.c : une table de quatre tests, un par direction droite, MetatileBehavior_IsJumpSouth, IsJumpNorth, IsJumpWest et IsJumpEast (src/metatile_behavior.c lignes 143 à 173, chacun reconnaissant un comportement), et DIR_NONE sinon, https://github.com/pret/pokeemerald/blob/master/src/field_player_avatar.c. ↩↩↩↩↩↩↩↩↩↩

  13. Mesure de l’auteur, 5 octobre 2026, ajoutée après le quatrième tour de relecture : r4_corner_cells.py dans le dossier de preuves de l’auteur pour ce billet, sortie r4_corner_cells.txt, avec le décodeur de troisième génération du billet sur les routes comme pour la note 1. (1) Chaque ligne de src/ et include/ de pokeemerald à 731ad5b et pokefirered à 037335f qui nomme un comportement MB_JUMP_*, une fonction MetatileBehavior_IsJump* ou GetLedgeJumpDirection : dans Émeraude, 31 lignes, et les quatre comportements diagonaux ne sont nommés que dans l’en-tête (lignes 65 à 68) et dans sTileBitAttributes (src/metatile_behavior.c lignes 56 à 59, dont l’indicateur TILE_FLAG_UNUSED est commenté « Set but never read » à la ligne 7) ; dans Rouge Feu, 23 lignes et aucun nom diagonal. (2) Chaque cellule d’Émeraude dont le metatile porte un comportement de saut, par comportement et bits de collision : dans les agencements utilisés par une carte, 657 sud, 120 est, 169 ouest, 33 sud-est et 44 sud-ouest, toutes à collision 1 ; sur l’ensemble des fichiers d’agencement, 78 cellules diagonales, toutes à collision 1. (3) Les cellules de rebord d’Émeraude comme cellules que le moteur fait sauter, les quatre comportements droits : 946 (sud 657, ouest 169, est 120, nord 0), 711 à l’extérieur ; par type de carte, routes 679 (21 agencements), souterrain 187 (16), intérieur 48 (4), ville 32 (1), bourg 0, à côté de 726, 215, 48, 34 et 0 avec les pièces d’angle. (4) Les 23 fichiers d’agencement comportant une cellule diagonale, dont Route101_Layout (une sud-est). (5) Rouge Feu : l’en-tête définit MB_JUMP_EAST à MB_JUMP_SOUTH de 0x38 à 0x3B et rien de 0x3C à 0x3F, et aucun de ses 10 903 metatiles ni aucune cellule de carte n’y porte de valeur. Relancé dans une copie de travail avec une sortie identique. ↩↩↩↩↩↩↩↩↩↩↩↩

  14. pret, pokecrystal/constants/collision_constants.asm à 5beda23, lu le 5 octobre 2026 : COLL_HOP_UP (ligne 95), COLL_HOP_UP_RIGHT et COLL_HOP_UP_LEFT (lignes 99 et 100), chacun marqué « ; unused » ; COLL_RIGHT_WALL, COLL_LEFT_WALL et COLL_UP_WALL (lignes 101 à 103), https://github.com/pret/pokecrystal/blob/master/constants/collision_constants.asm. ↩↩

  15. pret, pokeemerald/src/field_effect_helpers.c à 731ad5b, lu le 5 octobre 2026 : LoadObjectReflectionPalette et bridgeReflectionVerticalOffsets (lignes 75 à 95 : 12, 28 et 44 pixels pour les ponts d’étang bas, moyen et haut, appliqués en même temps que la palette du pont haut dès que MetatileBehavior_GetBridgeType renvoie un type d’étang, et la palette habituelle sans décalage pour le type 0, la mer) ; le commentaire des lignes 112 et 113 (« When walking on a bridge high above water (Route 120), the reflection is a solid dark blue color. This is so the sprite blends in with the dark water metatile underneath the bridge. », quand on marche sur un pont haut au-dessus de l’eau (Route 120), le reflet est d’un bleu foncé uni, afin que le sprite se fonde dans le metatile d’eau sombre sous le pont) ; UpdateShadowFieldEffect (ligne 249 : l’ombre au y du sprite lié plus sYOffset), https://github.com/pret/pokeemerald/blob/master/src/field_effect_helpers.c. ↩↩↩↩↩↩↩↩↩↩↩↩↩

  16. pret, pokeemerald/src/data/field_effects/field_effect_objects.h à 731ad5b (sPicTable_GroundImpactDust, trois images, et sAnim_GroundImpactDust, 8 ticks chacune, sur un sprite de 16 sur 8, lignes 278 à 305), src/event_object_movement.c (GroundEffect_JumpLandingDust, ligne 7961, l’effet de réception sur sol ordinaire), src/data/object_events/object_event_graphics_info.h (le shadowSize = SHADOW_SIZE_M du joueur) et graphics/field_effects/pics/shadow_medium.png (16 sur 8 pixels, lu dans son en-tête PNG), lus le 5 octobre 2026, https://github.com/pret/pokeemerald/blob/master/src/data/field_effects/field_effect_objects.h. ↩↩↩↩

  17. Blake Crosley, « Pixel-Art Routes: Map Connections and Districts on iPhone », blakecrosley.com, 5 octobre 2026 : section 1 (les vitesses de marche, 16 images par cellule dans les trois générations, et les tables de pas d’Émeraude, 8 entrées pour la course) ; section 2 (la recherche à la course, 8 images par cellule, chaque saut de rebord restant à 32 images, « because the hop is the same 32-frame jump at any gait », parce que le saut est le même saut de 32 images quelle que soit l’allure ; « Ledges shorten the way home » (les rebords raccourcissent le chemin du retour) : sur les neuf routes mesurées dont les extrémités se rejoignent à pied, le trajet vers la ville précédente est le plus court, les rebords de la Route 1 de Rouge, de la Route 1 de Rouge Feu et de la Route 101 d’Émeraude regardent tous vers la ville de départ, et la Route 29 de Cristal, dont les cellules de lèvre regardent surtout vers le sud en travers de la route, fait exception ; les 42 cellules de rebord de la Route 1 de Rouge ; les 12 cellules de rebord que le moteur peut faire sauter sur la Route 101 d’Émeraude, en trois rangées de quatre, sa pièce d’angle exclue depuis le 5 octobre 2026 ; les murs unilatéraux de Cristal et les 110, 132 et 128 cellules de la Route 32 ; le saut d’angle de côté ; « The elevation question » (la question de l’élévation), renvoyant les descentes à ce billet) ; section 7 (le cahier des charges : le graphe de marche à huit directions pour l’app et le serveur, une diagonale coûtant √2 et refusée au-delà d’une tuile bloquée ; les quatre haies de la promenade des Prés aux rangées 12, 24, 36 et 48 avec des ouvertures de 2 tuiles et son portillon ; le retour de 88,07 tuiles, la fourchette d’aller de 110 à 120 et les 4 111 agencements qui y tombent à 0,73 à 0,80 ; la vérification de parité serveur 12 ; la liste d’exclusion comme travail à faire ; le report des rebords), https://blakecrosley.com/blog/pixel-art-world-beyond-the-plaza. ↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩

  18. Dossier moteur de l’auteur pour le billet sur les structures, dépôt Kiradex docs/research/structures/02-structures-craft-and-engine.md, 3 octobre 2026 ; privé : section 3.4 (« Elevation and the walk rule », l’élévation et la règle de marche, « Only when a map needs a ledge, a terrace or a bridge », seulement quand une carte a besoin d’un rebord, d’une terrasse ou d’un pont ; l’esquisse de canStep(to:height:) et de height(after:was:), dont le commentaire dit « The walker’s height after the step: unchanged on a transition or a bridge. », la hauteur du marcheur après le pas : inchangée sur une transition ou un pont), section 3.5 (la hauteur dans le sol de la ville par élévation), et l’ordre de travail de la section 5, étape 10, « Elevation and ledges, only when a map uses them » (élévation et rebords, seulement quand une carte s’en sert). ↩↩↩↩↩↩

  19. Mesure de l’auteur, 5 octobre 2026 : measure_gen3_elevation.py, section I, dans le dossier de preuves de l’auteur pour ce billet : pour chaque cellule de rebord droite extérieure ayant du sol des deux côtés, le plus petit nombre de pas de sa cellule de départ à sa cellule de réception sans aucun rebord, dans quatre directions, sur le sol, selon la règle d’élévation d’Émeraude, à l’intérieur de la carte du rebord ; aucun quand un tel trajet n’existe pas. Les personnages, les objets, le surf, les vélos et les warps ne sont pas modélisés. Les quatre directions sont celles des jeux eux-mêmes : FieldGetPlayerInput dans src/field_control_avatar.c règle la direction du joueur sur le nord, le sud, l’ouest ou l’est (pret pokeemerald à 731ad5b, lignes 124 à 131 ; pokefirered à 037335f, lignes 148 à 154), lu le 5 octobre 2026. ↩↩↩↩↩↩↩↩↩↩↩

  20. Dossier de recherche de l’auteur, « Elevation, ledges and bridges: how 2D games build height, and what Kiradex should » (élévation, rebords et ponts : comment les jeux 2D construisent la hauteur, et ce que Kiradex devrait faire), compilé le 5 octobre 2026 : la méthode et les scripts de mesure, les faits clés (sa copie conserve les chiffres du premier jet, dont 1 023 cellules de rebord comptées par comportement, 683 couches de pont Normal et un reflet de 12 pixels, que les tours de relecture ont révisés comme l’indiquent les notes), les études de cas, les quinze règles, la section 4 (« The brief for Kiradex », le cahier des charges pour Kiradex, synthèse de l’auteur : la décision sur les rebords, la terrasse et les descentes, le saut, la rangée de toit, la passerelle, la hauteur différée et sa règle corrigée, le graphe de marche, le serveur et le pli, les neuf vérifications de recette et les refus) et la section 5 (« What is measured and what is not », ce qui est mesuré et ce qui ne l’est pas : les approximations, ce qui a été lu plutôt que mesuré, la recherche d’une déclaration sur Eastward qui n’a pas pu être lancée, l’absence de matériel iPhone Duo, et les constats concernant les billets publiés). Dépôt Kiradex docs/research/elevation/01-elevation.md ; privé, avec une copie dans les archives de recherche de l’auteur. ↩↩↩↩↩↩↩↩↩↩↩↩↩↩

  21. Mesure de l’auteur, 5 octobre 2026 : probe_meadow_drops.py dans le dossier de preuves de l’auteur pour ce billet, sortie meadow_drops.txt. Le pré seul, 24 sur 60 tuiles, d’un bord à l’autre, avec les murs ou haies du cahier des charges des routes aux rangées locales 12, 24, 36 et 48, chacun percé d’une ouverture de 2 tuiles dont la position, de 0 à 19, est tirée pour 400 agencements par le random.Random(6) de Python. Modèle du portillon : la colonne 21 est une haie de la rangée 0 à 58, l’allée occupe les colonnes 22 et 23, accessible depuis le bord nord, jamais quittée vers le nord par le portillon, ouverte sur le pré seulement à la rangée 59 ; les trajets aller partent à l’ouest de la haie. Modèle à descentes : les murs couvrent les 24 colonnes sauf l’ouverture, et les colonnes 22 et 23 de chaque mur portent des descentes de la rangée r − 1 à r + 1, coût 2, vers le sud seulement. Le graphe à huit directions de l’app, aller du bord sud au bord nord, retour du nord au sud. Les constantes d’agencement viennent du measure_meadow_gate.py du billet sur les routes. L’itinéraire complet de l’arrivée au ponton n’est pas modélisé ici ; la note 22 le modélise. ↩↩↩↩↩↩↩↩

  22. Mesure de l’auteur, 5 octobre 2026, ajoutée après la relecture par le second moteur : astra_meadow_joined.py dans le dossier de preuves de l’auteur pour ce billet, sorties astra_meadow_joined.txt et astra_meadow_joined.json. Il importe le measure_meadow_gate.py du billet sur les routes (la Grand-Place tirée de town.json avec sa clôture nord ouverte le long du bord commun, la promenade des Prés au décalage 4, le Bord du lac avec le ponton en tête d’allée, la marche à huit directions avec une diagonale à √2 refusée au-delà d’une tuile bloquée, et le modèle du portillon) et place la conception à descentes sur la même grille reliée : pas de haie d’allée, les quatre murs aux rangées 12, 24, 36 et 48 du pré sur les 24 colonnes sauf leur ouverture de 2 tuiles, les colonnes 22 et 23 de chaque mur étant des descentes à sens unique de la rangée du dessus à celle du dessous pour un coût de 2, et pas de portillon. Section 1, l’agencement que désignait la relecture, ouvertures (19, 1, 1, 17) : aller 114,15432893 avec le portillon et 111,66904756 avec les descentes, retour 88,07106781 dans les deux cas, l’itinéraire aller entrant dans le pré par la colonne globale 11 avec le portillon et 26 avec les descentes. Section 2, les 400 agencements tirés par la sonde : retour 88,07 sur tous dans les deux cas ; aller de 94,70 à 127,75 avec le portillon et de 92,21 à 123,27 avec les descentes, plus court avec les descentes pour 114 et plus long pour aucun ; 17 dans les fourchettes du cahier des charges des routes avec le portillon, dont 4 modifiés par les descentes, ouvertures (19, 1, 1, 17), (19, 0, 16, 15), (6, 17, 1, 16) et (17, 1, 19, 17), les quatre restant dans la fourchette d’aller. Section 3, chaque combinaison d’ouvertures (160 000, dix processus de travail, 430 secondes sur le Mac de l’auteur) : retour 88,07 sur toutes ; aller de 89,73 à 134,44 ; 17 846 entre 110 et 120 sans filtre de serpentement ; 5 912 dans la fourchette de serpentement de 78 à 90 (les mêmes 5 912 que le serpentement soit mesuré à l’ouest de la haie d’allée, comme le définit le billet sur les routes, ou sur les 24 colonnes du pré à descentes, les deux valeurs coïncidant sur chaque agencement), dont 4 607 dans la fourchette d’aller à 0,734 à 0,800 ; sur les 4 111 agencements acceptés par le portillon, aller inchangé pour 3 076, plus court pour 1 035 (jusqu’à 5,31 tuiles), plus long pour aucun, 4 103 encore dans la fourchette et 8 sous 110, le plus court à 109,67. Les sections 1 et 2 ont été relancées pour ce jet dans une copie de travail avec une sortie identique, hormis la ligne qui affiche la durée de la section 1 ; la section 3 a été exécutée une fois. ↩↩↩↩↩↩↩↩

  23. Mesure de l’auteur, 5 octobre 2026 : probe_kiradex_variants.py dans le dossier de preuves de l’auteur pour ce billet, sortie kiradex_variants.txt, avec la marche de measure_kiradex_elevation.py : (a) chaque trajet de porte à porte que modifie une rangée supérieure de toit praticable ; (b) les volées extérieures d’une tuile en x 3 et x 36 remplacées par des descentes, et, à titre de témoin, supprimées sans descente ; (c) les parterres de fleurs de la cour en rangée 12, x 12 à 15 et 23 à 26, pavés, avec des descentes au-dessus des six dont le départ est praticable (x 12, 14, 15, 23, 24 et 26), et, à titre de témoin, pavés sans descente ; totaux sur les 16 trajets de descente et les 16 de remontée. Relancé pour ce jet avec une sortie identique. ↩↩↩↩

  24. Code source de Kiradex, lu le 5 octobre 2026 (dépôt privé) : scripts/forge/town.py, la docstring du module (la liste des lettres, dont « W the terrace’s wall: the upper town stands a step above the lower, and this is the face of that step, seen from the lower side (build 35) », W le mur de la terrasse : la ville haute se trouve une marche au-dessus de la ville basse, et ceci est la face de cette marche, vue d’en bas (build 35), et « / a stair through the wall (plaza stone to the feet) », / un escalier qui traverse le mur (de la pierre de place sous les pieds) ; les deux niveaux « the width of the town with five flights through it », sur toute la largeur de la ville, traversés par cinq volées ; « Height is drawn, not simulated: the wall’s cells are blocked and the stairs are stone, so nothing about the feet changed », la hauteur est dessinée, pas simulée : les cellules du mur sont bloquées et les escaliers sont en pierre, donc rien n’a changé pour les pieds), et l’export Kiradex/Resources/World/town.json (40 sur 30, rangée 11 le mur), daté du 3 octobre 2026. ↩↩↩↩↩↩

  25. Blake Crosley, « Pixel-Art Structures: Houses, Halls and Interiors on iPhone », blakecrosley.com, 3 octobre 2026 : section 2 (l’élévation d’Émeraude et la table de priorités ; « thirteen of 441 layouts use any » cellules multiniveaux, treize agencements sur 441 en utilisent ; le pont de la Route 119 d’après le manuel de Porymap) ; la liste honnête (« The top roof row is blocked, not walkable as Emerald’s is », la rangée supérieure du toit est bloquée, non praticable comme dans Émeraude ; « the layer would draw it correctly, the letters forbid it », la couche le dessinerait correctement, ce sont les lettres qui l’interdisent ; la recherche (cellule, hauteur) du dossier moteur, « written for when a map wants one », écrite pour le jour où une carte en voudra une) ; la mise à jour du soir du 3 octobre (la ville à deux niveaux comme build TestFlight 35, commit 305118e) ; et la réponse de FAQ « Reserve per-cell elevation for terraces, ledges and bridges on the ground, where Emerald uses a transition value for stairs and a multi-level value for a bridge cell », réservez l’élévation par cellule aux terrasses, rebords et ponts au sol, https://blakecrosley.com/blog/pixel-art-structures-on-iphone. ↩↩↩↩↩↩

  26. Dossier de recherche de l’auteur pour le billet sur les structures, dépôt Kiradex docs/research/structures/01-structures-in-the-canon.md, 3 octobre 2026 ; privé : section 8.8 (« Free height », la hauteur libre : le coût de CrossCode et l’avertissement de son équipe, et « No ledges to jump, no climbing, no isometric », pas de rebords à sauter, pas d’escalade, pas d’isométrie) ; l’éditeur de cartes de CrossCode lu à cette occasion (height-map.service.ts dans le crosscode-map-editor de CCDirectLink, qui dessine la paroi de chaque niveau sur level.height / 16 rangées de tuiles, https://raw.githubusercontent.com/CCDirectLink/crosscode-map-editor/master/webapp/src/app/services/height-map/height-map.service.ts), non archivé de nouveau pour ce billet ; et son constat de l’absence de déclaration de développeur sur l’élévation d’Eastward. ↩↩↩↩↩

  27. Blake Crosley, « Honoring the Old Pokémon Games Without Borrowing Them », blakecrosley.com, 5 octobre 2026 : section 5 (les cellules de rebord d’Émeraude que le moteur peut faire sauter, par type de carte, selon la correction du 5 octobre 2026 : 679 sur 21 des 41 routes, 32 dans les villes, 187 en souterrain, 48 en intérieur, aucune dans les 7 bourgs, décomptes qui, dans la version publiée d’abord, comptaient chaque cellule portant un comportement de saut, 726, 34, 215 et 48 ; « In Hoenn, the town, where people live and the player arrives, never has one », à Hoenn, la ville, où vivent les gens et où arrive le joueur, n’en a jamais, phrase qui, dans la version publiée d’abord, se lisait « The town, where people live and the player arrives, never has one », la ville, où vivent les gens et où arrive le joueur, n’en a jamais ; le resserrement du refus du billet sur les structures, une descente qui « has no z axis, only a one-way edge in the walk graph », n’a pas d’axe z, seulement une arête à sens unique dans le graphe de marche) et la ligne « Must not resemble » (ne doit pas ressembler à) du cahier des charges (« a grass lip with a light top edge and a dark shadow line », une lèvre d’herbe au bord supérieur clair avec une ligne d’ombre sombre, l’animation du saut, le son), https://blakecrosley.com/blog/honoring-the-old-pokemon-games. ↩↩↩↩↩↩↩↩↩↩↩↩↩

  28. pret, clones superficiels de pokered à d2704a6 (commit du 22 septembre 2026), pokecrystal à 5beda23 (29 septembre 2026), pokeemerald à 731ad5b (1er octobre 2026) et pokefirered à 037335f (26 septembre 2026), conservés dans les archives de recherche de l’auteur, https://github.com/pret. ↩

  29. Mesure de l’auteur, 5 octobre 2026 : r3_jump_behaviors.py dans le dossier de preuves de l’auteur pour ce billet, sortie r3_jump_behaviors.txt. Il lit l’énumération des comportements de pokeemerald/include/constants/metatile_behaviors.h à 731ad5b (huit valeurs MB_JUMP_*, lignes 61 à 68 : est, ouest, nord, sud, nord-est, nord-ouest, sud-est, sud-ouest) et chaque data/tilesets/*/*/metatile_attributes.bin (70 jeux de tuiles, 16 698 metatiles ; le comportement est l’octet de poids faible, METATILE_ATTR_BEHAVIOR_MASK 0x00FF à la ligne 39 de include/global.fieldmap.h). Metatiles de saut : 232 en tout, 89 sud, 53 est, 51 ouest, 20 sud-est, 19 sud-ouest, et aucun nord, nord-est ou nord-ouest ; 33 dans le jeu de tuiles primaire partagé et 199 dans quatorze jeux de tuiles secondaires. ↩↩

  30. Mesure de l’auteur, 5 octobre 2026, ajoutée après la troisième lecture attentive : cr3_bridge_ledge_cells.py dans le dossier de preuves de l’auteur pour ce billet, sortie cr3_bridge_ledge_cells.txt, avec le décodeur des notes 1 et 7 et l’ensemble des ponts du moteur tiré de engine_terrain.py. La section 1 répartit les 702 cellules de pont d’Émeraude par collision, élévation et carte : 252 à 15, cellules de pont seulement (Route 110 185, Route 120 47, Route 119 16, Cimetronelle 4 ; la section C de la note 7 compte toutes les cellules à 15, pont ou non, et donne donc 48 pour la Route 120 et 22 pour la Route 119, la différence étant 1 et 6 cellules MB_NORMAL, listées par t1_elev15_cells.py, sortie t1_elev15_cells.txt, ajouté après les signalements des traducteurs) ; sur les 450 autres, 329 ouvertes à 4 (Route 110 294, Cimetronelle 23, Route 120 12), 69 stockées bloquées (toutes sur la Route 110, 68 à 0 et 1 à 3), 47 ouvertes à 1 (Route 110 46, Route 120 1), 4 ouvertes à 0 (Route 110 (21, 13), (22, 13), (28, 91) et (29, 91), les deux escaliers d’extrémité de pont de la note 8) et 1 ouverte à 3 (la Union Room, une carte intérieure) ; les seules valeurs de collision sont 0 et 1 ; les 27 de Cimetronelle sont 23 à 4 et 4 à 15. La section 2 prend les 944 cellules de rebord droites ayant une cellule de chaque côté (note 1) et vérifie si le départ est ouvert : 730 des 784 qui relient des élévations égales, les 28 qui relient deux niveaux de sol, et 4 des 132 ayant une cellule de transition d’un côté ; les 549 cellules extérieures à départ ouvert sont les 521 égales et les 28, la population dont la section I de measure_gen3_elevation.py calcule le détour. Sur les 132, la réception stocke 3 pour 118, 1 pour 12 (toutes sur la Route 118, chacune atterrissant sur MB_OCEAN_WATER), 0 pour 1 (Route Victoire 1F) et 5 pour 1 (la zone nord du Parc Safari) ; 128 ont un départ bloqué, et les 4 à départ ouvert atterrissent sur 3 dans l’arène de Cimetronelle (1), l’arène de Vermilava (2) et la Route Victoire B2F (1). Le test de rebord du moteur ne lit que le comportement de la cellule de rebord (GetLedgeJumpDirection, note 3) et jamais la collision de la cellule de réception, si bien que c’est un départ bloqué qui tient un marcheur à l’écart d’un rebord. Exécuté deux fois pour ce jet, dans le dossier de preuves et dans une copie de travail, avec une sortie identique. ↩↩↩↩↩↩

  31. pret, pokeemerald/include/global.fieldmap.h à 731ad5b, lu le 5 octobre 2026 : MAPGRID_ELEVATION_MASK 0xF000 // Bits 12-15 (ligne 9) et ELEVATION_TRANSITION = 0, ELEVATION_SURF = 1, ELEVATION_DEFAULT = 3, ELEVATION_MULTI_LEVEL = 15 (lignes 16 à 19) ; et les types de couche de metatile (lignes 50 à 52), METATILE_LAYER_TYPE_NORMAL (« Metatile uses middle and top bg layers », le metatile utilise les couches d’arrière-plan médiane et supérieure), METATILE_LAYER_TYPE_COVERED (« Metatile uses bottom and middle bg layers », le metatile utilise les couches d’arrière-plan inférieure et médiane) et METATILE_LAYER_TYPE_SPLIT, https://github.com/pret/pokeemerald/blob/master/include/global.fieldmap.h. ↩↩↩↩↩

  32. Manuel de Porymap, « Editing Map Collisions », archivé le 5 octobre 2026 sous porymap-collisions.txt dans le dossier de preuves de l’auteur pour ce billet (« Elevation is how the game determines whether or not an object is on the same level as something else » ; le type Transition, qui « allows the player to move between different elevations. The most common use case is for stairs » ; le type Multi-Level, qui « is used for bridges » et « remembers the player’s previous elevation »), https://huderlem.github.io/porymap/manual/editing-map-collisions.html. ↩↩↩

  33. pret, pokeemerald/src/metatile_behavior.c et include/metatile_behavior.h à 731ad5b, lus le 5 octobre 2026 : MetatileBehavior_GetBridgeType (à partir de la ligne 788 ; ses commentaires, MB_BRIDGE_OVER_POND_LOW « (Unused) », les ponts d’étang moyen et haut sur la Route 120, les ponts sur la mer sur les Routes 110 et 119 ; tout le reste renvoie BRIDGE_TYPE_OCEAN, que l’énumération de l’en-tête fixe à 0), https://github.com/pret/pokeemerald/blob/master/src/metatile_behavior.c. ↩↩

  34. pret, pokeemerald/include/constants/metatile_behaviors.h à 731ad5b, lu le 5 octobre 2026 : la liste des comportements, dont MB_STAIRS_OUTSIDE_ABANDONED_SHIP (ligne 32, que MetatileBehavior_IsNorthArrowWarp dans src/metatile_behavior.c, ligne 304, compte comme un warp), les huit comportements MB_JUMP_* aux lignes 61 à 68, et les comportements de pont à partir de MB_BRIDGE_OVER_OCEAN (ligne 117), https://github.com/pret/pokeemerald/blob/master/include/constants/metatile_behaviors.h. ↩↩↩↩

  35. pret, pokefirered/src/field_player_avatar.c à 037335f, lu le 5 octobre 2026 : PlayerIsMovingOnRockStairs (ligne 535 : vers le nord, il teste la cellule où l’on se tient, ligne 546, et vers le sud la cellule devant, ligne 549), qui choisit PlayerRunSlow (ligne 520) ou PlayerWalkSlow (ligne 529), https://github.com/pret/pokefirered/blob/master/src/field_player_avatar.c. ↩

  36. pret, pokered/engine/overworld/ledges.asm à d2704a6, lu le 5 octobre 2026 : HandleLedges (revient sauf si le jeu de tuiles est OVERWORLD ; compare l’orientation, la tuile où l’on se tient et la tuile devant à LedgeTiles ; exige la direction maintenue dans hJoyHeld ; règle wJoyIgnore sur toutes les touches, ligne 43, ce que _Joypad dans engine/joypad.asm applique aux touches maintenues, ligne 29 ; simule deux pressions ; LoadHoppingShadowOAM ; SFX_LEDGE), LedgeHoppingShadow (gfx/overworld/shadow.1bpp) et LedgeHoppingShadowOAMBlock (une tuile écrite quatre fois, telle quelle, retournée en X, retournée en Y et les deux), et data/tilesets/ledge_tiles.asm (la table), https://github.com/pret/pokered/blob/master/engine/overworld/ledges.asm. ↩↩↩↩↩↩↩↩↩

  37. pret, pokecrystal/engine/overworld/player_movement.asm à 5beda23, lu le 5 octobre 2026 : .Normal (à partir de la ligne 45 : .TryStep, puis .TryJump à la ligne 54 seulement si le pas a été refusé), .CheckTile (à partir de la ligne 113, qui lit wPlayerTileCollision pour les courants et les cascades sous le joueur), .TryJump (à partir de la ligne 354 : le quartet de poids fort de wPlayerTileCollision comparé à HI_NYBBLE_LEDGES, l’orientation combinée par ET avec .ledge_table à la ligne 383, qui associe COLL_HOP_UP et les angles hauts comme les autres, SFX_JUMP_OVER_LEDGE), https://github.com/pret/pokecrystal/blob/master/engine/overworld/player_movement.asm. ↩↩↩↩

  38. pret, pokecrystal/home/map.asm à 5beda23, lu le 5 octobre 2026 : GetMovementPermissions (à partir de la ligne 1511 ; sous le commentaire « get coords of current tile » de la ligne 1516, il lit wPlayerMapX et wPlayerMapY, appelle GetCoordTileCollision et range le résultat dans wPlayerTileCollision, dont l’object_struct de macros/ram.asm fait le champ de collision de tuile propre à l’objet joueur), https://github.com/pret/pokecrystal/blob/master/home/map.asm. ↩

  39. pret, pokered/engine/overworld/player_animations.asm à d2704a6, lu le 5 octobre 2026 : PlayerJumpingYScreenCoords (ligne 523), lu via wPlayerJumpingYScreenCoordsIndex (à partir de la ligne 492) ; .finishedJump (lignes 504 à 521 : revient tant que wWalkCounter n’est pas à 0, puis UpdateSprites, Delay3 (note 41), et efface hJoyHeld, hJoyPressed, hJoyReleased, l’index et l’indicateur de rebord, ainsi que wJoyIgnore à la ligne 520), https://github.com/pret/pokered/blob/master/engine/overworld/player_animations.asm. ↩↩

  40. pret, pokered/home/overworld.asm à d2704a6, lu le 5 octobre 2026 : OverworldLoop (à partir de la ligne 41 : DelayFrame aux lignes 42 et 44, HandleMidJump à la ligne 48 tant que l’indicateur de rebord est positionné), le compteur de marche d’un pas à 8 (lignes 264 et 265), décrémenté une fois par passage dans AdvancePlayerSprite (ligne 1445), et _HandleMidJump dans engine/overworld/player_animations.asm (à partir de la ligne 491 : l’index n’est enregistré que tant qu’il reste inférieur à 16, la table étant lue à l’ancien index). Suivi passage par passage après les signalements des traducteurs : au passage qui trouve le rebord, HandleLedges positionne l’indicateur de rebord à l’intérieur de CollisionCheckOnLand (ligne 1219), qui appelle ensuite quand même CheckTilePassable (ligne 1242) sur la tuile de rebord, et aucune tuile de rebord de data/tilesets/ledge_tiles.asm ne figure dans la liste des tuiles praticables du monde extérieur (Overworld_Coll, data/tilesets/collision_tile_ids.asm ligne 11), si bien que ce passage ne déplace rien ; les 16 passages suivants déplacent le joueur, les 15 premiers lisant les entrées 1 à 15 de la table et le seizième aucune ; le passage d’après, qui s’ouvre sur les deux mêmes appels à DelayFrame (les passages du saut se terminent sur jp OverworldLoop, ligne 251 pour le passage qui trouve le rebord et ligne 687, après CheckMapConnections, pour les autres), exécute le nettoyage : 32 + 2 + 3 = 37 images depuis le passage qui a pris la pression. https://github.com/pret/pokered/blob/master/home/overworld.asm. ↩↩

  41. pret, pokered/home/palettes.asm à d2704a6, lu le 5 octobre 2026 : Delay3 (ligne 14, sous le commentaire « Wait three frames to let the bg map fully update », attendre trois images pour que la carte d’arrière-plan se mette entièrement à jour, ld c, 3 et jp DelayFrames), https://github.com/pret/pokered/blob/master/home/palettes.asm. ↩

  42. pret, pokecrystal/engine/overworld/map_objects.asm (les .y_offsets du saut sous UpdateJumpPosition, ligne 1847) et pokecrystal/engine/overworld/movement.asm (JumpStep à partir de la ligne 748, qui appelle SpawnShadow à la ligne 762) à 5beda23, lus le 5 octobre 2026, https://github.com/pret/pokecrystal/blob/master/engine/overworld/movement.asm. ↩↩↩↩

  43. Mesure de l’auteur, 5 octobre 2026 : measure_ledge_art.py dans le dossier de preuves de l’auteur pour ce billet, sorties ledge_art.txt et ledge_art.png, sur pret pokeemerald à 731ad5b, data/tilesets/primary/general/ (tiles.png, les palettes JASC, metatiles.bin, metatile_attributes.bin) : les 33 metatiles portant un comportement MB_JUMP_* (27 droits : 9 sud, 9 ouest, 9 est ; et 6 pièces d’angle, 3 sud-ouest et 3 sud-est), leur type de couche (bits 12 à 15 de l’attribut) et la luminance moyenne de chaque rangée de pixels sur les pixels que dessinent les deux couches (couleur 0 transparente). Le rendu a été examiné pour ce jet : chaque tuile orientée sud est une surface d’herbe, de sable ou de terre au-dessus d’une lèvre de roche brune ; les entrées dessinées des tuiles utilisent les palettes 2, 3 et 5, parmi les six que possède un jeu de tuiles primaire (les 60 entrées portant la palette 0 sont toutes la tuile vide 0) (NUM_PALS_IN_PRIMARY 6, include/fieldmap.h ligne 8). Le rendu est dérivé d’un graphisme protégé par le droit d’auteur, ne sert qu’à l’analyse et n’est pas publié ; ce billet n’en trace que les chiffres. ↩↩↩↩↩↩

  44. pret, pokeemerald/src/field_camera.c et src/overworld.c à 731ad5b, lus le 5 octobre 2026 : DrawMetatile (à partir de la ligne 245 ; le cas Covered, ligne 268, place la couche inférieure sur BG3 et la supérieure sur BG2, le cas Normal, ligne 287, l’inférieure sur BG2 et la supérieure sur BG1, « which covers object event sprites », qui recouvre les sprites des événements d’objet) et sOverworldBgTemplates (à partir de la ligne 266 de overworld.c : BG1 en priorité 1, BG2 en 2, BG3 en 3), https://github.com/pret/pokeemerald/blob/master/src/field_camera.c. ↩↩

  45. Martin Korth, GBATEK, l’attribut d’OBJ « Priority relative to BG » (« In case that the ‘Priority relative to BG’ is the same than the priority of one of the background layers, then the OBJ becomes higher priority and is displayed on top of that BG layer », si la priorité relative à l’arrière-plan est égale à celle d’une des couches d’arrière-plan, l’OBJ devient prioritaire et s’affiche par-dessus cette couche), archivé le 4 octobre 2026 sous gbatek.txt dans le dossier de preuves du billet sur les routes, https://problemkaputt.de/gbatek.htm. Une référence matérielle, pas du code pret : la règle d’égalité est celle de la console, et les phrases du billet sur l’ordre d’affichage reposent sur elle. ↩↩↩

  46. pret, pokeemerald/src/field_tasks.c à 731ad5b, lu le 5 octobre 2026 : la tâche du pont de Cimetronelle (lignes 505 à 562 : le commentaire « Make sure player isn’t below bridge » à la ligne 525, le test d’élévation paire, PlaySE(SE_BRIDGE_WALK) à la ligne 532, le commentaire BUGFIX sur les sections de pont qui ne s’enfoncent pas depuis un autre sol, et tBounceTime = 16 à la ligne 561), https://github.com/pret/pokeemerald/blob/master/src/field_tasks.c. ↩↩↩↩↩

  47. pret, pokeemerald/src/cable_car.c à 731ad5b, lu le 5 octobre 2026 : le fondu à timer == 570 (ligne 455) et les délais de météo de 350 et 265 images (lignes 837 et 865), https://github.com/pret/pokeemerald/blob/master/src/cable_car.c. ↩↩↩

  48. everything8215, désassemblage ff6, notes/field-ram.txt, archivé le 5 octobre 2026 sous ff6-field-ram.txt dans le dossier de preuves de l’auteur pour ce billet (propriétés de tuile : « tile uses up/left movement (stairs) », « up/right movement (stairs) », l’indicateur de pont « not active for bridge tiles », « passable on lower z-level », « passable on upper z-level », et « if both of these are set, this tile can be a transition between upper and lower »), https://github.com/everything8215/ff6/blob/main/notes/field-ram.txt. ↩

  49. snesrev, réimplémentation zelda3, src/player.c, archivé le 5 octobre 2026 sous zelda3-player.txt dans le dossier de preuves de l’auteur pour ce billet (Dungeon_HandleLayerChange, sa ligne 89 ; l’attribut lu avec link_is_on_lower_level ? 0x1000 : 0 dans PushBlock_GetTargetTileFlag, sa ligne 3798, et le même décalage dans le test d’éclaboussure du marteau, sa ligne 4478 ; la bascule par l’escalier, sa ligne 2319 ; la détection de tuiles de la réimplémentation n’a pas été lue), https://github.com/snesrev/zelda3/blob/master/src/player.c. Code de réimplémentation, sans source rédigée. ↩↩

  50. Radical Fish Games (lachsen), « CrossQuestion: Why do we use auto jump in CrossCode? », publié le 29 septembre 2013, avec le commentaire de lachsen du 4 octobre 2013, archivé le 5 octobre 2026 sous crosscode-1168.txt dans le dossier de preuves de l’auteur pour ce billet, https://www.radicalfishgames.com/?p=1168. ↩↩↩↩↩↩

  51. Radical Fish Games (lachsen), « Path Finding in CrossCode », publié le 28 avril 2013 (« jump-up-edges » et « jump-down-edges »), archivé le 5 octobre 2026 sous crosscode-498.txt dans le dossier de preuves de l’auteur pour ce billet, https://www.radicalfishgames.com/?p=498. ↩

  52. Screen Rant, interview de Thierry Boulanger, de Sabotage Studio, sur Sea of Stars, 29 août 2023, archivée le 5 octobre 2026 sous seaofstars-screenrant.txt dans le dossier de preuves de l’auteur pour ce billet, https://screenrant.com/sea-stars-interview-thierry-boulanger/. ↩↩↩

  53. Code source de Kiradex, Kiradex/World/TileMap.swift, lu le 5 octobre 2026 (dépôt privé) : Tile et ses cas et lettres praticables (lignes 25 à 55) ; depth(atWorldY:) (ligne 122, 1 + (1 - y / (Float(height) * Self.tileSize)) * 0.5) et depth(ofObjectWithBase:) (ligne 127, la profondeur de la rangée de base moins 0,001) ; path(from:to:) (à partir de la ligne 325 : renvoie [SIMD2<Int>], les tuiles à traverser, et aucun coût ; huit mouvements, une diagonale coûtant Float(2).squareRoot() et ignorée sauf si les deux tuiles entre lesquelles elle passe sont praticables). ↩↩↩↩↩↩↩↩↩

  54. Code source de Kiradex, Kiradex/World/PlazaRig.swift, au commit 334fbfe, lu le 5 octobre 2026 (dépôt privé ; l’arborescence de travail était en cours de réécriture ce jour-là, et ces lignes sont celles du commit, décodées depuis son magasin d’objets) : la classe Walker (ligne 19 : son entity, la silhouette, et le commentaire sur son shadow, « The blob under the feet, a child of the figure. ») ; tilesPerSecond à 4 (ligne 101) et runPace à 1,6 (ligne 122) ; la recherche de chemin appelée pour planifier chaque trajet (lignes 528 et 608) ; walk(to:) qui fixe running = steps.count >= 6 (ligne 614) ; shade (à partir de la ligne 389 : l’ombre est un plan ModelEntity de 12 sur 4, ajouté comme enfant de l’entité du marcheur à la ligne 394) ; advance (à partir de la ligne 652 : la longueur √2 pour un pas en diagonale et 1 pour tout autre, ligne 659, et la progression avancée de dt × tilesPerSecond × (running ? runPace : 1) ÷ length, ligne 660, vers un point au sol interpolé entre les centres des deux tuiles, ligne 670) ; animate (l’image fixée comme matériau propre de l’entité du marcheur, ligne 716) ; place (à partir de la ligne 722 : x et y arrondis, z tiré de map.depth(atWorldY:) du point au sol, ligne 724) ; et follow (à partir de la ligne 733 : « Half open, the player is kept clear of the fold: at the centre of the wider side of it, not of the view », à demi ouvert, le joueur est tenu à l’écart du pli : au centre de son côté le plus large, et non de la vue). ↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩

  55. Blake Crosley, « Pixel-Art Motion: Walks, Cameras and Doors on iPhone », blakecrosley.com, 5 octobre 2026 : les règles de son cahier des charges, une marche à 1 pixel par tick, 16 ticks par tuile, 3,75 tuiles par seconde, et une course à 2 pixels par tick, 8 ticks par tuile, en conservant la règle actuelle selon laquelle un chemin de 6 pas ou plus se fait en courant, avec un pas en diagonale de 23 ticks à la marche et 12 à la course ; et son modèle du code actuel, où la course prend 10 images par tuile à 60 hertz, 6,00 tuiles par seconde là où 4 fois 1,6 donnerait 6,4, « because each tile’s overshoot is thrown away » (parce que le dépassement de chaque tuile est jeté), https://blakecrosley.com/blog/pixel-art-motion-on-iphone. ↩↩↩↩↩

  56. Documentation Apple Developer, « Preparing your app for iPhone Duo », archivée le 5 octobre 2026 sous apple-prepare-duo.txt dans le dossier de preuves de l’auteur pour ce billet (« a reserved region that represents the fold is active when iPhone Duo is partially open, but inactive when it is fully open » ; « Identify elements or controls in your views that appear in the fold, and are difficult to see or interact with. »), https://developer.apple.com/documentation/technologyoverviews/preparing-your-app-for-iphone-duo. ↩↩↩

  57. Documentation Apple Developer, GeometryProxy.reservedRegions(kind:options:layoutDirectionBehavior:), archivée le 5 octobre 2026 sous apple-reservedregions.txt dans le dossier de preuves de l’auteur pour ce billet (« Returns an array of reserved regions that match the selection options you specify » ; le type division, « An area where content splits into separate regions, such as at the fold of a hinge. » ; disponibilité iOS 27.1+ et iPadOS 27.1+, marqués bêta, Mac Catalyst, macOS, tvOS, visionOS et watchOS 27.1+), https://developer.apple.com/documentation/swiftui/geometryproxy/reservedregions(kind:options:layoutdirectionbehavior:). ↩↩

  58. Blake Crosley, « Pixel-Art Worlds on iPhone: What the 16-Bit Masters Knew », blakecrosley.com, 3 octobre 2026 : la recette RealityKit (une caméra orthographique à pixels entiers par texel, des matériaux non éclairés et découpés), la règle de capture (les images RealityKit sur le simulateur d’iPhone Duo ne sont fidèles que capturées depuis l’intérieur du bundle de test, XCUIScreen.screens[1]), et la FAQ juridique avec la Circular 33 du Copyright Office américain, https://blakecrosley.com/blog/pixel-art-world-on-iphone. ↩↩↩↩

  59. Code source de Kiradex, lu le 5 octobre 2026 (dépôt privé) : Kiradex/World/PlazaClient.swift, moved(to:facing:) (à partir de la ligne 174, qui envoie ["t": "move", "tile": [tile.x, tile.y], "facing": facing] à la ligne 177, une fois par tuile franchie) ; server/app/main.py, _tile (à partir de la ligne 107 : une liste de deux entiers praticable, sans vérification de contiguïté) et le gestionnaire move (à partir de la ligne 220 : une tuile et une orientation valides, et player.may_move(now)) ; server/app/rooms.py, WALKABLE = set("gtpTBFsEH") (ligne 23) et Plaza.path (à partir de la ligne 52, en largeur sur quatre mouvements ; sa docstring, « the same walk the app takes »). ↩↩↩↩↩↩

  60. Documentation Apple Developer, View.onHingeChange(isEnabled:_:), archivée le 5 octobre 2026 sous apple-onhingechange.txt dans le dossier de preuves de l’auteur pour ce billet (« Adds an action to perform when the hinge context of the view hierarchy changes. » ; iOS 27.1+ et iPadOS 27.1+, marqués bêta, et les mêmes autres plateformes), https://developer.apple.com/documentation/swiftui/view/onhingechange(isenabled:_:). ↩

  61. Apple, Human Interface Guidelines, « Designing for iPhone Duo », archivé le 5 octobre 2026 sous apple-hig-duo.txt dans le dossier de preuves de l’auteur pour ce billet (« Avoid extreme layout changes as people fold the device. »), https://developer.apple.com/design/human-interface-guidelines/designing-for-iphone-duo. ↩↩

  62. Code source de Kiradex, Kiradex/World/WorldHUD.swift, lu le 5 octobre 2026 (dépôt privé) : Fold.read (à partir de la ligne 154 : proxy.reservedRegions(kind: .division).first(where: \.isActive)?.frame derrière #if canImport(SwiftUI, _version: 8.0.85) et #available(iOS 27.1, *), avec le commentaire « Reserved regions are in the 27.1 SDK only; a build from the 27.0 SDK the App Store takes sees no fold » ; le commentaire du type, « The region arrives a few layouts after the hinge moves ») et HingeReads (à partir de la ligne 169 : onHingeChange à la ligne 178, puis une boucle, lignes 180 et 181, qui dort successivement 0,1, 0,4, 1,0 et 2,5 secondes et lit après chaque sommeil). ↩↩

  63. Blake Crosley, « Xcode 27.1 Beta: Your App in the iPhone Duo Simulator », blakecrosley.com, 21 septembre 2026, corrigé le 2 octobre 2026 (les poses Closed, Book et Open du Device Hub ; sur l’écran intérieur ouvert, « an inactive division 40 points wide down the middle that turns active in the Book pose », une division inactive de 40 points de large au milieu, qui devient active dans la pose Book), https://blakecrosley.com/blog/xcode-27-1-beta-iphone-duo-simulator. ↩↩

  64. Code source de Kiradex, lu le 5 octobre 2026 (dépôt privé) : scripts/forge/props.py (wall_face, ligne 159 ; stair, ligne 202) ; scripts/forge/rig.py (aucune image de bond, de saut ou d’accroupissement) ; scripts/forge/buildings.py (les cellules blocked de la fiche de bâtiment, ligne 189, chaque cellule opaque sauf la porte) ; et scripts/forge/town.py (la passe des bois, lignes 455 à 476, qui écrit ^ « reserved for the canopy » (réservé à la canopée) et le remplace par . avant que les rangées soient renvoyées ; swift_rows à partir de la ligne 479, les lettres exportées, dans lesquelles ^ n’apparaît pas). ↩↩↩↩

Articles connexes

Routes en pixel art : connexions de cartes et quartiers sur iPhone

Comment Pokémon, Stardew et Animal Crossing bâtissent l'entre-villes, mesuré dans le code : routes, raccords, postes, ca…

140 min de lecture

Des structures en pixel art : maisons, halls et intérieurs sur iPhone

Comment Pokémon, les RPG SNES et Stardew bâtissent maisons, intérieurs et étages, mesuré dans le code, et comment la vil…

102 min de lecture

Préparer votre app pour l'iPhone Duo : un exemple complet

Préparer et soumettre une app pour l'iPhone Duo : le tampon de SDK qui active la mise en page, une vraie app dans chaque…

93 min de lecture