Forge-Engine/static/js/play/offline/compute-operation.js

// Export Web/SCORM (voir le plan "port complet du runtime jouable côté
// navigateur") — port fidèle de screens/data_actions/compute_operation.py,
// utilisé UNIQUEMENT quand window.FORGE_OFFLINE est vrai (paquet exporté,
// aucun serveur disponible) — voir apply-actions.js, les deux seuls
// endroits qui en ont besoin. Toute divergence avec la version Python doit
// être volontaire et commentée (ex. modulo/int()).

// int() Python tronque vers zéro — Math.trunc fait exactement ça
// (contrairement à Math.floor, qui arrondit vers -l'infini).
function forgePyInt(n) {
  return Math.trunc(n);
}

// Le signe du résultat de "%" suit le DIVISEUR en Python, le DIVIDENDE en
// JS — sans ce correctif, "modulo" donnerait un résultat différent de
// compute_operation.py dès qu'une des deux valeurs est négative.
function forgePyMod(a, b) {
  return ((a % b) + b) % b;
}

function forgeComputeNewValue(operation, current, rawValue, isDecimal) {
  const round = function (v) { return isDecimal ? v : forgePyInt(v); };
  if (operation === 'definir_texte') return rawValue || '';
  if (operation === 'definir_nombre') {
    const n = parseFloat(rawValue);
    return Number.isNaN(n) ? 0 : round(n);
  }
  if (operation === 'definir_bool_vrai') return 1;
  if (operation === 'definir_bool_faux') return 0;
  if (operation === 'basculer_bool') return current ? 0 : 1;
  if (operation === 'incrementer' || operation === 'decrementer') {
    let amount = (rawValue === null || rawValue === undefined || rawValue === '') ? 0 : parseFloat(rawValue);
    if (Number.isNaN(amount)) amount = 0;
    if (operation === 'decrementer') amount = -amount;
    return round((current || 0) + amount);
  }
  if (operation === 'multiplier') {
    let factor = (rawValue === null || rawValue === undefined || rawValue === '') ? 1 : parseFloat(rawValue);
    if (Number.isNaN(factor)) factor = 1;
    return round((current || 0) * factor);
  }
  if (operation === 'diviser' || operation === 'modulo') {
    let divisor = (rawValue === null || rawValue === undefined || rawValue === '') ? 0 : parseFloat(rawValue);
    if (Number.isNaN(divisor)) divisor = 0;
    if (divisor === 0) return current;
    const result = operation === 'diviser' ? (current || 0) / divisor : forgePyMod(current || 0, divisor);
    return round(result);
  }
  if (operation === 'minimum' || operation === 'maximum') {
    const bound = parseFloat(rawValue);
    if (Number.isNaN(bound)) return current;
    const res = operation === 'minimum' ? Math.max(current || 0, bound) : Math.min(current || 0, bound);
    return round(res);
  }
  if (operation === 'alea') {
    const parts = String(rawValue || '').split(',');
    let lo = parseFloat(parts[0]); let
      hi = parseFloat(parts[1]);
    if (Number.isNaN(lo)) lo = 0;
    if (Number.isNaN(hi)) hi = 0;
    if (lo > hi) { const tmp = lo; lo = hi; hi = tmp; }
    if (isDecimal) return Math.random() * (hi - lo) + lo; // NOSONAR S2245 - tirage de jeu, jamais crypto
    const iLo = Math.trunc(lo); const
      iHi = Math.trunc(hi);
    return Math.floor(Math.random() * (iHi - iLo + 1)) + iLo; // NOSONAR S2245 - tirage de jeu, jamais crypto
  }
  throw new Error(`opération inconnue : ${operation}`);
}

// static/js/play/__tests__/ (node:test) — même patron que conditions.js.
if (typeof module !== 'undefined' && module.exports) {
  module.exports = { forgeComputeNewValue, forgePyInt, forgePyMod };
}