Forge-Engine/static/game/js/play/offline/visibility-condition.js

// Export Web/SCORM (voir le plan "port complet du runtime jouable côté
// navigateur") — port de game_engine/rendering/visibility_condition.py
// (is_element_visible). Réutilise forgeResolveFilterValue/
// forgeResolveVariablePath (filter-repeater-rows.js) et compareValues
// (conditions.js), chargés avant ce fichier.
//
// `ctx` : les {{champ}} de la ligne en cours quand cet élément est
// descendant d'un Répéteur (voir render-element.js) — en mode "objet", si
// le champ réglé s'y trouve déjà, sa valeur est utilisée telle quelle
// plutôt que la ligne la plus récente de l'objet (même raison que côté
// serveur : sans ça, tous les exemplaires d'un même modèle de ligne
// évalueraient la MÊME ligne au lieu de chacun la sienne).
function forgeIsElementVisibleOffline(gameData, attrs, ctx) {
  const mode = attrs._visibilite_cond_mode;
  if (mode !== 'variable' && mode !== 'objet') return true;
  const operator = attrs._visibilite_cond_operateur || 'egal';
  const expected = forgeResolveFilterValue(gameData, attrs._visibilite_cond_valeur || '');

  if (mode === 'variable') {
    const varName = attrs._visibilite_cond_variable;
    if (!varName) return true;
    const variable = gameData.variables && gameData.variables[varName];
    if (!variable) return true; // variable supprimée depuis : ne bloque jamais l'affichage
    let { value } = variable;
    const path = attrs._visibilite_cond_variable_chemin;
    if (path) value = forgeResolveVariablePath(value, path);
    return compareValues(value, operator, expected, variable.type || 'texte');
  }

  let definitionId = attrs._visibilite_cond_definition_id;
  const fieldName = attrs._visibilite_cond_champ;
  if (!definitionId || !fieldName) return true;
  definitionId = String(definitionId);
  const fieldsMetaForDef = gameData.fields_meta && gameData.fields_meta[definitionId];
  if (!fieldsMetaForDef) return true;
  const field = fieldsMetaForDef.find((f) => f.name === fieldName);
  const fieldType = field ? field.type : 'texte';

  if (ctx && Object.prototype.hasOwnProperty.call(ctx, fieldName)) {
    return compareValues(ctx[fieldName], operator, expected, fieldType);
  }

  const rows = gameData.data && gameData.data[definitionId];
  if (!rows || !rows.length) return true; // objet sans donnée pour l'instant : ne bloque pas
  const row = rows[0]; // convention "état de partie" : une seule ligne
  // row[fieldName] : gameData.data est déjà indexé par le nom D'AFFICHAGE
  // du champ (voir full_game_payload.py), jamais par sa colonne SQL.
  return compareValues(row[fieldName], operator, expected, fieldType);
}

if (typeof module !== 'undefined' && module.exports) {
  module.exports = { forgeIsElementVisibleOffline };
  const filterMod = require('./filter-repeater-rows.js');
  global.forgeResolveFilterValue = global.forgeResolveFilterValue || filterMod.forgeResolveFilterValue;
  global.forgeResolveVariablePath = global.forgeResolveVariablePath || filterMod.forgeResolveVariablePath;
  global.compareValues = global.compareValues || require('../conditions.js').compareValues;
}