# Ce qui se cache derrière unwind, notre casse-tête en ligne

> Un casse-tête en ligne simple à prendre en main, et derrière, des graphes, du ray casting et 5 000 niveaux générés. Les coulisses d'unwind.

16 novembre 2026

Des flèches, un plateau, un ordre à trouver. Derrière ce casse-tête qui se prend en main en quelques secondes, il y a des graphes, des rayons et un générateur conçu pour que chacun de ses 5 000 niveaux ait une solution.

9 min de lecture

![Un plateau d'unwind en cours de partie, une flèche bleue libre et son rayon en pointillés jusqu'au bord, une flèche rouge bloquée à côté](https://agencetwini.fr/media/2026/11/twini-article-unwind-partie-bf3870f2-1920.webp)

Nous avons conçu unwind, un casse-tête en ligne qui s'installe aussi sur un téléphone comme une application. C'est un puzzle de flèches. Elles couvrent un plateau, chacune peut glisser hors du plateau dans la direction qu'elle indique, à condition que rien ne lui barre la route. Il faut trouver l'ordre qui les libère toutes, et chaque flèche touchée alors qu'elle était bloquée coûte l'un des trois cœurs de la partie.

Afficher des flèches était la partie facile. Le vrai travail consistait à produire automatiquement des milliers de niveaux qui aient tous une solution, qui remplissent le plateau, qui ne se ressemblent pas et qui restent agréables à jouer. C'est cette partie invisible que nous racontons ici, code à l'appui.

## Un casse-tête en ligne, sans moteur de jeu

Le jeu n'utilise ni Unity ni Phaser. Il tient en un peu plus de 4 000 lignes de TypeScript, écrites avec les outils que nous employons chaque jour pour nos sites, et pèse environ 55 Ko une fois compressé, Vue compris.

- **Vue 3 et TypeScript** pour les écrans, la carte des niveaux, les réglages et les thèmes.
- **Le Canvas 2D du navigateur** pour le plateau, rendu une seule fois par image même quand le doigt pince, zoome et fait glisser.
- **Vite et vite-plugin-pwa** pour construire le site et l'installer sur un téléphone, avec un service worker qui le garde disponible hors connexion.
- **La Web Audio API** pour des sons qui se superposent quand plusieurs flèches sortent à la suite.
- **Plausible**, hébergé par nos soins, pour une mesure d'audience sans cookie.

Aucun serveur de jeu. Le site entier se résume à des fichiers statiques, et la progression du joueur reste dans son navigateur.

## Comment savoir si une flèche peut sortir du jeu ?

Le jeu lance un rayon depuis la pointe de la flèche, case après case, jusqu'au bord du plateau. Si le rayon atteint le bord sans rien rencontrer, la flèche est libre. S'il touche une autre flèche, elle est bloquée. C'est ce que les développeurs appellent le ray casting, la technique qui permettait déjà aux premiers jeux en trois dimensions de savoir ce que le joueur avait devant lui.

Le plateau garde une carte des cases occupées, qui dit en une seule lecture quelle flèche se trouve sur une case. Un rayon coûte donc au plus la largeur du plateau, et le jeu peut se poser la question pour toutes les flèches, à chaque coup.

src/game/board.ts

TypeScript

```
<span class="code-line"><span class="tok-keyword">const</span> <span class="tok-type">DIRECTIONS</span> <span class="tok-punctuation">=</span> <span class="tok-punctuation">{</span></span><span class="code-line">  up<span class="tok-punctuation">:</span> <span class="tok-punctuation">{</span> dx<span class="tok-punctuation">:</span> <span class="tok-number">0</span><span class="tok-punctuation">,</span> dy<span class="tok-punctuation">:</span> <span class="tok-punctuation">-</span><span class="tok-number">1</span> <span class="tok-punctuation">}</span><span class="tok-punctuation">,</span></span><span class="code-line">  down<span class="tok-punctuation">:</span> <span class="tok-punctuation">{</span> dx<span class="tok-punctuation">:</span> <span class="tok-number">0</span><span class="tok-punctuation">,</span> dy<span class="tok-punctuation">:</span> <span class="tok-number">1</span> <span class="tok-punctuation">}</span><span class="tok-punctuation">,</span></span><span class="code-line">  left<span class="tok-punctuation">:</span> <span class="tok-punctuation">{</span> dx<span class="tok-punctuation">:</span> <span class="tok-punctuation">-</span><span class="tok-number">1</span><span class="tok-punctuation">,</span> dy<span class="tok-punctuation">:</span> <span class="tok-number">0</span> <span class="tok-punctuation">}</span><span class="tok-punctuation">,</span></span><span class="code-line">  right<span class="tok-punctuation">:</span> <span class="tok-punctuation">{</span> dx<span class="tok-punctuation">:</span> <span class="tok-number">1</span><span class="tok-punctuation">,</span> dy<span class="tok-punctuation">:</span> <span class="tok-number">0</span> <span class="tok-punctuation">}</span><span class="tok-punctuation">,</span></span><span class="code-line"><span class="tok-punctuation">}</span> <span class="tok-keyword">as</span> <span class="tok-keyword">const</span> <span class="tok-keyword">satisfies</span> <span class="tok-type">Record</span><span class="tok-punctuation"><</span><span class="tok-type">Direction</span><span class="tok-punctuation">,</span> <span class="tok-type">Vector</span><span class="tok-punctuation">></span></span><span class="code-line"></span><span class="code-line"><span class="tok-comment">/** Les cases que voit une flèche, de sa pointe jusqu'au bord, une à une et à la demande. */</span></span><span class="code-line"><span class="tok-keyword">function</span><span class="tok-punctuation">*</span> <span class="tok-call">ray</span><span class="tok-punctuation">(</span>board<span class="tok-punctuation">:</span> <span class="tok-type">Board</span><span class="tok-punctuation">,</span> <span class="tok-punctuation">{</span> head<span class="tok-punctuation">,</span> direction <span class="tok-punctuation">}</span><span class="tok-punctuation">:</span> <span class="tok-type">Arrow</span><span class="tok-punctuation">)</span><span class="tok-punctuation">:</span> <span class="tok-type">Generator</span><span class="tok-punctuation"><</span><span class="tok-type">Cell</span><span class="tok-punctuation">></span> <span class="tok-punctuation">{</span></span><span class="code-line">  <span class="tok-keyword">const</span> <span class="tok-punctuation">{</span> dx<span class="tok-punctuation">,</span> dy <span class="tok-punctuation">}</span> <span class="tok-punctuation">=</span> <span class="tok-type">DIRECTIONS</span><span class="tok-punctuation">[</span>direction<span class="tok-punctuation">]</span></span><span class="code-line">  <span class="tok-keyword">let</span> row <span class="tok-punctuation">=</span> head<span class="tok-punctuation">.</span>row <span class="tok-punctuation">+</span> dy</span><span class="code-line">  <span class="tok-keyword">let</span> col <span class="tok-punctuation">=</span> head<span class="tok-punctuation">.</span>col <span class="tok-punctuation">+</span> dx</span><span class="code-line"></span><span class="code-line" data-marked="">  <span class="tok-keyword">while</span> <span class="tok-punctuation">(</span>board<span class="tok-punctuation">.</span><span class="tok-call">contains</span><span class="tok-punctuation">(</span>row<span class="tok-punctuation">,</span> col<span class="tok-punctuation">)</span><span class="tok-punctuation">)</span> <span class="tok-punctuation">{</span></span><span class="code-line" data-marked="">    <span class="tok-keyword">yield</span> <span class="tok-punctuation">{</span> row<span class="tok-punctuation">,</span> col <span class="tok-punctuation">}</span></span><span class="code-line">    row <span class="tok-punctuation">+=</span> dy</span><span class="code-line">    col <span class="tok-punctuation">+=</span> dx</span><span class="code-line">  <span class="tok-punctuation">}</span></span><span class="code-line"><span class="tok-punctuation">}</span></span><span class="code-line"></span><span class="code-line"><span class="tok-comment">/** Une flèche est bloquée si son rayon croise une autre flèche avant le bord. */</span></span><span class="code-line"><span class="tok-keyword">export</span> <span class="tok-keyword">function</span> <span class="tok-call">isBlocked</span><span class="tok-punctuation">(</span>board<span class="tok-punctuation">:</span> <span class="tok-type">Board</span><span class="tok-punctuation">,</span> arrow<span class="tok-punctuation">:</span> <span class="tok-type">Arrow</span><span class="tok-punctuation">)</span><span class="tok-punctuation">:</span> <span class="tok-type">boolean</span> <span class="tok-punctuation">{</span></span><span class="code-line" data-marked="">  <span class="tok-keyword">return</span> <span class="tok-call">ray</span><span class="tok-punctuation">(</span>board<span class="tok-punctuation">,</span> arrow<span class="tok-punctuation">)</span><span class="tok-punctuation">.</span><span class="tok-call">some</span><span class="tok-punctuation">(</span><span class="tok-punctuation">(</span>cell<span class="tok-punctuation">)</span> <span class="tok-punctuation">=></span> board<span class="tok-punctuation">.</span><span class="tok-call">occupantAt</span><span class="tok-punctuation">(</span>cell<span class="tok-punctuation">)</span> <span class="tok-punctuation">!==</span> <span class="tok-literal">undefined</span><span class="tok-punctuation">)</span></span><span class="code-line"><span class="tok-punctuation">}</span></span>
```

Le rayon est un générateur, parcouru case après case. some() s'arrête à la première flèche rencontrée, le reste du rayon n'est jamais calculé.

Une fois tous les rayons tracés, le plateau devient un graphe, un ensemble de points reliés entre eux. Chaque flèche en est un point, relié à celles qui lui barrent la route. Résoudre un niveau revient à parcourir ce graphe dans le bon ordre, en commençant par les flèches que rien ne retient.

- ![Une chaîne. Le rayon de C atteint le bord, C sort la première, puis B, puis A.](https://agencetwini.fr/media/2026/11/twini-article-unwind-chaine-d1248d7b-800.webp)

Une chaîne. Le rayon de C atteint le bord, C sort la première, puis B, puis A.
- ![Un cycle. A attend B, qui attend C, qui attend D, qui attend A. Aucune ne sortira.](https://agencetwini.fr/media/2026/11/twini-article-unwind-cycle-25fa4746-800.webp)

Un cycle. A attend B, qui attend C, qui attend D, qui attend A. Aucune ne sortira.

## Pourquoi un niveau peut-il être impossible ?

Il suffit que le graphe contienne un cycle, des flèches qui s'attendent les unes les autres en boucle. À l'œil, rien ne le signale, le plateau paraît plein et prêt à jouer, et pourtant aucune solution n'existe. Tout le générateur repose donc sur une règle que les mathématiciens appellent un invariant, une propriété qui doit rester vraie quoi qu'il arrive. Ici, le graphe des flèches doit rester sans cycle, à chaque flèche posée.

## Comment fabriquer 5 000 niveaux qui ont tous une solution ?

Le générateur pose les flèches une à une et tient, pour chacune, la liste de celles qu'elle attend. Avant de poser une nouvelle flèche, il remonte cette liste de proche en proche. Si sa pointe ou son corps tombe sur le rayon de l'une de ces flèches, celle-ci l'attendrait à son tour et la boucle se fermerait. La position est alors écartée, et le graphe reste sans cycle par construction.

src/game/generator.ts

TypeScript

```
<span class="code-line"><span class="tok-comment">/** Toutes les flèches qui doivent sortir avant celles de `start`, de proche en proche. */</span></span><span class="code-line"><span class="tok-keyword">function</span> <span class="tok-call">ancestors</span><span class="tok-punctuation">(</span>graph<span class="tok-punctuation">:</span> <span class="tok-type">DependencyGraph</span><span class="tok-punctuation">,</span> start<span class="tok-punctuation">:</span> <span class="tok-type">Iterable</span><span class="tok-punctuation"><</span><span class="tok-type">ArrowId</span><span class="tok-punctuation">></span><span class="tok-punctuation">)</span><span class="tok-punctuation">:</span> <span class="tok-type">Set</span><span class="tok-punctuation"><</span><span class="tok-type">ArrowId</span><span class="tok-punctuation">></span> <span class="tok-punctuation">{</span></span><span class="code-line">  <span class="tok-keyword">const</span> seen <span class="tok-punctuation">=</span> <span class="tok-keyword">new</span> <span class="tok-type">Set</span><span class="tok-punctuation">(</span>start<span class="tok-punctuation">)</span></span><span class="code-line">  <span class="tok-keyword">const</span> stack <span class="tok-punctuation">=</span> <span class="tok-punctuation">[</span><span class="tok-punctuation">...</span>seen<span class="tok-punctuation">]</span></span><span class="code-line"></span><span class="code-line">  <span class="tok-keyword">for</span> <span class="tok-punctuation">(</span><span class="tok-keyword">let</span> id <span class="tok-punctuation">=</span> stack<span class="tok-punctuation">.</span><span class="tok-call">pop</span><span class="tok-punctuation">(</span><span class="tok-punctuation">)</span><span class="tok-punctuation">;</span> id <span class="tok-punctuation">!==</span> <span class="tok-literal">undefined</span><span class="tok-punctuation">;</span> id <span class="tok-punctuation">=</span> stack<span class="tok-punctuation">.</span><span class="tok-call">pop</span><span class="tok-punctuation">(</span><span class="tok-punctuation">)</span><span class="tok-punctuation">)</span> <span class="tok-punctuation">{</span></span><span class="code-line">    <span class="tok-keyword">for</span> <span class="tok-punctuation">(</span><span class="tok-keyword">const</span> blocker <span class="tok-keyword">of</span> graph<span class="tok-punctuation">.</span><span class="tok-call">blockersOf</span><span class="tok-punctuation">(</span>id<span class="tok-punctuation">)</span><span class="tok-punctuation">)</span> <span class="tok-punctuation">{</span></span><span class="code-line">      <span class="tok-keyword">if</span> <span class="tok-punctuation">(</span>seen<span class="tok-punctuation">.</span><span class="tok-call">has</span><span class="tok-punctuation">(</span>blocker<span class="tok-punctuation">)</span><span class="tok-punctuation">)</span> <span class="tok-keyword">continue</span></span><span class="code-line">      seen<span class="tok-punctuation">.</span><span class="tok-call">add</span><span class="tok-punctuation">(</span>blocker<span class="tok-punctuation">)</span></span><span class="code-line">      stack<span class="tok-punctuation">.</span><span class="tok-call">push</span><span class="tok-punctuation">(</span>blocker<span class="tok-punctuation">)</span></span><span class="code-line">    <span class="tok-punctuation">}</span></span><span class="code-line">  <span class="tok-punctuation">}</span></span><span class="code-line"></span><span class="code-line">  <span class="tok-keyword">return</span> seen</span><span class="code-line"><span class="tok-punctuation">}</span></span><span class="code-line"></span><span class="code-line"><span class="tok-keyword">export</span> <span class="tok-keyword">function</span> <span class="tok-call">tryPlace</span><span class="tok-punctuation">(</span>head<span class="tok-punctuation">:</span> <span class="tok-type">Cell</span><span class="tok-punctuation">,</span> direction<span class="tok-punctuation">:</span> <span class="tok-type">Direction</span><span class="tok-punctuation">,</span> length<span class="tok-punctuation">:</span> <span class="tok-type">number</span><span class="tok-punctuation">)</span><span class="tok-punctuation">:</span> <span class="tok-type">Arrow</span> <span class="tok-punctuation">|</span> <span class="tok-literal">null</span> <span class="tok-punctuation">{</span></span><span class="code-line">  <span class="tok-keyword">if</span> <span class="tok-punctuation">(</span>board<span class="tok-punctuation">.</span><span class="tok-call">occupantAt</span><span class="tok-punctuation">(</span>head<span class="tok-punctuation">)</span> <span class="tok-punctuation">!==</span> <span class="tok-literal">undefined</span><span class="tok-punctuation">)</span> <span class="tok-keyword">return</span> <span class="tok-literal">null</span></span><span class="code-line"></span><span class="code-line" data-marked="">  <span class="tok-comment">// Les flèches que son rayon touche sortiront avant elle, et avec elles tout ce qu'elles attendent.</span></span><span class="code-line" data-marked="">  <span class="tok-keyword">const</span> waitsFor <span class="tok-punctuation">=</span> <span class="tok-call">ancestors</span><span class="tok-punctuation">(</span>graph<span class="tok-punctuation">,</span> board<span class="tok-punctuation">.</span><span class="tok-call">arrowsOnRay</span><span class="tok-punctuation">(</span>head<span class="tok-punctuation">,</span> direction<span class="tok-punctuation">)</span><span class="tok-punctuation">)</span></span><span class="code-line" data-marked=""></span><span class="code-line" data-marked="">  <span class="tok-comment">// Si l'une d'elles a cette pointe sur son rayon, elle l'attendrait à son tour. La boucle se fermerait.</span></span><span class="code-line" data-marked="">  <span class="tok-keyword">if</span> <span class="tok-punctuation">(</span><span class="tok-punctuation">!</span>board<span class="tok-punctuation">.</span><span class="tok-call">raysThrough</span><span class="tok-punctuation">(</span>head<span class="tok-punctuation">)</span><span class="tok-punctuation">.</span><span class="tok-call">isDisjointFrom</span><span class="tok-punctuation">(</span>waitsFor<span class="tok-punctuation">)</span><span class="tok-punctuation">)</span> <span class="tok-keyword">return</span> <span class="tok-literal">null</span></span><span class="code-line"></span><span class="code-line">  <span class="tok-comment">// Son corps évite leurs rayons, pour la même raison.</span></span><span class="code-line">  <span class="tok-keyword">const</span> body <span class="tok-punctuation">=</span> <span class="tok-call">growBody</span><span class="tok-punctuation">(</span>head<span class="tok-punctuation">,</span> direction<span class="tok-punctuation">,</span> <span class="tok-punctuation">{</span> length<span class="tok-punctuation">,</span> avoid<span class="tok-punctuation">:</span> waitsFor <span class="tok-punctuation">}</span><span class="tok-punctuation">)</span></span><span class="code-line">  <span class="tok-keyword">if</span> <span class="tok-punctuation">(</span>body<span class="tok-punctuation">.</span>length <span class="tok-punctuation"><</span> <span class="tok-type">MIN_LENGTH</span><span class="tok-punctuation">)</span> <span class="tok-keyword">return</span> <span class="tok-literal">null</span></span><span class="code-line"></span><span class="code-line">  <span class="tok-keyword">return</span> graph<span class="tok-punctuation">.</span><span class="tok-call">add</span><span class="tok-punctuation">(</span><span class="tok-punctuation">{</span> head<span class="tok-punctuation">,</span> direction<span class="tok-punctuation">,</span> body <span class="tok-punctuation">}</span><span class="tok-punctuation">,</span> waitsFor<span class="tok-punctuation">)</span></span><span class="code-line"><span class="tok-punctuation">}</span></span>
```

Avant de poser une flèche, le générateur rassemble tout ce qu'elle attendra, et refuse la position qui fermerait une boucle.

Les longues flèches sont posées d'abord, de plus courtes comblent ensuite les vides, et les dernières cases isolées rejoignent la queue d'une flèche voisine. Le plateau finit rempli à plus de 97 %, sans aucune flèche d'une seule case, et une flèche sur quatre mesure quinze cases ou plus.

Chaque niveau est ensuite vérifié par un épluchage glouton, le greedy peel. Le programme compte, pour chaque flèche, celles qui lui barrent la route, part de celles qui n'en ont aucune et, à chaque flèche sortie, décompte celles qu'elle retenait. C'est l'algorithme de Kahn, qui sert d'ordinaire à ordonner des tâches qui dépendent les unes des autres. Si toutes les flèches finissent par sortir, le niveau est validé.

src/game/solver.ts

TypeScript

```
<span class="code-line"><span class="tok-comment">/**</span></span><span class="code-line"><span class="tok-comment"> * Un niveau a une solution si et seulement si son graphe des blocages n'a pas de cycle.</span></span><span class="code-line"><span class="tok-comment"> * L'algorithme de Kahn le vérifie en voyant chaque flèche et chaque blocage une seule fois.</span></span><span class="code-line"><span class="tok-comment"> */</span></span><span class="code-line"><span class="tok-keyword">export</span> <span class="tok-keyword">function</span> <span class="tok-call">isSolvable</span><span class="tok-punctuation">(</span>level<span class="tok-punctuation">:</span> <span class="tok-type">Level</span><span class="tok-punctuation">)</span><span class="tok-punctuation">:</span> <span class="tok-type">boolean</span> <span class="tok-punctuation">{</span></span><span class="code-line">  <span class="tok-keyword">const</span> graph <span class="tok-punctuation">=</span> <span class="tok-type">DependencyGraph</span><span class="tok-punctuation">.</span><span class="tok-keyword">from</span><span class="tok-punctuation">(</span>level<span class="tok-punctuation">)</span></span><span class="code-line">  <span class="tok-keyword">const</span> blockers <span class="tok-punctuation">=</span> <span class="tok-keyword">new</span> <span class="tok-type">Map</span><span class="tok-punctuation">(</span>graph<span class="tok-punctuation">.</span>arrows<span class="tok-punctuation">.</span><span class="tok-call">map</span><span class="tok-punctuation">(</span><span class="tok-punctuation">(</span>id<span class="tok-punctuation">)</span> <span class="tok-punctuation">=></span> <span class="tok-punctuation">[</span>id<span class="tok-punctuation">,</span> graph<span class="tok-punctuation">.</span><span class="tok-call">blockersOf</span><span class="tok-punctuation">(</span>id<span class="tok-punctuation">)</span><span class="tok-punctuation">.</span>size<span class="tok-punctuation">]</span> <span class="tok-keyword">as</span> <span class="tok-keyword">const</span><span class="tok-punctuation">)</span><span class="tok-punctuation">)</span></span><span class="code-line">  <span class="tok-keyword">const</span> free <span class="tok-punctuation">=</span> graph<span class="tok-punctuation">.</span>arrows<span class="tok-punctuation">.</span><span class="tok-call">filter</span><span class="tok-punctuation">(</span><span class="tok-punctuation">(</span>id<span class="tok-punctuation">)</span> <span class="tok-punctuation">=></span> blockers<span class="tok-punctuation">.</span><span class="tok-keyword">get</span><span class="tok-punctuation">(</span>id<span class="tok-punctuation">)</span> <span class="tok-punctuation">===</span> <span class="tok-number">0</span><span class="tok-punctuation">)</span></span><span class="code-line"></span><span class="code-line">  <span class="tok-comment">// La liste grandit pendant qu'on la parcourt, chaque flèche libérée y entre à son tour.</span></span><span class="code-line" data-marked="">  <span class="tok-keyword">for</span> <span class="tok-punctuation">(</span><span class="tok-keyword">const</span> id <span class="tok-keyword">of</span> free<span class="tok-punctuation">)</span> <span class="tok-punctuation">{</span></span><span class="code-line" data-marked="">    <span class="tok-keyword">for</span> <span class="tok-punctuation">(</span><span class="tok-keyword">const</span> next <span class="tok-keyword">of</span> graph<span class="tok-punctuation">.</span><span class="tok-call">waitingOn</span><span class="tok-punctuation">(</span>id<span class="tok-punctuation">)</span><span class="tok-punctuation">)</span> <span class="tok-punctuation">{</span></span><span class="code-line" data-marked="">      <span class="tok-keyword">const</span> left <span class="tok-punctuation">=</span> <span class="tok-punctuation">(</span>blockers<span class="tok-punctuation">.</span><span class="tok-keyword">get</span><span class="tok-punctuation">(</span>next<span class="tok-punctuation">)</span> <span class="tok-punctuation">??</span> <span class="tok-number">0</span><span class="tok-punctuation">)</span> <span class="tok-punctuation">-</span> <span class="tok-number">1</span></span><span class="code-line" data-marked="">      blockers<span class="tok-punctuation">.</span><span class="tok-keyword">set</span><span class="tok-punctuation">(</span>next<span class="tok-punctuation">,</span> left<span class="tok-punctuation">)</span></span><span class="code-line" data-marked="">      <span class="tok-keyword">if</span> <span class="tok-punctuation">(</span>left <span class="tok-punctuation">===</span> <span class="tok-number">0</span><span class="tok-punctuation">)</span> free<span class="tok-punctuation">.</span><span class="tok-call">push</span><span class="tok-punctuation">(</span>next<span class="tok-punctuation">)</span></span><span class="code-line">    <span class="tok-punctuation">}</span></span><span class="code-line">  <span class="tok-punctuation">}</span></span><span class="code-line"></span><span class="code-line" data-marked="">  <span class="tok-keyword">return</span> free<span class="tok-punctuation">.</span>length <span class="tok-punctuation">===</span> graph<span class="tok-punctuation">.</span>arrows<span class="tok-punctuation">.</span>length</span><span class="code-line"><span class="tok-punctuation">}</span></span>
```

La vérification d'un niveau, un tri topologique. Il est validé quand toutes ses flèches ont pu sortir.

Ce calcul n'a rien d'une approximation. Retirer une flèche ne fait que libérer des cases, une flèche libre le reste donc jusqu'au bout, et l'ordre dans lequel on les retire n'a aucune importance. Si un ordre gagnant existe, l'algorithme le trouve, en ne regardant chaque flèche et chaque blocage qu'une seule fois.

## Un niveau tient dans un numéro

Aucun des 5 000 niveaux n'est enregistré. Le numéro d'un niveau, brassé par une fonction de hachage pour que deux niveaux voisins ne se ressemblent pas, sert de graine à un générateur pseudo-aléatoire, une suite de nombres qui paraît due au hasard mais que la même graine reproduit à l'identique. Le niveau 1 284 est donc le même pour tous les joueurs, sur tous les appareils, et le défi du jour prend la date pour graine.

src/game/random.ts

TypeScript

```
<span class="code-line"><span class="tok-comment">/** Mulberry32, un générateur pseudo-aléatoire à graine, sur 32 bits. */</span></span><span class="code-line"><span class="tok-keyword">export</span> <span class="tok-keyword">function</span> <span class="tok-call">mulberry32</span><span class="tok-punctuation">(</span>seed<span class="tok-punctuation">:</span> <span class="tok-type">number</span><span class="tok-punctuation">)</span><span class="tok-punctuation">:</span> <span class="tok-punctuation">(</span><span class="tok-punctuation">)</span> <span class="tok-punctuation">=></span> <span class="tok-type">number</span> <span class="tok-punctuation">{</span></span><span class="code-line">  <span class="tok-keyword">let</span> state <span class="tok-punctuation">=</span> seed <span class="tok-punctuation">></span><span class="tok-punctuation">></span><span class="tok-punctuation">></span> <span class="tok-number">0</span></span><span class="code-line"></span><span class="code-line">  <span class="tok-keyword">return</span> <span class="tok-punctuation">(</span><span class="tok-punctuation">)</span> <span class="tok-punctuation">=></span> <span class="tok-punctuation">{</span></span><span class="code-line" data-marked="">    state <span class="tok-punctuation">=</span> <span class="tok-punctuation">(</span>state <span class="tok-punctuation">+</span> <span class="tok-number">0x6d2b79f5</span><span class="tok-punctuation">)</span> <span class="tok-punctuation">></span><span class="tok-punctuation">></span><span class="tok-punctuation">></span> <span class="tok-number">0</span></span><span class="code-line" data-marked="">    <span class="tok-keyword">let</span> t <span class="tok-punctuation">=</span> <span class="tok-type">Math</span><span class="tok-punctuation">.</span><span class="tok-call">imul</span><span class="tok-punctuation">(</span>state ^ <span class="tok-punctuation">(</span>state <span class="tok-punctuation">></span><span class="tok-punctuation">></span><span class="tok-punctuation">></span> <span class="tok-number">15</span><span class="tok-punctuation">)</span><span class="tok-punctuation">,</span> state <span class="tok-punctuation">|</span> <span class="tok-number">1</span><span class="tok-punctuation">)</span></span><span class="code-line" data-marked="">    t ^<span class="tok-punctuation">=</span> t <span class="tok-punctuation">+</span> <span class="tok-type">Math</span><span class="tok-punctuation">.</span><span class="tok-call">imul</span><span class="tok-punctuation">(</span>t ^ <span class="tok-punctuation">(</span>t <span class="tok-punctuation">></span><span class="tok-punctuation">></span><span class="tok-punctuation">></span> <span class="tok-number">7</span><span class="tok-punctuation">)</span><span class="tok-punctuation">,</span> t <span class="tok-punctuation">|</span> <span class="tok-number">61</span><span class="tok-punctuation">)</span></span><span class="code-line" data-marked="">    <span class="tok-keyword">return</span> <span class="tok-punctuation">(</span><span class="tok-punctuation">(</span>t ^ <span class="tok-punctuation">(</span>t <span class="tok-punctuation">></span><span class="tok-punctuation">></span><span class="tok-punctuation">></span> <span class="tok-number">14</span><span class="tok-punctuation">)</span><span class="tok-punctuation">)</span> <span class="tok-punctuation">></span><span class="tok-punctuation">></span><span class="tok-punctuation">></span> <span class="tok-number">0</span><span class="tok-punctuation">)</span> <span class="tok-punctuation">/</span> <span class="tok-number">2</span> <span class="tok-punctuation">*</span><span class="tok-punctuation">*</span> <span class="tok-number">32</span></span><span class="code-line">  <span class="tok-punctuation">}</span></span><span class="code-line"><span class="tok-punctuation">}</span></span><span class="code-line"></span><span class="code-line"><span class="tok-comment">// Chaque niveau reçoit son propre hasard, tiré de son numéro, et rien de global n'est touché.</span></span><span class="code-line"><span class="tok-keyword">export</span> <span class="tok-keyword">function</span> <span class="tok-call">campaignLevel</span><span class="tok-punctuation">(</span>n<span class="tok-punctuation">:</span> <span class="tok-type">number</span><span class="tok-punctuation">)</span><span class="tok-punctuation">:</span> <span class="tok-type">Level</span> <span class="tok-punctuation">{</span></span><span class="code-line" data-marked="">  <span class="tok-keyword">return</span> <span class="tok-call">generateLevel</span><span class="tok-punctuation">(</span><span class="tok-punctuation">{</span> tier<span class="tok-punctuation">:</span> <span class="tok-call">tierOf</span><span class="tok-punctuation">(</span>n<span class="tok-punctuation">)</span><span class="tok-punctuation">,</span> random<span class="tok-punctuation">:</span> <span class="tok-call">mulberry32</span><span class="tok-punctuation">(</span><span class="tok-call">hash</span><span class="tok-punctuation">(</span>n<span class="tok-punctuation">)</span><span class="tok-punctuation">)</span> <span class="tok-punctuation">}</span><span class="tok-punctuation">)</span></span><span class="code-line"><span class="tok-punctuation">}</span></span>
```

Le numéro du niveau devient sa graine, et tout son hasard en découle.

Mulberry32 tient en quatre lignes et répartit bien mieux ses nombres que les vieux générateurs à multiplication simple, dont les derniers bits tournent en rond. Math.imul y multiplie sur 32 bits, comme le processeur, sans passer par les nombres à virgule de JavaScript, et la suite est la même sur tous les navigateurs. Le générateur reçoit ce hasard en paramètre plutôt que de remplacer Math.random, ce qui le rend testable et permet de calculer deux niveaux à la fois sans qu'ils se mélangent. Un plateau expert, 70 cases sur 45 et près de 300 flèches, se calcule en une fraction de seconde, au moment où le joueur l'ouvre.

## Résoluble ne veut pas dire intéressant

Un niveau peut avoir une solution et n'offrir aucun plaisir, quand le prochain coup saute aux yeux à chaque fois. La difficulté se règle donc aussi pour l'œil. Le générateur dose la part de flèches libres au départ et la taille du plateau, de 18 cases sur 12 à 70 sur 45, et la campagne mélange les niveaux autour d'une difficulté qui monte peu à peu, pour qu'un niveau plus simple vienne parfois souffler entre deux plus exigeants.

Nous avons aussi mis l'IA à l'épreuve, Claude et GPT, avec des consignes détaillées et des captures à l'appui. Leurs pistes étaient intéressantes, mais les niveaux obtenus restaient impossibles, trop linéaires ou troués d'espaces vides. Le générateur d'unwind est donc écrit à la main, règle après règle, à force d'essais.

## Des niveaux en forme de cœur ou de chat

Un niveau sur six, à partir du treizième, le plateau prend une forme, un cœur, une étoile, un chat, une lune ou une fleur. Chacune est décrite par une équation, et le générateur ne pose ses flèches qu'à l'intérieur. Ces niveaux sont volontairement plus faciles, une respiration dans la campagne. L'atelier de création, réservé à l'équipe, va plus loin et transforme n'importe quelle image en niveau, ses zones sombres devenant le plateau.

- ![Un niveau d'unwind en forme de cœur, rempli de flèches](https://agencetwini.fr/media/2026/11/twini-article-unwind-coeur-94918532-800.webp)
- ![Un niveau d'unwind en forme de tête de chat, rempli de flèches](https://agencetwini.fr/media/2026/11/twini-article-unwind-chat-f6d048e0-800.webp)
- ![Un niveau d'unwind en forme d'étoile, rempli de flèches](https://agencetwini.fr/media/2026/11/twini-article-unwind-etoile-f09ee9c6-800.webp)

## Ce que le joueur ne voit pas

Sur un téléphone, une flèche mesure parfois quelques millimètres. Le jeu cherche donc celle que le doigt visait, pas celle qu'il effleure. Les flèches jouables à cet instant reçoivent une zone de toucher plus large, la cible est retenue dès que le doigt se pose plutôt qu'au moment où il se lève, et une légère vibration confirme le geste. Une erreur coûte un cœur, elle doit venir du joueur, jamais d'un doigt qui glisse.

Une partie interrompue reprend exactement là où elle s'était arrêtée. Le jeu ne garde que les flèches déjà sorties, puisque le plateau se reconstruit à partir du numéro du niveau. Les étoiles gagnées débloquent des thèmes, de l'Océan au Néon, des traînées de particules et d'autres formes de pointes.

## Une application sans passer par un store

Le jeu est une PWA, pour progressive web app, un site qui s'installe sur l'écran d'accueil d'un téléphone et s'ouvre ensuite comme une application, sans passer par l'App Store ni Google Play. Ses mises à jour arrivent d'elles-mêmes, à l'ouverture suivante.

C'est ce que nous voulions montrer avec unwind. Un site peut être bien plus qu'une vitrine, et les techniques qui font tenir un jeu, les graphes, la génération automatique, la précision du toucher, servent tout autant un outil métier ou une expérience de marque. Nous les mettons au service de nos [sites sur mesure](https://agencetwini.fr/services/sites-sur-mesure) comme de nos [logiciels métiers](https://agencetwini.fr/services/logiciels-metiers).

[Essayez unwind](https://unwind.agencetwini.dev/) sur votre téléphone ou votre ordinateur, une partie prend quelques minutes. Et si vous imaginez un jeu, un outil ou une expérience interactive pour votre entreprise, [parlons-en](https://agencetwini.fr/contact).

## Écrit par Julien Lemonnier

Développeur

---

Source : https://agencetwini.fr/actualites/casse-tete-en-ligne-unwind
