diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..70a0e79 --- /dev/null +++ b/.env.example @@ -0,0 +1,8 @@ +DB_HOST=127.0.0.1 +DB_PORT=15432 +DB_NAME=fallout +DB_USER=fallout +DB_PASS= +OLLAMA_URL=http://host.docker.internal:11434 +MODEL_MJ=qwen2.5:14b +MODEL_PNJ=qwen2.5:7b diff --git a/.gitignore b/.gitignore index df60c42..4601cd9 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,4 @@ __pycache__/ .DS_Store Thumbs.db INFRA_PRIVATE.md +.env diff --git a/dashboard/app.py b/dashboard/app.py index f8f24e0..3dca479 100644 --- a/dashboard/app.py +++ b/dashboard/app.py @@ -1,16 +1,65 @@ """ -VAULTCOM — Fallout: Venice of Wasteland -Dashboard simulation. Schéma DB actuel (migration_003). -Onglets: Simulation (par session) | Paramètres (config + restart) +PipBoy — Fallout: Venice of Wasteland +Dashboard unifié : Simulation | Outils | Lore enrichment | Paramètres +(anciennement VAULTCOM) """ -import os, json, subprocess +import os, json, subprocess, threading, time import psycopg2 import psycopg2.extras from flask import Flask, render_template_string, jsonify, request, redirect, url_for app = Flask(__name__) +# --------------------------------------------------------------------------- +# Stress test — état global (un seul test à la fois) +# --------------------------------------------------------------------------- +_stress_state = { + "running": False, + "started_at": None, + "mode": None, + "rounds": None, + "pnj_count": None, + "output": [], # lignes de stdout + "returncode": None, + "error": None, +} +_stress_lock = threading.Lock() + +def _run_stress_bg(mode: str, rounds: int, pnj_count: int): + global _stress_state + ollama_url = os.getenv("OLLAMA_URL", "http://host.docker.internal:11434") + model_mj = os.getenv("MODEL_MJ", "qwen2.5:14b") + model_pnj = os.getenv("MODEL_PNJ", "qwen2.5:7b") + results_path = os.path.join(SIM_CONFIGS_DIR, "crash_results.json") + + cmd = [ + "python3", "/app/tools/llm_crash_test.py", + "--mode", mode, + "--rounds", str(rounds), + "--pnj-count", str(pnj_count), + ] + env = {**os.environ, + "OLLAMA_URL": ollama_url, + "MODEL_MJ": model_mj, + "MODEL_PNJ": model_pnj, + "CRASH_RESULTS_PATH": results_path, + "PYTHONUNBUFFERED": "1"} + try: + proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + text=True, env=env) + for line in proc.stdout: + with _stress_lock: + _stress_state["output"].append(line.rstrip()) + proc.wait() + with _stress_lock: + _stress_state["returncode"] = proc.returncode + _stress_state["running"] = False + except Exception as e: + with _stress_lock: + _stress_state["error"] = str(e) + _stress_state["running"] = False + DB_HOST = os.getenv("DB_HOST", "localhost") DB_PORT = int(os.getenv("DB_PORT", 5432)) DB_NAME = os.getenv("DB_NAME", "fallout") @@ -80,172 +129,573 @@ TEMPLATE = r""" -VAULTCOM — Fallout: Venice of Wasteland +PipBoy — Fallout: Venice of Wasteland -

⚡ VAULTCOM — VENICE OF WASTELAND ⚡

- -
- {% for s in all_sessions %} - - S{{ s.id }} — {{ s.name[:22] }} - - ● {{ s.status[:3].upper() }} - - - {% endfor %} + +
+ 📟 PIPBOY +
+ {% for s in all_sessions %} + {% set is_active = s.status == 'active' %} + + + S{{ s.id }} + + {% endfor %} +
- 📡 SIMULATION - ⚙ PARAMÈTRES - 📜 LORE +
+ 📡 SIM + 🔧 OUTILS + 📜 LORE + ⚙ PARAMS +
{% if flash_msg %} -
- {{ flash_msg }} -
+
{{ flash_msg }}
{% endif %} +
+ {% if tab == 'sim' %} {% if session %} -
- SESSION #{{ session.id }} — {{ session.name }} - JOUR {{ session.current_day }} / TICK {{ session.current_tick }}h - {{ session.mode | upper }} - STATUS: {{ session.status | upper }} - SEED: {{ session.seed_global }} - 🔄 Actualiser - +
+ Session #{{ session.id }} — {{ session.name }} + Jour {{ session.current_day }} / Tick {{ session.current_tick }}h + {{ session.mode | upper }} + {% set st = session.status %} + + + {{ st | upper }} + + Seed: {{ session.seed_global }} + + ↻ Actualiser + +
{% endif %} + +
+
+
PNJ Vivants
+
{{ alive_count }}
+
+
+
PNJ Morts
+
{{ stats.get('PNJ morts', 0) }}
+
+
+
Total PNJ
+
{{ total_count }}
+
+
+
Combats
+
{{ stats.get('Combats', 0) }}
+
+
+
Rencontres
+
{{ stats.get('Rencontres', 0) }}
+
+
+
Événements
+
{{ stats.get('Événements total', 0) }}
+
+
+
-

👥 PNJ ACTIFS ({{ alive_count }}/{{ total_count }})

+

👥 PNJ ({{ alive_count }}/{{ total_count }})

- + {% for c in characters %} - + {% set pct = (c.hp / c.max_hp * 100) | int if c.max_hp else 0 %} + - - + + {% endfor %}
TIERNOMPVFACTIONZONECAPS
TierNomPVFactionZoneCaps
- {% if c.tier == 0 %}★BOSS - {% elif c.tier == 2 %}◈ T2 - {% elif c.tier == 3 %}· T3 - {% else %}● T1{% endif %} + {% if c.tier == 0 %}★ BOSS + {% elif c.tier == 2 %}T2 + {% elif c.tier == 3 %}T3 + {% else %}T1{% endif %} {{ c.name }} {% if c.is_alive %} - {% set pct = (c.hp / c.max_hp * 100) | int if c.max_hp else 0 %} -
- {{ c.hp }}/{{ c.max_hp }} - {% else %}†{% endif %} + {{ c.hp }}/{{ c.max_hp }} + {% else %}†{% endif %} 		{% set f = c.faction_slug or 'sans' %} - - {{ f[:12] }} + {{ f[:14] }} {{ (c.location_slug or '—')[:14] }}{{ c.caps }}¢{{ (c.location_slug or '—')[:16] }}{{ c.caps }}¢
@@ -254,18 +704,18 @@ TEMPLATE = r"""
-

📡 ÉVÉNEMENTS RÉCENTS

+

📡 Événements récents

- + {% for ev in events %} - - - + + + {% endfor %} - {% if not events %}{% endif %} + {% if not events %}{% endif %}
J/TTYPEDESCRIPTION
J/TTypeDescription
{{ ev.day }}/{{ ev.tick }}{{ ev.event_type }}{{ ev.description[:80] }}{% if ev.description|length > 80 %}…{% endif %}{{ ev.day }}/{{ ev.tick }}{{ ev.event_type }}{{ ev.description[:90] }}{% if ev.description|length > 90 %}…{% endif %}
Aucun événement
Aucun événement
@@ -274,109 +724,103 @@ TEMPLATE = r"""
-

🗺 ÉTAT DU MONDE

+

🗺 État du monde

{% for ws in world_state %}
{{ ws.location_slug }} - - 🍖
 - 💧
 - 🛡
 - 👤{{ ws.pop_count or 0 }} + + 🍖 {{ ws.food_level or 0 }}% + 💧 {{ ws.water_level or 0 }}% + 🛡 {{ ws.security_level or 0 }}% + 👤 {{ ws.pop_count or 0 }}
{% endfor %} - {% if not world_state %}

Pas de données monde

{% endif %} + {% if not world_state %}

Pas de données monde

{% endif %}
-

⚔ RELATIONS FACTIONS

+

⚔ Relations factions

- + {% for r in faction_relations %} + {% set cls = 'rel-hostile' if r.relation_score < -20 else 'rel-allie' if r.relation_score > 20 else 'rel-neutral' %} - - - - + + + + {% endfor %} - {% if not faction_relations %}{% endif %} + {% if not faction_relations %}{% endif %}
FACTION AFACTION BSCOREÉTAT
Faction AFaction BScoreÉtat
{{ r.faction_a[:12] }}{{ r.faction_b[:12] }} - {{ r.relation_score }} - {{ r.relation_label or ('HOSTILE' if r.relation_score < -20 else 'ALLIÉ' if r.relation_score > 20 else 'NEUTRE') }} - {{ r.faction_a[:14] }}{{ r.faction_b[:14] }}{{ r.relation_score }}{{ r.relation_label or ('HOSTILE' if r.relation_score < -20 else 'ALLIÉ' if r.relation_score > 20 else 'NEUTRE') }}
Pas de données
Pas de données
- +
-

📊 STATS SIMULATION

- - - {% for k, v in stats.items() %} - - {% endfor %} -
MÉTRIQUEVALEUR
{{ k }}{{ v }}
-
-

🎭 PNJ PAR TIER

- - +

🎭 PNJ par tier

+
TIERLABELVIVANTSMORTS
+ {% for row in tier_stats %} - - - + + + + + {% endfor %}
TierLabelVivantsMorts
{{ row.tier }}{{ row.label }}{{ row.alive }}{{ row.dead }}
{{ row.tier }}{{ row.label }}{{ row.alive }}{{ row.dead }}
-
-

🏙 PNJ PAR ZONE (TOP 5)

+

🏙 PNJ par zone (top 5)

- + {% for row in zone_stats %} - + + + + {% endfor %}
ZONEPNJ
ZonePNJ
{{ row.location_slug }}{{ row.cnt }}
{{ row.location_slug }}{{ row.cnt }}
-
-

⚡ RENCONTRES RÉCENTES

-
+
+

⚡ Rencontres récentes

+
- + {% for ev in encounters %} - - - - - + + + + + {% endfor %} - {% if not encounters %}{% endif %} + {% if not encounters %}{% endif %}
J/TTYPEACTEURZONEDESCRIPTION
J/TTypeActeurZoneDescription
{{ ev.day }}/{{ ev.tick }}{{ ev.event_type }}{{ ev.actor_name or '—' }}{{ (ev.location_slug or '—')[:14] }}{{ ev.description[:90] }}{% if ev.description|length > 90 %}…{% endif %}{{ ev.day }}/{{ ev.tick }}{{ ev.event_type }}{{ ev.actor_name or '—' }}{{ (ev.location_slug or '—')[:16] }}{{ ev.description[:90] }}{% if ev.description|length > 90 %}…{% endif %}
Aucune rencontre
Aucune rencontre
{% if boss_inventory %} -
-

★ ÉQUIPEMENT CHEFS DE FACTION

+
+

★ Équipement chefs de faction

- + {% for row in boss_inventory %} - + - + - + {% endfor %}
BOSSITEMTYPEQTÉÉQUIPÉ
BossItemTypeQtéÉquipé
{{ row.char_name }}{{ row.char_name }} {{ row.item_name }}{{ row.item_type }}{{ row.item_type }} {{ row.quantity }}{{ '✓' if row.is_equipped else '' }}{{ '✓' if row.is_equipped else '' }}
@@ -384,7 +828,6 @@ TEMPLATE = r""" {% endif %} +{% elif tab == 'tools' %} + + + + + + + +
+

🚀 Lancer une simulation

+
+ +
+ {% for s in all_sessions %} + + {% endfor %} +
+
+
+ + +
+
+ +
+ + + + +
+ +
+
+ +
+
+
+ 

+    

+  

+

+
+
+

+  
📚 Lancer un enrichissement lore

+  

+    
+    
+  

+  

+    
+  

+  

+    

+      

+    

+  

+

+
+
+

+  
⚡ Stress Test LLM

+  

+    
+    

+      
+      
+      
+      
+    

+  

+  

+    
+    

+      
+      
+      
+    

+  

+  

+    
+    

+      
+      
+      
+    

+  

+  

+    
+    
+    
+    
+  

+  
+  
+  
+  
+  
+  

+

+
+
+
 {% elif tab == 'lore' %}
 
 
 
-
 
-

-  📜 ENRICHISSEMENT LORE — VENICE OF WASTELAND
-  
-    En attente : {{ lore_stats.pending }}
-    Acceptées : {{ lore_stats.accepted }}
-    Rejetées : {{ lore_stats.rejected }}
-    Modifiées : {{ lore_stats.modified }}
-  
+

+  📜 Enrichissement Lore — Venice of Wasteland
+  

+    En attente : {{ lore_stats.pending }}
+    Acceptées : {{ lore_stats.accepted }}
+    Rejetées : {{ lore_stats.rejected }}
+    Modifiées : {{ lore_stats.modified }}
+  

 

 
 

@@ -445,19 +1161,19 @@ if (el) {
   
   
   
-  {{ proposals|length }} proposition(s) affichée(s)
+  {{ proposals|length }} proposition(s) affichée(s)
 

 
 {% if not proposals %}
-

+

   Aucune proposition lore.

-  Lancer : python3 lore_enricher.py --faction grand_krewe sur Ampère
+  Lancer : python3 lore_enricher.py --faction grand_krewe sur Ampère
 

 {% endif %}
 
@@ -465,22 +1181,22 @@ if (el) {
 

   

     #{{ p.id }}
-    {{ p.status | upper }}
+    {{ p.status | upper }}
     {{ p.change_type }}
-    {{ p.faction_slug }}
+    {{ p.faction_slug }}
     {% if p.field_path %}{{ p.field_path }}{% endif %}
-    {{ p.created_at.strftime('%d/%m %H:%M') if p.created_at else '' }}
+    {{ p.created_at.strftime('%d/%m %H:%M') if p.created_at else '' }}
   

 
   
{{ p.rationale or '(pas de justification)' }}

 
   

     

-      
ORIGINAL

+      
Original

       
{{ p.original_text or '(ajout — pas de texte original)' }}

     

     

-      
PROPOSÉ

+      
Proposé

       
{{ p.proposed_text }}

     

   

@@ -492,28 +1208,28 @@ if (el) {
       
       
       
-      
+      
     
     

       
       
       
       
-      
+      
     

-    

+    
       
       
       
       
       
-      
+      
     

   

   {% elif p.status == 'modified' and p.modified_text %}
-  

-    
TEXTE MODIFIÉ ACCEPTÉ

-    
{{ p.modified_text }}

+  

+    
Texte modifié accepté

+    
{{ p.modified_text }}

   

   {% endif %}
 

@@ -525,11 +1241,15 @@ if (el) {
 
 
 {% if session %}
-

-  SESSION #{{ session.id }} — {{ session.name }}
-  {{ session.mode | upper }}
-  STATUS: {{ session.status | upper }}
-  JOUR {{ session.current_day }} / TICK {{ session.current_tick }}h
+

+  Session #{{ session.id }} — {{ session.name }}
+  {{ session.mode | upper }}
+  {% set st = session.status %}
+  
+    
+    {{ st | upper }}
+  
+  Jour {{ session.current_day }} / Tick {{ session.current_tick }}h
 

 {% endif %}
 
@@ -537,12 +1257,12 @@ if (el) {
 
   
   

-    
⚙ CONFIG SIM_{{ '%03d' % current_sid }}.JSON

+    
⚙ Config sim_{{ '%03d' % current_sid }}.json

     

     {% if cfg is not none %}
 
       

-        
GÉNÉRAL

+        
Général

         

           
           
@@ -562,7 +1282,7 @@ if (el) {
       

 
       

-        
SURVIE

+        
Survie

         

           
           
@@ -578,7 +1298,7 @@ if (el) {
       

 
       

-        
RENCONTRES

+        
Rencontres

         

           
           
@@ -590,23 +1310,23 @@ if (el) {
       

 
       

-        
ÉCONOMIE

+        
Économie

         

           
           
         

       

 
-      
-      

-        ⚠ Prise en compte au prochain jour (J{{ (session.current_day or 0) + 1 }}).
+      
+      

+        Prise en compte au prochain jour (J{{ (session.current_day or 0) + 1 }}).
         Pour effet immédiat : STOP → relancer via terminal.
       

     {% else %}
-      

+      

         Fichier sim_{{ '%03d' % current_sid }}.json introuvable dans {{ sim_configs_dir }}
       

-      

+      

         Vérifier le mount Docker : /home/ubuntu/fallout-venice/src/config → /app/src/config
       

     {% endif %}
@@ -615,31 +1335,31 @@ if (el) {
 
   
   

-    
🔧 GESTION SESSION #{{ current_sid }}

+    
🔧 Gestion session #{{ current_sid }}

 
     

-      
STATUT DB

-      
-        
-        
-      
-       
-      

-        
-        
-      

-       
-      

-        
-        
-      

-      

-        Note: ne tue pas le process Python. Mettre "paused" ou "stopped" fait sortir run.py au prochain tick.
+      
Statut DB

+      

+        

+          
+          
+        

+        

+          
+          
+        

+        

+          
+          
+        

+      

+      

+        STOP → la sim s'arrête dans les 5 ticks suivants. Puis RESET JOUR/TICK → relancer via terminal.
       

     

 
     

-      
RESET JOUR/TICK

+      
Reset jour/tick

       

         

           
@@ -649,44 +1369,52 @@ if (el) {
           
           
         

-        
+        
       

     

 
     

-      
MODES DISPONIBLES

+      
Modes disponibles

       
-        
+        
         {% for m_name, m_vals in modes.items() %}
         
-          
-          
-          
-          
+          
+          
+          
         {% endfor %}
       
MODEDRAINENCOUNTERSCAPS
ModeDrainEncountersCaps

+          
             {{ m_name }}{% if m_name == cfg.get('mode','') %} ◀{% endif %}×{{ m_vals.get('survival',{}).get('drain_speed','—') }}×{{ m_vals.get('encounter',{}).get('global_rate_multiplier','—') }}×{{ m_vals.get('economy',{}).get('caps_global_multiplier','—') }}×{{ m_vals.get('survival',{}).get('drain_speed','—') }}×{{ m_vals.get('encounter',{}).get('global_rate_multiplier','—') }}×{{ m_vals.get('economy',{}).get('caps_global_multiplier','—') }}
         

     

 
     

-      
COMMANDES AMPÈRE

-      
Copier-coller dans votre terminal SSH :

-      

-        
# Lancer/relancer S{{ current_sid }} :

-        
cd /home/ubuntu/fallout-venice/src/engine

-        
nohup env SESSION_ID={{ current_sid }} SIM_CONFIG=../config/sim_{{ '%03d' % current_sid }}.json TICK_SLEEP_SEC=60 PYTHONUNBUFFERED=1 python3 -u run.py > ~/fallout_sim_s{{ current_sid }}.log 2>&1 &

-        

-        
# Voir les logs :

-        
tail -f ~/fallout_sim_s{{ current_sid }}.log

+      
Commandes SSH (référence)

+      
Copier-coller dans votre terminal SSH. Pour les commandes générées, utiliser l'onglet OUTILS.

+      

+        
tail -f ~/fallout_sim_s{{ current_sid }}.log

       

     

   

 
 

+
+
+
 {% endif %}
 
-
VAULT-TEC VAULTCOM v4.0 | S{{ current_sid }} | J={{ session.current_day if session else '?' }} T={{ session.current_tick if session else '?' }}h

+

+
+
PipBoy v5.0 | SIM LIBRE • OUTILS • ENRICHISSEMENT • PARAMÈTRES

 
 """
 
@@ -808,6 +1536,79 @@ def index():
         **data,
     )
 
+@app.route("/tools")
+def tools():
+    all_sessions = get_all_sessions()
+    sid = int(request.args.get("sid", all_sessions[-1]["id"] if all_sessions else 1))
+    session = query_one("SELECT * FROM sessions WHERE id = %s", (sid,))
+    return render_template_string(TEMPLATE,
+        tab="tools",
+        current_sid=sid,
+        all_sessions=all_sessions,
+        session=session,
+        flash_msg=None,
+        flash_ok=True,
+        cfg=None, modes={}, sim_configs_dir=SIM_CONFIGS_DIR,
+        proposals=[], lore_stats={"pending":0,"accepted":0,"rejected":0,"modified":0},
+        all_factions=[], filt_faction="", filt_status="",
+        characters=[], alive_count=0, total_count=0,
+        events=[], encounters=[], world_state=[],
+        faction_relations=[], tier_stats=[], zone_stats=[],
+        stats={}, boss_inventory=[],
+    )
+
+@app.route("/api/stress-test/results")
+def api_stress_test_results():
+    path = os.path.join(SIM_CONFIGS_DIR, "crash_results.json")
+    if not os.path.exists(path):
+        return jsonify({"error": "Aucun résultat. Lancez d'abord le test."})
+    try:
+        import datetime
+        mtime = os.path.getmtime(path)
+        file_date = datetime.datetime.fromtimestamp(mtime).strftime("%d/%m/%Y %H:%M:%S")
+        with open(path) as f:
+            data = json.load(f)
+        data["file_date"] = file_date
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": f"Erreur lecture : {e}"})
+
+@app.route("/api/stress-test/run", methods=["POST"])
+def api_stress_test_run():
+    global _stress_state
+    with _stress_lock:
+        if _stress_state["running"]:
+            return jsonify({"error": "Un test est déjà en cours.", "running": True})
+        mode      = request.json.get("mode", "simultane")
+        rounds    = int(request.json.get("rounds", 5))
+        pnj_count = int(request.json.get("pnj_count", 2))
+        _stress_state = {
+            "running": True,
+            "started_at": time.strftime("%H:%M:%S"),
+            "mode": mode,
+            "rounds": rounds,
+            "pnj_count": pnj_count,
+            "output": [],
+            "returncode": None,
+            "error": None,
+        }
+    t = threading.Thread(target=_run_stress_bg, args=(mode, rounds, pnj_count), daemon=True)
+    t.start()
+    return jsonify({"ok": True, "message": f"Test '{mode}' {rounds} rounds lancé."})
+
+@app.route("/api/stress-test/status")
+def api_stress_test_status():
+    with _stress_lock:
+        return jsonify({
+            "running":     _stress_state["running"],
+            "started_at":  _stress_state["started_at"],
+            "mode":        _stress_state["mode"],
+            "rounds":      _stress_state["rounds"],
+            "output":      _stress_state["output"][-60:],  # 60 dernières lignes
+            "returncode":  _stress_state["returncode"],
+            "error":       _stress_state["error"],
+        })
+
 @app.route("/params")
 def params():
     all_sessions = get_all_sessions()
@@ -828,6 +1629,8 @@ def params():
         flash_msg=flash_msg,
         flash_ok=flash_ok,
         # unused in params tab but required by template
+        proposals=[], lore_stats={"pending":0,"accepted":0,"rejected":0,"modified":0},
+        all_factions=[], filt_faction="", filt_status="",
         characters=[], alive_count=0, total_count=0,
         events=[], encounters=[], world_state=[],
         faction_relations=[], tier_stats=[], zone_stats=[],
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..38fb05a
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,36 @@
+services:
+  fallout-visu:
+    image: python:3.11-alpine
+    container_name: fallout-visu
+    restart: unless-stopped
+    working_dir: /app
+    volumes:
+      - ./dashboard/app.py:/app/app.py:ro
+      - /home/ubuntu/.ssh/vigile_backup:/ssh/vigile.key:ro
+      - ./src/config:/app/src/config
+      - ./tools:/app/tools:ro
+    command: >
+      sh -c "apk add --no-cache openssh-client &&
+             pip install flask psycopg2-binary --quiet &&
+             python app.py"
+    networks:
+      - proxy-nw
+    extra_hosts:
+      - 'host.docker.internal:172.20.0.1'
+    environment:
+      - PYTHONUNBUFFERED=1
+      - LETSENCRYPT_HOST=fallout.coyoteos.ovh
+      - VIRTUAL_HOST=fallout.coyoteos.ovh
+      - DB_HOST=${DB_HOST}
+      - DB_PORT=${DB_PORT}
+      - DB_NAME=${DB_NAME}
+      - DB_USER=${DB_USER}
+      - DB_PASS=${DB_PASS}
+      - SIM_CONFIGS_DIR=/app/src/config
+      - OLLAMA_URL=${OLLAMA_URL}
+      - MODEL_MJ=${MODEL_MJ}
+      - MODEL_PNJ=${MODEL_PNJ}
+
+networks:
+  proxy-nw:
+    external: true
diff --git a/src/config/crash_results.json b/src/config/crash_results.json
new file mode 100644
index 0000000..104b862
--- /dev/null
+++ b/src/config/crash_results.json
@@ -0,0 +1,54 @@
+{
+  "test_type": "capacity",
+  "mode": "capacity_test",
+  "timestamp": "2026-06-16T10:19:26.345074",
+  "file_date": "16/06/2026 10:19:26",
+  "model_mj": "qwen2.5:14b",
+  "model_pnj": "qwen2.5:7b",
+  "stats": [
+    {
+      "n_players": 1,
+      "pnj_avg_wall_s": 4.8,
+      "pnj_avg_p50_s": 4.8,
+      "pnj_avg_p95_s": 4.8,
+      "mj_avg_elapsed_s": 29.9,
+      "tick_total_avg_s": 34.6,
+      "actions_per_hour": 103,
+      "errors": 0,
+      "viable_realtime_1h": true
+    },
+    {
+      "n_players": 5,
+      "pnj_avg_wall_s": 27.5,
+      "pnj_avg_p50_s": 17.2,
+      "pnj_avg_p95_s": 27.5,
+      "mj_avg_elapsed_s": 29.8,
+      "tick_total_avg_s": 57.2,
+      "actions_per_hour": 62,
+      "errors": 0,
+      "viable_realtime_1h": true
+    },
+    {
+      "n_players": 10,
+      "pnj_avg_wall_s": 47.4,
+      "pnj_avg_p50_s": 26.4,
+      "pnj_avg_p95_s": 47.4,
+      "mj_avg_elapsed_s": 29.9,
+      "tick_total_avg_s": 77.3,
+      "actions_per_hour": 46,
+      "errors": 0,
+      "viable_realtime_1h": true
+    },
+    {
+      "n_players": 50,
+      "pnj_avg_wall_s": 180.2,
+      "pnj_avg_p50_s": 91.6,
+      "pnj_avg_p95_s": 172.2,
+      "mj_avg_elapsed_s": 31.9,
+      "tick_total_avg_s": 212.1,
+      "actions_per_hour": 16,
+      "errors": 8,
+      "viable_realtime_1h": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/tools/capacity_test.py b/tools/capacity_test.py
new file mode 100644
index 0000000..8a47a64
--- /dev/null
+++ b/tools/capacity_test.py
@@ -0,0 +1,343 @@
+"""
+Capacity Test — Fallout Venice of Wasteland
+Série de tests pour mesurer la capacité de charge LLM.
+
+Simule N joueurs simultanés et mesure :
+- Temps de réponse par joueur (P50, P95, max)
+- Débit total (tokens/s global)
+- Temps d'attente queue (joueur 1 vs joueur N)
+- Viabilité pour le mode temps-réel (1h/tick)
+
+Usage :
+    python3 capacity_test.py
+    python3 capacity_test.py --quick   (skip 50-player test)
+    python3 capacity_test.py --output /path/to/results.json
+"""
+
+import os, sys, time, json, argparse, threading, statistics
+import urllib.request
+from datetime import datetime
+
+OLLAMA_URL = os.getenv("OLLAMA_URL", "http://localhost:11434")
+MODEL_MJ   = os.getenv("MODEL_MJ",   "qwen2.5:14b")
+MODEL_PNJ  = os.getenv("MODEL_PNJ",  "qwen2.5:7b")
+OUTPUT     = os.getenv("CRASH_RESULTS_PATH",
+                        "/home/ubuntu/fallout-venice/src/config/crash_results.json")
+
+# ---------------------------------------------------------------------------
+# Prompts variés pour éviter le cache
+# ---------------------------------------------------------------------------
+PNJ_PROMPTS = [
+    "Tu es un garde de La Régie. Réponds en 1 phrase à : 'Laisse-moi passer.'",
+    "Tu es un marchand créole de Pearl River. Réponds en 1 phrase à : 'T'as du carburant ?'",
+    "Tu es une goule du Grand Krewe. Réponds en 1 phrase à : 'Que veut le Baron ?'",
+    "Tu es un Écumeur. Réponds en 1 phrase à : 'On veut juste traverser le fleuve.'",
+    "Tu es Sœur Eulalie de L'Union. Réponds en 1 phrase à : 'J'ai été mordu.'",
+    "Tu es un technicien de la CdA. Réponds en 1 phrase à : 'Répare mon Pip-Boy.'",
+    "Tu es un scavenger neutre. Réponds en 1 phrase à : 'Combien pour cette armure ?'",
+    "Tu es un informateur du Syndicat. Réponds en 1 phrase à : 'Qui contrôle la Route 61 ?'",
+    "Tu es un fermier de Oak Plantation. Réponds en 1 phrase à : 'Vous travaillez pour qui ?'",
+    "Tu es un passeur de Laplace. Réponds en 1 phrase à : 'Combien pour traverser ?'",
+]
+
+MJ_PROMPTS = [
+    "En 2 phrases, décris la réaction de la foule quand les joueurs entrent dans le marché de NOLA.",
+    "En 2 phrases, décris l'ambiance de Pearl River à l'aube après une nuit de combat.",
+    "En 2 phrases, que se passe-t-il quand le Grand Krewe envoie un émissaire aux joueurs ?",
+    "En 2 phrases, décris les conséquences d'un vol de convoi de la Régie.",
+    "En 2 phrases, comment réagit L'Union quand elle apprend qu'un de ses membres a trahi ?",
+]
+
+# ---------------------------------------------------------------------------
+# HTTP
+# ---------------------------------------------------------------------------
+
+def http_post(url: str, body: dict, timeout: int = 180) -> dict:
+    data = json.dumps(body).encode()
+    req  = urllib.request.Request(url, data=data, method="POST",
+                                   headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        return json.loads(r.read())
+
+def call_llm(model: str, prompt: str, player_id: int = 0) -> dict:
+    t0 = time.time()
+    try:
+        res = http_post(f"{OLLAMA_URL}/api/generate", {
+            "model": model,
+            "prompt": prompt,
+            "stream": False,
+            "options": {"num_predict": 80, "temperature": 0.7, "seed": player_id},
+        })
+        elapsed = time.time() - t0
+        tokens  = res.get("eval_count", 0)
+        return {
+            "player_id": player_id,
+            "model":     model,
+            "tokens":    tokens,
+            "elapsed":   round(elapsed, 2),
+            "tok_s":     round(tokens / elapsed, 2) if elapsed > 0 else 0,
+            "queued_s":  round(res.get("load_duration", 0) / 1e9, 2),
+            "error":     None,
+            "enqueued_at": t0,
+        }
+    except Exception as e:
+        return {
+            "player_id": player_id, "model": model,
+            "tokens": 0, "elapsed": round(time.time() - t0, 2),
+            "tok_s": 0, "queued_s": 0,
+            "error": str(e)[:80], "enqueued_at": t0,
+        }
+
+# ---------------------------------------------------------------------------
+# Scénarios
+# ---------------------------------------------------------------------------
+
+def scenario_warmup() -> dict:
+    """1 appel MJ + 1 appel PNJ pour chauffer les modèles."""
+    print("  [WARMUP] Chargement des modèles en RAM...")
+    r_mj  = call_llm(MODEL_MJ,  MJ_PROMPTS[0],  0)
+    r_pnj = call_llm(MODEL_PNJ, PNJ_PROMPTS[0], 0)
+    ok = "✓" if not r_mj["error"] and not r_pnj["error"] else "✗"
+    print(f"  {ok} MJ: {r_mj['elapsed']}s ({r_mj['tok_s']} t/s)  "
+          f"PNJ: {r_pnj['elapsed']}s ({r_pnj['tok_s']} t/s)")
+    return {"mj_warmup": r_mj, "pnj_warmup": r_pnj}
+
+
+def scenario_n_players(n: int, rounds: int = 3) -> dict:
+    """
+    Simule N joueurs envoyant une action simultanément.
+    Chaque joueur → 1 appel PNJ 7b (en parallèle via threads).
+    Après tous les PNJ → 1 appel MJ 14b (narrateur du tick).
+    """
+    print(f"\n  [{n} JOUEURS] {rounds} round(s) — {n} PNJ en parallèle + 1 MJ après")
+    all_rounds = []
+
+    for r in range(rounds):
+        round_results = {"pnj": [], "mj": None}
+        t_round_start = time.time()
+
+        # Phase 1 : N joueurs en parallèle
+        lock    = threading.Lock()
+        threads = []
+
+        def player_action(pid: int):
+            prompt = PNJ_PROMPTS[pid % len(PNJ_PROMPTS)]
+            res = call_llm(MODEL_PNJ, prompt, pid)
+            with lock:
+                round_results["pnj"].append(res)
+
+        for i in range(n):
+            t = threading.Thread(target=player_action, args=(i,))
+            threads.append(t)
+
+        t_first = time.time()
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        t_all_pnj_done = time.time()
+        pnj_total_wall = round(t_all_pnj_done - t_first, 2)
+
+        # Phase 2 : MJ synthétise
+        mj_prompt = (
+            f"Tick {r+1}, {n} joueurs ont agi simultanément dans NOLA. "
+            + MJ_PROMPTS[r % len(MJ_PROMPTS)]
+        )
+        mj_res = call_llm(MODEL_MJ, mj_prompt, -1)
+        round_results["mj"] = mj_res
+
+        t_round_total = round(time.time() - t_round_start, 2)
+
+        # Stats PNJ de ce round
+        pnj_ok      = [x for x in round_results["pnj"] if not x["error"]]
+        pnj_elapsed = sorted([x["elapsed"] for x in pnj_ok])
+        p50 = statistics.median(pnj_elapsed) if pnj_elapsed else 0
+        p95 = pnj_elapsed[int(len(pnj_elapsed) * 0.95)] if len(pnj_elapsed) > 1 else (pnj_elapsed[0] if pnj_elapsed else 0)
+
+        status = "✓" if not mj_res["error"] and len(pnj_ok) == n else f"⚠ {n - len(pnj_ok)} erreurs"
+        print(f"    R{r+1}: PNJ wall={pnj_total_wall}s P50={p50}s P95={p95}s | "
+              f"MJ={mj_res['elapsed']}s | total={t_round_total}s | {status}")
+
+        all_rounds.append({
+            "round": r + 1,
+            "pnj":   round_results["pnj"],
+            "mj":    mj_res,
+            "pnj_wall_time": pnj_total_wall,
+            "round_total_time": t_round_total,
+            "pnj_p50": p50,
+            "pnj_p95": p95,
+        })
+
+    return {"n_players": n, "rounds": all_rounds}
+
+
+def compute_stats(scenario_result: dict) -> dict:
+    n       = scenario_result["n_players"]
+    rounds  = scenario_result["rounds"]
+
+    all_pnj_elapsed  = [x["elapsed"] for r in rounds for x in r["pnj"] if not x.get("error")]
+    all_pnj_wall     = [r["pnj_wall_time"] for r in rounds]
+    all_mj_elapsed   = [r["mj"]["elapsed"] for r in rounds if not r["mj"].get("error")]
+    all_total        = [r["round_total_time"] for r in rounds]
+    all_p50          = [r["pnj_p50"] for r in rounds]
+    all_p95          = [r["pnj_p95"] for r in rounds]
+    errors           = sum(1 for r in rounds for x in r["pnj"] if x.get("error"))
+
+    def avg(lst): return round(sum(lst) / len(lst), 2) if lst else 0
+
+    tick_duration_s  = avg(all_total)
+    viable_realtime  = tick_duration_s < 3600
+    viable_5min      = tick_duration_s < 300
+
+    return {
+        "n_players":          n,
+        "pnj_avg_elapsed_s":  avg(all_pnj_elapsed),
+        "pnj_avg_wall_s":     avg(all_pnj_wall),
+        "pnj_avg_p50_s":      avg(all_p50),
+        "pnj_avg_p95_s":      avg(all_p95),
+        "mj_avg_elapsed_s":   avg(all_mj_elapsed),
+        "tick_total_avg_s":   tick_duration_s,
+        "tick_total_min_s":   min(all_total) if all_total else 0,
+        "tick_total_max_s":   max(all_total) if all_total else 0,
+        "errors":             errors,
+        "viable_realtime_1h": viable_realtime,
+        "viable_5min_tick":   viable_5min,
+        "actions_per_hour":   int(3600 / tick_duration_s) if tick_duration_s > 0 else 0,
+    }
+
+# ---------------------------------------------------------------------------
+# Rapport
+# ---------------------------------------------------------------------------
+
+SEP = "=" * 70
+
+def print_report(warmup: dict, scenarios: list[dict], stats_list: list[dict]):
+    print(f"\n{SEP}")
+    print(f"  RAPPORT CAPACITÉ — FALLOUT VENICE — {datetime.now().strftime('%d/%m/%Y %H:%M')}")
+    print(SEP)
+
+    w_mj  = warmup.get("mj_warmup", {})
+    w_pnj = warmup.get("pnj_warmup", {})
+    print(f"\n  BASELINE (warm)")
+    print(f"    MJ  14b : {w_mj.get('elapsed','?')}s  |  {w_mj.get('tok_s','?')} tok/s")
+    print(f"    PNJ  7b : {w_pnj.get('elapsed','?')}s  |  {w_pnj.get('tok_s','?')} tok/s")
+
+    print(f"\n  {'N':>4}  {'PNJ wall':>10}  {'P50':>7}  {'P95':>7}  {'MJ':>7}  {'TICK total':>11}  {'Actions/h':>10}  {'1h viable':>10}  ERR")
+    print(f"  {'-'*4}  {'-'*10}  {'-'*7}  {'-'*7}  {'-'*7}  {'-'*11}  {'-'*10}  {'-'*10}  {'-'*4}")
+
+    for s in stats_list:
+        v1h  = "✓" if s["viable_realtime_1h"] else "✗"
+        err  = str(s["errors"]) if s["errors"] else "0"
+        print(f"  {s['n_players']:>4}  "
+              f"{s['pnj_avg_wall_s']:>9.1f}s  "
+              f"{s['pnj_avg_p50_s']:>6.1f}s  "
+              f"{s['pnj_avg_p95_s']:>6.1f}s  "
+              f"{s['mj_avg_elapsed_s']:>6.1f}s  "
+              f"{s['tick_total_avg_s']:>10.1f}s  "
+              f"{s['actions_per_hour']:>10}  "
+              f"{v1h:>10}  "
+              f"{err:>4}")
+
+    print(f"\n  LÉGENDE")
+    print(f"    PNJ wall   : durée réelle pour que TOUS les PNJ répondent (parallèle)")
+    print(f"    P50 / P95  : médiane / 95e percentile du temps d'attente par joueur")
+    print(f"    TICK total : PNJ wall + MJ (= durée d'un tick complet)")
+    print(f"    Actions/h  : combien de ticks complets tiennent en 1h réelle")
+    print(f"    1h viable  : tick < 1h (compatible mode temps-réel)")
+
+    print(f"\n  RECOMMANDATIONS")
+    for s in stats_list:
+        n = s["n_players"]
+        t = s["tick_total_avg_s"]
+        a = s["actions_per_hour"]
+        if a >= 6:
+            msg = f"✓ {n} joueurs → 1 action toutes les {round(t/60,1)} min — jouable"
+        elif a >= 1:
+            msg = f"⚠ {n} joueurs → 1 action toutes les {round(t/60,1)} min — lent mais viable en temps réel"
+        else:
+            msg = f"✗ {n} joueurs → tick de {round(t/60,1)} min — dépasse 1h, non viable en temps réel"
+        print(f"    {msg}")
+
+    print(f"\n{SEP}")
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(description="Capacity test LLM Fallout Venice")
+    parser.add_argument("--quick",  action="store_true", help="Skip 50-player test")
+    parser.add_argument("--output", default=OUTPUT)
+    args = parser.parse_args()
+
+    print(f"\n{SEP}")
+    print(f"  CAPACITY TEST — FALLOUT VENICE OF WASTELAND")
+    print(f"  Ollama : {OLLAMA_URL}")
+    print(f"  MJ     : {MODEL_MJ}  |  PNJ : {MODEL_PNJ}")
+    print(f"  Début  : {datetime.now().strftime('%H:%M:%S')}")
+    print(SEP)
+
+    # Vérifier Ollama
+    try:
+        with urllib.request.urlopen(f"{OLLAMA_URL}/api/tags", timeout=5) as r:
+            models = [m["name"] for m in json.loads(r.read()).get("models", [])]
+        print(f"\n  Modèles dispos : {', '.join(models)}")
+    except Exception as e:
+        print(f"  [ERR] Ollama inaccessible : {e}")
+        sys.exit(1)
+
+    # 1. Warmup (toujours)
+    print(f"\n{SEP}")
+    print("  PHASE 0 — WARMUP (chargement modèles en RAM)")
+    print(SEP)
+    warmup = scenario_warmup()
+
+    # 2. Série de tests
+    configs = [
+        {"n": 1,  "rounds": 3},   # baseline solo
+        {"n": 5,  "rounds": 3},   # petit groupe
+        {"n": 10, "rounds": 2},   # groupe moyen
+    ]
+    if not args.quick:
+        configs.append({"n": 50, "rounds": 1})  # stress
+
+    scenarios    = []
+    stats_list   = []
+
+    for cfg in configs:
+        n, rounds = cfg["n"], cfg["rounds"]
+        print(f"\n{SEP}")
+        print(f"  PHASE — {n} JOUEUR{'S' if n > 1 else ''} SIMULTANÉ{'S' if n > 1 else ''} ({rounds} round{'s' if rounds > 1 else ''})")
+        print(SEP)
+        result = scenario_n_players(n, rounds)
+        s      = compute_stats(result)
+        scenarios.append(result)
+        stats_list.append(s)
+
+    # 3. Rapport terminal
+    print_report(warmup, scenarios, stats_list)
+
+    # 4. Export JSON
+    output = {
+        "test_type":   "capacity",
+        "mode":        "capacity_test",
+        "timestamp":   datetime.now().isoformat(),
+        "ollama_url":  OLLAMA_URL,
+        "model_mj":    MODEL_MJ,
+        "model_pnj":   MODEL_PNJ,
+        "warmup":      warmup,
+        "scenarios":   scenarios,
+        "stats":       stats_list,
+        "file_date":   datetime.now().strftime("%d/%m/%Y %H:%M:%S"),
+    }
+    try:
+        with open(args.output, "w") as f:
+            json.dump(output, f, indent=2, ensure_ascii=False)
+        print(f"\n  Résultats écrits → {args.output}")
+    except Exception as e:
+        print(f"  [WARN] Impossible d'écrire le fichier : {e}")
+
+
+if __name__ == "__main__":
+    main()