Mouvement continu, limites de scène et priorité d'animation (jeu 2D)

Répond au manque signalé par l'utilisateur : le déclencheur "clavier"
existant (keydown) ne se déclenche qu'UNE FOIS par appui, insuffisant
pour "maintenir une touche fait avancer/sauter le personnage en continu".

- Deux nouveaux déclencheurs (screens/flow/constants.py,
  screens/scenes/flow_palette.py) : "Tant qu'une touche est maintenue"
  (se répète ~20 fois/seconde tant que la touche reste enfoncée,
  runScreenHeldKeyTriggers() dans triggers.js — même patron PAR ÉCRAN que
  "minuteur", arrêté au changement d'écran) et "Au relâchement d'une
  touche" (un seul déclenchement, scan global comme "clavier"). Combinés
  à l'action existante "Modifier un objet de scène → Déplacer de... px
  (relatif)", ça permet un vrai déplacement continu.
- preventDefault() sur toute touche que le jeu écoute réellement
  (isGameKey(), triggers.js) : Espace/Flèches font défiler la page par
  défaut, et Espace réactive en plus le bouton actuellement focus (souvent
  le bouton "Jouer" qui garde le focus après l'ouverture de l'aperçu) —
  ça pouvait donner l'impression qu'une touche du jeu ne faisait rien.
- Le personnage pouvait sortir du cadre de la scène en se déplaçant :
  applyObjectProperty()/clampSceneObjectPosition() (static/js/play/actions.js)
  bornent maintenant toute position (absolue ou relative) à
  [0, scene_width/height − la taille de l'objet].
- Vitesse d'animation par défaut adaptée au nombre d'images : la valeur
  fixe (8 i/s) venait d'un formulaire pensé pour les cycles Kenney (8
  images) — un cycle CraftPix (walk=30 images) au même 8 i/s prenait
  ~4 secondes, "très lent". Le choix d'une animation dans la galerie
  calcule maintenant une vitesse par défaut proportionnelle à son nombre
  d'images (flow-editor.js, animation-timeline.js).
- Priorité d'animation (bug : "je ne peux pas me déplacer et sauter") :
  un déclencheur de déplacement (touche maintenue) redemande "marche" à
  chaque tick, écrasant aussitôt une animation ponctuelle ("sauter")
  démarrée entre-temps avant qu'elle ait pu s'afficher. runSpriteAnimation()
  (actions.js) laisse maintenant une animation NON BOUCLÉE en cours
  (même à une seule frame, ex. une pose Kenney figée) aller jusqu'au bout
  avant qu'une autre demande puisse l'interrompre.

Nouveaux tests : static/js/play/__tests__/{actions,triggers}.test.js
(idempotence + priorité d'animation, bornage aux limites de la scène,
isGameKey) ; tests/test_scene_edit_view.py (persistance d'un nœud
"touche_maintenue").

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

static/js/play/triggers.js

@@ -161,8 +161,28 @@ function bindHoverTriggers() {
 // est parcouru à CHAQUE appui, pas une seule fois au chargement, pour
 // que les nœuds ajoutés/déplacés après un rafraîchissement des données
 // restent pris en compte sans devoir ré-attacher quoi que ce soit.
+// Empêche le comportement par défaut du navigateur pour une touche que LE
+// JEU écoute (ex. Espace/Flèches font défiler la page, et Espace "clique"
+// en plus le bouton actuellement focus — souvent le bouton "Jouer" qui a
+// gardé le focus après avoir ouvert l'aperçu) — sans ça, sauter et se
+// déplacer en même temps pouvait sembler ne pas marcher : la touche
+// réactivait/scrollait la page au lieu de se contenter de jouer le jeu.
+// Jamais pour une touche qui n'est PAS écoutée par le jeu (laisse tel
+// quel un champ de saisie ailleurs sur la page, par ex.).
+function isGameKey(key) {
+  for (const screenIdKey in gameData.flows) {
+    if (gameData.flows[screenIdKey].nodes.some(function(n) {
+      return n.node_type === 'trigger' &&
+        (n.trigger_event === 'clavier' || n.trigger_event === 'touche_maintenue' || n.trigger_event === 'touche_relachee') &&
+        n.trigger_key === key;
+    })) return true;
+  }
+  return false;
+}
+
 function bindKeyboardTriggers() {
   window.addEventListener('keydown', function (ev) {
+    if (isGameKey(ev.key)) ev.preventDefault();
     for (const screenIdKey in gameData.flows) {
       gameData.flows[screenIdKey].nodes
         .filter(function(n){ return n.node_type === 'trigger' && n.trigger_event === 'clavier' && n.trigger_key === ev.key; })
@@ -170,3 +190,58 @@ function bindKeyboardTriggers() {
     }
   });
 }
+
+// Mouvement continu (jeu 2D) — répond au manque signalé par l'utilisateur :
+// "clavier" ci-dessus ne se déclenche qu'UNE FOIS par appui (keydown),
+// insuffisant pour "maintenir une touche fait avancer le personnage".
+// heldKeys suit les touches actuellement enfoncées (Set, indépendant de la
+// répétition OS du keydown — un keydown répété pour la même touche ne fait
+// que la re-ajouter, sans effet). Un SEUL écouteur global (comme
+// bindKeyboardTriggers ci-dessus), lu à intervalle régulier PAR ÉCRAN (voir
+// runScreenHeldKeyTriggers, appelée depuis showScreen() comme
+// runScreenTimerTriggers). "touche_relachee" (keyup), lui, n'a pas besoin
+// d'être scopé par écran — un seul déclenchement ponctuel, même patron de
+// scan global que "clavier".
+var heldKeys = new Set();
+
+function bindHeldKeyTriggers() {
+  window.addEventListener('keydown', function (ev) {
+    if (isGameKey(ev.key)) ev.preventDefault();
+    heldKeys.add(ev.key);
+  });
+  window.addEventListener('keyup', function (ev) {
+    heldKeys.delete(ev.key);
+    for (const screenIdKey in gameData.flows) {
+      gameData.flows[screenIdKey].nodes
+        .filter(function(n){ return n.node_type === 'trigger' && n.trigger_event === 'touche_relachee' && n.trigger_key === ev.key; })
+        .forEach(function(n){ runFlowFrom(n.id, screenIdKey); });
+    }
+  });
+  // La fenêtre peut perdre le focus touche encore enfoncée (alt-tab...) —
+  // sans ça, heldKeys garderait une touche "fantôme" indéfiniment maintenue.
+  window.addEventListener('blur', function () { heldKeys.clear(); });
+}
+
+// Même patron PAR ÉCRAN que runScreenTimerTriggers() ci-dessus : n'existe
+// que tant que l'écran qui porte le déclencheur est affiché, réinitialisé
+// à chaque changement d'écran (voir showScreen(), static/js/play/screens.js).
+// 50ms (20 fois/seconde) : assez fluide pour un déplacement perçu comme
+// continu, sans re-exécuter le graphe à une fréquence excessive.
+var activeHeldKeyTriggerInterval = null;
+
+function runScreenHeldKeyTriggers(screenId) {
+  if (activeHeldKeyTriggerInterval) { clearInterval(activeHeldKeyTriggerInterval); activeHeldKeyTriggerInterval = null; }
+  const flow = gameData.flows[String(screenId)];
+  if (!flow) return;
+  const nodes = flow.nodes.filter(function(n){ return n.node_type === 'trigger' && n.trigger_event === 'touche_maintenue'; });
+  if (!nodes.length) return;
+  activeHeldKeyTriggerInterval = setInterval(function () {
+    nodes.filter(function(n){ return heldKeys.has(n.trigger_key); })
+      .forEach(function(n){ runFlowFrom(n.id, screenId); });
+  }, 50);
+}
+
+// static/js/play/__tests__/ (node:test) — même patron que conditions.js.
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { isGameKey, heldKeys };
+}