williamandClaude Sonnet 5
1296edc2f8
Nouvel attribut max_width (vide par défaut = pleine largeur, inchangé) sur les kinds titre/paragraphe, réglable depuis leur panneau Propriétés. Le sous-titre de la page de garde du thème Sécurité Incendie l'utilise (60ch) pour rester conforme à la maquette d'origine, qui ne l'étirait pas sur toute la largeur de la page. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
573 lines
28 KiB
Python
573 lines
28 KiB
Python
import html as html_lib
|
|
import json
|
|
import random
|
|
from typing import Any
|
|
|
|
|
|
def render_document(elements: list[dict[str, Any]]) -> str:
|
|
"""Assemble le document ENTIER à partir de la liste à plat renvoyée
|
|
par document_engine.list_document_elements : les éléments top-niveau
|
|
(parent_id NULL) dans l'ordre, chaque rangée ("row") rendant
|
|
récursivement ses propres enfants côte à côte. Point d'entrée unique
|
|
du rendu, utilisé à la fois par le canevas d'édition et par le Mode
|
|
Aperçu (même fonction, voir docs/plan/PLAN.md — "Aperçu réel")."""
|
|
children_by_parent: dict[int | None, list[dict[str, Any]]] = {}
|
|
for el in elements:
|
|
children_by_parent.setdefault(el["parent_id"], []).append(el)
|
|
top_level = children_by_parent.get(None, [])
|
|
return "".join(render_document_element(el, children_by_parent) for el in top_level)
|
|
|
|
|
|
def render_document_element(el: dict[str, Any], children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
"""HTML d'UN élément — dispatch par dict plutôt qu'un enchaînement de
|
|
`if` (mirroir de l'esprit de game_engine/scenes/render_scene_object.py,
|
|
mais un vrai registre ici puisque le nombre de kinds est plus élevé)."""
|
|
renderer = _RENDERERS.get(el["kind"], _render_unknown)
|
|
return renderer(el, children_by_parent)
|
|
|
|
|
|
def _render_row(el: dict[str, Any], children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
attrs = el["attributes"]
|
|
gap = attrs.get("gap", 16)
|
|
align = html_lib.escape(str(attrs.get("align", "stretch")))
|
|
justify = html_lib.escape(str(attrs.get("justify", "flex-start")))
|
|
style = f"display:flex; flex-wrap:wrap; gap:{gap}px; align-items:{align}; justify-content:{justify};"
|
|
children = children_by_parent.get(el["id"], [])
|
|
inner = "".join(render_document_element(child, children_by_parent) for child in children)
|
|
return f'<div class="docRow" data-element-id="{el["id"]}" data-kind="row" style="{style}">{inner}</div>'
|
|
|
|
|
|
_STYLE_PRESETS = {
|
|
"titre1": ("clamp(1.6rem,4vw,2rem)", 800, 1.15),
|
|
"titre2": ("1.3rem", 800, 1.25),
|
|
"paragraphe": ("15px", 400, 1.5),
|
|
"legende": ("12.5px", 600, 1.4),
|
|
}
|
|
|
|
|
|
def _render_text(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
a = el["attributes"]
|
|
content = html_lib.escape(str(a.get("content", "")))
|
|
style_name = a.get("style", "paragraphe")
|
|
font_size, base_weight, line_height = _STYLE_PRESETS.get(style_name, _STYLE_PRESETS["paragraphe"])
|
|
weight = 800 if a.get("bold") else base_weight
|
|
font_style = "italic" if a.get("italic") else "normal"
|
|
text_decoration = "underline" if a.get("underline") else "none"
|
|
align = html_lib.escape(str(a.get("align", "left")))
|
|
color = html_lib.escape(str(a.get("color", "var(--forge-text)")))
|
|
style = (
|
|
f"font-size:{font_size}; font-weight:{weight}; line-height:{line_height}; "
|
|
f"font-style:{font_style}; text-decoration:{text_decoration}; text-align:{align}; color:{color};"
|
|
)
|
|
# max_width optionnel (ex. "60ch", "480px") — vide par défaut (pleine
|
|
# largeur de .docPageContent, comportement inchangé). Retour
|
|
# utilisateur du 24/09/2026 : un paragraphe doit pouvoir rester plus
|
|
# étroit que la page, comme un sous-titre sous un grand titre, sans
|
|
# dépendre d'une rangée (qui partagerait la largeur avec un frère).
|
|
max_width = str(a.get("max_width", "")).strip()
|
|
if max_width:
|
|
style += f" max-width:{html_lib.escape(max_width)};"
|
|
return f'<div class="docText" data-element-id="{el["id"]}" data-kind="{el["kind"]}" style="{style}">{content}</div>'
|
|
|
|
|
|
def _render_image(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
a = el["attributes"]
|
|
svg_markup = str(a.get("svg_markup", "")).strip()
|
|
if svg_markup:
|
|
# Contenu vectoriel dessiné/collé par le créateur plutôt qu'un
|
|
# fichier hébergé — prioritaire sur `src` (voir
|
|
# element_kind_labels.element_default_attributes). Nettoyé à
|
|
# CHAQUE rendu (jamais seulement à l'écriture) par sanitize_svg_markup,
|
|
# même défense en profondeur que html.escape sur les autres kinds.
|
|
from .sanitize_svg_markup import sanitize_svg_markup
|
|
|
|
sanitized = sanitize_svg_markup(svg_markup)
|
|
return f'<div class="docImage" data-element-id="{el["id"]}" data-kind="image">{sanitized}</div>'
|
|
src = html_lib.escape(str(a.get("src", "")))
|
|
alt = html_lib.escape(str(a.get("alt", "")))
|
|
if not src:
|
|
return (
|
|
f'<div class="docImage docImagePlaceholder" data-element-id="{el["id"]}" data-kind="image">'
|
|
f"Image — aucun fichier choisi</div>"
|
|
)
|
|
return f'<img class="docImage" data-element-id="{el["id"]}" data-kind="image" src="{src}" alt="{alt}">'
|
|
|
|
|
|
def _render_list(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
"""Liste à puces (<ul>) ou numérotée (<ol>) — le kind lui-même décide
|
|
la balise, pas un attribut "ordered" séparé (voir
|
|
element_kind_labels.element_default_attributes). Une "items" vide
|
|
rend une liste vide plutôt qu'un placeholder : contrairement à une
|
|
image sans fichier, une liste sans élément n'a rien d'anormal à
|
|
afficher (le créateur vient peut-être de tout supprimer avant d'en
|
|
retaper un)."""
|
|
items = el["attributes"].get("items", [])
|
|
tag = "ol" if el["kind"] == "liste_numerotee" else "ul"
|
|
items_html = "".join(f"<li>{html_lib.escape(str(item))}</li>" for item in items)
|
|
return f'<{tag} class="docList" data-element-id="{el["id"]}" data-kind="{el["kind"]}">{items_html}</{tag}>'
|
|
|
|
|
|
def _render_button(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
a = el["attributes"]
|
|
label = html_lib.escape(str(a.get("label", "Bouton")))
|
|
target = html_lib.escape(str(a.get("target", "")))
|
|
target_attr = f' data-target="{target}"' if target else ""
|
|
# `data-attachment-filename` sert UNIQUEMENT de marqueur mécanique : un
|
|
# fichier a bien été joint (voir routes/document/
|
|
# document_element_upload_attachment.py). L'URL de téléchargement
|
|
# elle-même n'est jamais construite ici (ce renderer ne connaît pas le
|
|
# slug du support) — static/document/js/document-editor.js l'assemble
|
|
# à partir de `data-element-id` + FORGE_DOCUMENT.slug, même principe
|
|
# que le reste des appels AJAX de l'éditeur.
|
|
attachment_filename = html_lib.escape(str(a.get("attachment_filename", "")))
|
|
attachment_attr = f' data-attachment-filename="{attachment_filename}"' if attachment_filename else ""
|
|
return (
|
|
f'<button type="button" class="docButton" data-element-id="{el["id"]}" '
|
|
f'data-kind="bouton"{target_attr}{attachment_attr}>{label}</button>'
|
|
)
|
|
|
|
|
|
def _render_badge(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
content = html_lib.escape(str(el["attributes"].get("content", "")))
|
|
return f'<div class="docBadge" data-element-id="{el["id"]}" data-kind="badge">{content}</div>'
|
|
|
|
|
|
def _render_carte(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
a = el["attributes"]
|
|
label = html_lib.escape(str(a.get("label", "")))
|
|
title = html_lib.escape(str(a.get("title", "")))
|
|
description = html_lib.escape(str(a.get("description", "")))
|
|
return (
|
|
f'<div class="docCard" data-element-id="{el["id"]}" data-kind="carte">'
|
|
f'<div class="docCardLabel">{label}</div>'
|
|
f'<div class="docCardTitle">{title}</div>'
|
|
f'<div class="docCardDescription">{description}</div>'
|
|
f"</div>"
|
|
)
|
|
|
|
|
|
def _render_minigame_placeholder(
|
|
el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]
|
|
) -> str:
|
|
from ..labels.element_kind_labels import ELEMENT_KIND_LABELS
|
|
|
|
a = el["attributes"]
|
|
theme_color = html_lib.escape(str(a.get("theme_color", "#ff5f2e")))
|
|
label = html_lib.escape(ELEMENT_KIND_LABELS.get(el["kind"], el["kind"]))
|
|
return (
|
|
f'<div class="docMinigame" data-element-id="{el["id"]}" data-kind="{el["kind"]}" '
|
|
f'style="border-color:{theme_color};">'
|
|
f'<div class="docMinigameBadge">'
|
|
f'<span class="docMinigameLabel">{label}</span>'
|
|
f'<span class="docMinigamePlaceholder">Formulaire de contenu à venir</span>'
|
|
f"</div></div>"
|
|
)
|
|
|
|
|
|
def _render_quiz_player(config: dict[str, Any]) -> str:
|
|
"""Questionnaire RÉELLEMENT interactif — affiché uniquement en Mode
|
|
Aperçu (voir static/document/document-editor.css,
|
|
.docEditor3--preview), pour que le créateur puisse tester son quiz
|
|
avant un futur export (voir docs/plan/maquettes/
|
|
document-formation-web.html, référence visuelle de ce rendu). Les
|
|
questions sont embarquées en JSON dans un attribut data-* (jamais un
|
|
<script> par élément) — static/document/js/document-editor.js les lit
|
|
et gère tout le déroulé (réponse/score/question suivante/résultat)
|
|
côté client, sans aucun aller-retour serveur (une session d'Aperçu
|
|
n'est jamais persistée)."""
|
|
config_json = html_lib.escape(json.dumps({"questions": config["questions"]}), quote=True)
|
|
return (
|
|
f'<div class="docQuizPlayer" data-quiz-config="{config_json}">'
|
|
f'<div class="docQuizCard">'
|
|
f'<div class="docQuizKicker">Quiz</div>'
|
|
f'<div class="docQuizPlayerTitle">Vérifiez vos connaissances</div>'
|
|
f'<div class="docQuizProgressTrack"><div class="docQuizProgressFill"></div></div>'
|
|
f'<div class="docQuizMeta"><span class="docQuizProg"></span><span class="docQuizScore"></span></div>'
|
|
f'<div class="docQuizQuestionText"></div>'
|
|
f'<div class="docQuizOptions"></div>'
|
|
f'<div class="docQuizFeedback"></div>'
|
|
f'<div class="docQuizNextBar"><button type="button" class="docQuizNextBtn">Question suivante</button></div>'
|
|
f"</div>"
|
|
f'<div class="docQuizResultCard" style="display:none;">'
|
|
f'<div class="docQuizResultBig"></div>'
|
|
f'<div class="docQuizResultSub"></div>'
|
|
f'<button type="button" class="docQuizRestartBtn">Recommencer le quiz</button>'
|
|
f"</div></div>"
|
|
)
|
|
|
|
|
|
def _render_quiz(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
from ..labels.quiz_config import quiz_total_points, sanitize_quiz_config
|
|
|
|
config = sanitize_quiz_config(el["attributes"])
|
|
theme_color = html_lib.escape(str(config["theme_color"]))
|
|
question_count = len(config["questions"])
|
|
question_label = "question" if question_count <= 1 else "questions"
|
|
total_points = quiz_total_points(config)
|
|
timer_note = f" · ⏱ {config['timer_seconds']}s/question" if config["timer_enabled"] else ""
|
|
subtitle = f"{question_count} {question_label} · {total_points} points{timer_note}"
|
|
player_html = _render_quiz_player(config) if config["questions"] else ""
|
|
return (
|
|
f'<div class="docMinigame" data-element-id="{el["id"]}" data-kind="quiz" '
|
|
f'style="border-color:{theme_color};">'
|
|
f'<div class="docMinigameBadge">'
|
|
f'<span class="docMinigameLabel">Quiz</span>'
|
|
f'<span class="docMinigamePlaceholder">{html_lib.escape(subtitle)}</span>'
|
|
f"</div>"
|
|
f"{player_html}"
|
|
f"</div>"
|
|
)
|
|
|
|
|
|
def _render_association_player(config: dict[str, Any]) -> str:
|
|
"""Plateau de glisser-déposer RÉELLEMENT interactif — affiché
|
|
uniquement en Mode Aperçu, même principe que _render_quiz_player :
|
|
aucun aller-retour serveur, tout le déroulé (glisser une carte de
|
|
gauche sur son emplacement de droite, ou cliquer les deux) est géré
|
|
par static/document/js/document-editor.js à partir du JSON embarqué.
|
|
Les deux colonnes sont mélangées INDÉPENDAMMENT (sinon la position
|
|
suffirait à deviner l'association, sans avoir à lire quoi que ce
|
|
soit) — random.shuffle : mélange d'affichage pour un mini-jeu,
|
|
jamais un usage cryptographique (voir CODE_QUALITY.md)."""
|
|
pairs = config["pairs"]
|
|
left_items = [{"pair_index": i, "text": p["left"]} for i, p in enumerate(pairs)]
|
|
right_items = [{"pair_index": i, "text": p["right"]} for i, p in enumerate(pairs)]
|
|
random.shuffle(left_items) # NOSONAR python:S2245 - melange d'affichage, pas un usage cryptographique
|
|
random.shuffle(right_items) # NOSONAR python:S2245 - idem
|
|
config_json = html_lib.escape(json.dumps({"left": left_items, "right": right_items}), quote=True)
|
|
return (
|
|
f'<div class="docAssocPlayer" data-assoc-config="{config_json}">'
|
|
f'<div class="docAssocCard">'
|
|
f'<div class="docQuizKicker">Association</div>'
|
|
f'<div class="docAssocTitle">Associez chaque élément à sa correspondance</div>'
|
|
f'<div class="docAssocMeta"><span class="docAssocProg"></span></div>'
|
|
f'<div class="docAssocBoard">'
|
|
f'<div class="docAssocColumn docAssocColumnLeft"></div>'
|
|
f'<div class="docAssocColumn docAssocColumnRight"></div>'
|
|
f"</div>"
|
|
f'<div class="docAssocFeedback"></div>'
|
|
# Le plateau reste affiché une fois toutes les paires trouvées
|
|
# (voir docs/plan/PLAN.md, retour utilisateur du 20/09/2026) —
|
|
# seul ce bouton apparaît (.is-visible posé par
|
|
# forgeDocAssociationMatchResult), jamais un écran de résultat
|
|
# séparé qui remplacerait le plateau (ça reste le comportement du
|
|
# Quiz, seul mini-jeu concerné par un écran de fin distinct).
|
|
f'<div class="docMinigameRestartBar">'
|
|
f'<button type="button" class="docAssocRestartBtn">Recommencer</button>'
|
|
f"</div>"
|
|
f"</div></div>"
|
|
)
|
|
|
|
|
|
def _render_association(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
from ..labels.association_config import sanitize_association_config
|
|
|
|
config = sanitize_association_config(el["attributes"])
|
|
theme_color = html_lib.escape(str(config["theme_color"]))
|
|
pair_count = len(config["pairs"])
|
|
pair_label = "paire" if pair_count <= 1 else "paires"
|
|
player_html = _render_association_player(config) if config["pairs"] else ""
|
|
return (
|
|
f'<div class="docMinigame" data-element-id="{el["id"]}" data-kind="association" '
|
|
f'style="border-color:{theme_color};">'
|
|
f'<div class="docMinigameBadge">'
|
|
f'<span class="docMinigameLabel">Association</span>'
|
|
f'<span class="docMinigamePlaceholder">{pair_count} {pair_label}</span>'
|
|
f"</div>"
|
|
f"{player_html}"
|
|
f"</div>"
|
|
)
|
|
|
|
|
|
def _render_memory_player(config: dict[str, Any]) -> str:
|
|
"""Plateau de Memory RÉELLEMENT interactif — affiché uniquement en
|
|
Mode Aperçu, même principe que _render_quiz_player/
|
|
_render_association_player. En mode "paire", chaque carte définie par
|
|
le créateur est dupliquée en deux instances partageant le même
|
|
card_index (l'appariement se fait dessus) ; en mode "single", une
|
|
seule instance par carte (simple retournement, sans appariement).
|
|
Les instances sont mélangées une seule fois ici (jamais recalculées
|
|
à chaque rendu répété d'un même Aperçu, voir la remarque dans
|
|
static/document/js/document-editor.js sur la ré-init au
|
|
rafraîchissement du canevas) puis embarquées en JSON."""
|
|
cards = config["cards"]
|
|
mode = config["mode"]
|
|
instances = []
|
|
for i, card in enumerate(cards):
|
|
instances.append({"card_index": i, "recto": card["recto"], "verso": card["verso"]})
|
|
if mode == "paire":
|
|
instances.append({"card_index": i, "recto": card["recto"], "verso": card["verso"]})
|
|
random.shuffle(instances) # NOSONAR python:S2245 - melange d'affichage, pas un usage cryptographique
|
|
config_json = html_lib.escape(json.dumps({"mode": mode, "cards": instances}), quote=True)
|
|
return (
|
|
f'<div class="docMemoryPlayer" data-memory-config="{config_json}">'
|
|
f'<div class="docMemoryCardWrap">'
|
|
f'<div class="docQuizKicker">Memory</div>'
|
|
f'<div class="docAssocTitle docMemoryTitle"></div>'
|
|
f'<div class="docAssocMeta"><span class="docMemoryProg"></span></div>'
|
|
f'<div class="docMemoryGrid"></div>'
|
|
# Même choix que l'Association ci-dessus : le plateau reste
|
|
# affiché une fois le jeu terminé, seul ce bouton apparaît.
|
|
f'<div class="docMinigameRestartBar">'
|
|
f'<button type="button" class="docMemoryRestartBtn">Recommencer</button>'
|
|
f"</div>"
|
|
f"</div></div>"
|
|
)
|
|
|
|
|
|
def _render_memory(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
from ..labels.memory_config import sanitize_memory_config
|
|
|
|
config = sanitize_memory_config(el["attributes"])
|
|
theme_color = html_lib.escape(str(config["theme_color"]))
|
|
card_count = len(config["cards"])
|
|
card_label = "carte" if card_count <= 1 else "cartes"
|
|
mode_label = "mode paire" if config["mode"] == "paire" else "mode simple"
|
|
subtitle = f"{card_count} {card_label} · {mode_label}"
|
|
player_html = _render_memory_player(config) if config["cards"] else ""
|
|
return (
|
|
f'<div class="docMinigame" data-element-id="{el["id"]}" data-kind="memory" '
|
|
f'style="border-color:{theme_color};">'
|
|
f'<div class="docMinigameBadge">'
|
|
f'<span class="docMinigameLabel">Memory</span>'
|
|
f'<span class="docMinigamePlaceholder">{html_lib.escape(subtitle)}</span>'
|
|
f"</div>"
|
|
f"{player_html}"
|
|
f"</div>"
|
|
)
|
|
|
|
|
|
_MOTS_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
_MOTS_DIRECTIONS = (
|
|
(0, 1), # horizontale, gauche -> droite
|
|
(1, 0), # verticale, haut -> bas
|
|
(1, 1), # diagonale droite, haut-gauche -> bas-droite
|
|
(1, -1), # diagonale gauche, haut-droite -> bas-gauche
|
|
)
|
|
_MOTS_MAX_PLACEMENT_ATTEMPTS = 200
|
|
_MOTS_MAX_GRID_GROWTH_ATTEMPTS = 20
|
|
|
|
|
|
def _mots_grid_size_for_words(words: list[str]) -> int:
|
|
"""Taille de départ de la grille (carrée) — assez grande pour loger le
|
|
plus long mot ET laisser assez de cases libres pour le remplissage
|
|
aléatoire, sans grille disproportionnée pour une courte liste de mots.
|
|
_build_mots_grid grandit cette taille si le placement échoue malgré
|
|
tout (mots qui se contraignent mutuellement), donc une estimation
|
|
approximative suffit ici."""
|
|
from ..labels.mots_config import MIN_WORD_LENGTH
|
|
|
|
longest = max((len(w) for w in words), default=MIN_WORD_LENGTH)
|
|
total_letters = sum(len(w) for w in words)
|
|
return max(longest, 8, int(total_letters**0.5) + 2)
|
|
|
|
|
|
def _mots_can_place_word(
|
|
grid: list[list[str]], word: str, row: int, col: int, delta_row: int, delta_col: int, size: int
|
|
) -> bool:
|
|
for i, letter in enumerate(word):
|
|
r, c = row + i * delta_row, col + i * delta_col
|
|
if not (0 <= r < size and 0 <= c < size):
|
|
return False
|
|
if grid[r][c] not in ("", letter):
|
|
return False
|
|
return True
|
|
|
|
|
|
def _mots_place_word(grid: list[list[str]], word: str, size: int) -> list[list[int]] | None:
|
|
"""None si aucun emplacement libre n'a été trouvé après le nombre
|
|
d'essais autorisé — laisse l'appelant décider (agrandir la grille et
|
|
tout retenter, voir _build_mots_grid) plutôt que de placer le mot de
|
|
force en écrasant des lettres déjà posées."""
|
|
for _ in range(_MOTS_MAX_PLACEMENT_ATTEMPTS):
|
|
delta_row, delta_col = random.choice(_MOTS_DIRECTIONS) # nosec B311 # noqa: S311 - placement de mot, jamais crypto # NOSONAR python:S2245
|
|
row = random.randint(0, size - 1) # nosec B311 # noqa: S311 - idem # NOSONAR python:S2245
|
|
col = random.randint(0, size - 1) # nosec B311 # noqa: S311 - idem # NOSONAR python:S2245
|
|
if not _mots_can_place_word(grid, word, row, col, delta_row, delta_col, size):
|
|
continue
|
|
cells = []
|
|
for i, letter in enumerate(word):
|
|
r, c = row + i * delta_row, col + i * delta_col
|
|
grid[r][c] = letter
|
|
cells.append([r, c])
|
|
return cells
|
|
return None
|
|
|
|
|
|
def _mots_attempt_placement(words: list[str], size: int) -> dict[str, Any] | None:
|
|
grid: list[list[str]] = [["" for _ in range(size)] for _ in range(size)]
|
|
placed_words = []
|
|
# Les mots les plus longs sont placés en premier : ce sont les plus
|
|
# difficiles à caser, autant le faire tant que la grille est encore
|
|
# majoritairement libre.
|
|
for word in sorted(words, key=len, reverse=True):
|
|
cells = _mots_place_word(grid, word, size)
|
|
if cells is None:
|
|
return None
|
|
placed_words.append({"text": word, "cells": cells})
|
|
for r in range(size):
|
|
for c in range(size):
|
|
if not grid[r][c]:
|
|
grid[r][c] = random.choice(_MOTS_ALPHABET) # nosec B311 # noqa: S311 - lettre de remplissage, jamais crypto # NOSONAR python:S2245
|
|
return {"size": size, "grid": grid, "words": placed_words}
|
|
|
|
|
|
def _build_mots_grid(words: list[str]) -> dict[str, Any]:
|
|
"""Construit la grille ET la position exacte de chaque mot (jamais
|
|
recalculée côté client, voir _render_mots_player) : une grille carrée,
|
|
chaque mot placé horizontalement/verticalement/en diagonale (deux sens
|
|
de diagonale seulement, jamais à l'envers — voir _MOTS_DIRECTIONS),
|
|
les cases restantes remplies de lettres aléatoires. Si un mot ne
|
|
trouve pas sa place (mots qui se contraignent mutuellement), la
|
|
grille entière est agrandie et le placement retenté depuis zéro,
|
|
plutôt que d'abandonner silencieusement ce mot."""
|
|
if not words:
|
|
return {"size": 0, "grid": [], "words": []}
|
|
size = _mots_grid_size_for_words(words)
|
|
for _ in range(_MOTS_MAX_GRID_GROWTH_ATTEMPTS):
|
|
result = _mots_attempt_placement(words, size)
|
|
if result is not None:
|
|
return result
|
|
size += 2
|
|
# Filet de sécurité théorique : avec MAX_WORDS=10 mots de
|
|
# MAX_WORD_LENGTH=20 lettres au plus, la grille finit toujours par
|
|
# être assez grande pour tous les loger bien avant cette limite.
|
|
return _mots_attempt_placement(words, size) or {"size": size, "grid": [], "words": []}
|
|
|
|
|
|
def _render_mots_player(config: dict[str, Any]) -> str:
|
|
"""Grille de mots mêlés RÉELLEMENT interactive — affichée uniquement
|
|
en Mode Aperçu, même principe que les autres mini-jeux : la grille ET
|
|
la position exacte de chaque mot sont calculées ICI côté serveur
|
|
(_build_mots_grid, jamais recalculées côté client) puis embarquées en
|
|
JSON ; static/document/js/document-editor.js compare les coordonnées
|
|
de la sélection de l'apprenant aux coordonnées exactes de chaque mot
|
|
— jamais une simple comparaison de texte, qui se tromperait sur des
|
|
lettres partagées entre deux mots qui se croisent."""
|
|
built = _build_mots_grid(config["words"])
|
|
config_json = html_lib.escape(json.dumps(built), quote=True)
|
|
return (
|
|
f'<div class="docMotsPlayer" data-mots-config="{config_json}">'
|
|
f'<div class="docAssocCard">'
|
|
f'<div class="docQuizKicker">Mots mêlés</div>'
|
|
f'<div class="docAssocTitle">Retrouvez chaque mot caché dans la grille</div>'
|
|
f'<div class="docAssocMeta"><span class="docMotsProg"></span></div>'
|
|
f'<div class="docMotsBoard">'
|
|
f'<div class="docMotsGrid"></div>'
|
|
f'<div class="docMotsWordList"></div>'
|
|
f"</div>"
|
|
f'<div class="docMinigameRestartBar">'
|
|
f'<button type="button" class="docMotsRestartBtn">Recommencer</button>'
|
|
f"</div>"
|
|
f"</div></div>"
|
|
)
|
|
|
|
|
|
def _render_mots(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
from ..labels.mots_config import sanitize_mots_config
|
|
|
|
config = sanitize_mots_config(el["attributes"])
|
|
theme_color = html_lib.escape(str(config["theme_color"]))
|
|
word_count = len(config["words"])
|
|
word_label = "mot" if word_count <= 1 else "mots"
|
|
player_html = _render_mots_player(config) if config["words"] else ""
|
|
return (
|
|
f'<div class="docMinigame" data-element-id="{el["id"]}" data-kind="mots" '
|
|
f'style="border-color:{theme_color};">'
|
|
f'<div class="docMinigameBadge">'
|
|
f'<span class="docMinigameLabel">Mots mêlés</span>'
|
|
f'<span class="docMinigamePlaceholder">{word_count} {word_label}</span>'
|
|
f"</div>"
|
|
f"{player_html}"
|
|
f"</div>"
|
|
)
|
|
|
|
|
|
def _render_scenario_player(config: dict[str, Any]) -> str:
|
|
"""Mise en situation RÉELLEMENT interactive — affichée uniquement en
|
|
Mode Aperçu, même principe que les autres mini-jeux : aucun
|
|
aller-retour serveur, tout le déroulé (navigation dans l'arbre de
|
|
décision, scénario suivant) est géré par static/document/js/
|
|
document-editor.js à partir du JSON embarqué (voir scenario_config.py
|
|
pour la forme exacte d'un scénario : {"title", "nodes"}, nodes[0]
|
|
étant la situation initiale). Les scénarios (plusieurs arbres
|
|
indépendants) gardent l'ORDRE d'écriture du créateur (contrairement à
|
|
l'Association/Memory/Mots mêlés, jamais mélangés) : ce sont des mises
|
|
en situation séquentielles, pas des éléments à faire correspondre ou
|
|
retrouver — un mélange n'aurait ici aucun sens pédagogique. Un seul
|
|
bloc de texte (.docScenarioSituation) sert successivement à afficher
|
|
le texte de chaque nœud visité : une fois un choix fait, le texte du
|
|
nœud suivant REMPLACE le précédent (les boutons de choix disparaissent
|
|
avec lui) — volontairement PAS le comportement du Quiz, où la
|
|
question resterait affichée à côté d'un encart de feedback séparé.
|
|
Aucune notion de bonne/mauvaise réponse ici (retour utilisateur du
|
|
20/09/2026 : "il n'y a pas de notion vrai/faux, l'utilisateur observe
|
|
les conséquences") — un nœud sans choix est simplement une fin de
|
|
branche. Réutilise les classes visuelles du Quiz
|
|
(.docQuizOptions/.docQuizNextBar/.docQuizQuestionText) plutôt que de
|
|
dupliquer ces règles, même esprit que .docAssocCard/
|
|
.docMinigameRestartBar."""
|
|
config_json = html_lib.escape(json.dumps({"scenarios": config["scenarios"]}), quote=True)
|
|
return (
|
|
f'<div class="docScenarioPlayer" data-scenario-config="{config_json}">'
|
|
f'<div class="docAssocCard">'
|
|
f'<div class="docQuizKicker">Scénario</div>'
|
|
f'<div class="docAssocMeta"><span class="docScenarioProg"></span></div>'
|
|
f'<div class="docScenarioSituation docQuizQuestionText"></div>'
|
|
f'<div class="docScenarioChoices docQuizOptions"></div>'
|
|
f'<div class="docQuizNextBar">'
|
|
f'<button type="button" class="docQuizNextBtn docScenarioNextBtn">Scénario suivant</button>'
|
|
f"</div>"
|
|
# Même choix que l'Association/Memory/Mots mêlés : le dernier
|
|
# scénario reste affiché une fois répondu, seul ce bouton
|
|
# apparaît (jamais un écran de résultat séparé — ça reste le
|
|
# comportement du Quiz).
|
|
f'<div class="docMinigameRestartBar">'
|
|
f'<button type="button" class="docScenarioRestartBtn">Recommencer</button>'
|
|
f"</div>"
|
|
f"</div></div>"
|
|
)
|
|
|
|
|
|
def _render_scenario(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
from ..labels.scenario_config import sanitize_scenario_config
|
|
|
|
config = sanitize_scenario_config(el["attributes"])
|
|
theme_color = html_lib.escape(str(config["theme_color"]))
|
|
scenario_count = len(config["scenarios"])
|
|
scenario_label = "scénario" if scenario_count <= 1 else "scénarios"
|
|
player_html = _render_scenario_player(config) if config["scenarios"] else ""
|
|
return (
|
|
f'<div class="docMinigame" data-element-id="{el["id"]}" data-kind="scenario" '
|
|
f'style="border-color:{theme_color};">'
|
|
f'<div class="docMinigameBadge">'
|
|
f'<span class="docMinigameLabel">Scénario</span>'
|
|
f'<span class="docMinigamePlaceholder">{scenario_count} {scenario_label}</span>'
|
|
f"</div>"
|
|
f"{player_html}"
|
|
f"</div>"
|
|
)
|
|
|
|
|
|
def _render_unknown(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
|
|
return f'<div class="docUnknown" data-element-id="{el["id"]}">Type inconnu : {html_lib.escape(el["kind"])}</div>'
|
|
|
|
|
|
_RENDERERS = {
|
|
"row": _render_row,
|
|
"titre": _render_text,
|
|
"paragraphe": _render_text,
|
|
"image": _render_image,
|
|
"bouton": _render_button,
|
|
"liste_puces": _render_list,
|
|
"liste_numerotee": _render_list,
|
|
"badge": _render_badge,
|
|
"carte": _render_carte,
|
|
"quiz": _render_quiz,
|
|
"association": _render_association,
|
|
"memory": _render_memory,
|
|
"mots": _render_mots,
|
|
"scenario": _render_scenario,
|
|
"zones": _render_minigame_placeholder,
|
|
}
|