262 lines
9.9 KiB
Python
262 lines
9.9 KiB
Python
import os
|
|
import subprocess
|
|
import threading
|
|
|
|
from flask import Blueprint, render_template, jsonify, request, send_file
|
|
|
|
from ..db import query, query_one, execute, get_all_sessions
|
|
from ..config import SIM_CONFIGS_DIR
|
|
|
|
bp = Blueprint("sim", __name__)
|
|
|
|
_sim_procs = {
|
|
"truth": {"proc": None, "output": [], "running": False, "returncode": None, "error": None, "sid": None},
|
|
"enriched": {"proc": None, "output": [], "running": False, "returncode": None, "error": None, "sid": None},
|
|
}
|
|
_sim_lock = threading.Lock()
|
|
|
|
|
|
def _run_sim_bg(mode, sid, tick_speed_s):
|
|
env = {**os.environ,
|
|
"SESSION_ID": str(sid),
|
|
"TICK_SLEEP_SEC": str(tick_speed_s),
|
|
"PYTHONUNBUFFERED": "1"}
|
|
if mode == "enriched":
|
|
env["USE_ENRICHED"] = "1"
|
|
try:
|
|
row = query_one(
|
|
"INSERT INTO sim_runs (mode,session_id,tick_speed_s,status,started_at) "
|
|
"VALUES (%s,%s,%s,'running',NOW()) RETURNING id",
|
|
(mode, sid, tick_speed_s))
|
|
run_id = row["id"] if row else None
|
|
except Exception:
|
|
run_id = None
|
|
with _sim_lock:
|
|
_sim_procs[mode].update({"output": [], "running": True, "returncode": None, "error": None, "sid": sid})
|
|
try:
|
|
proc = subprocess.Popen(
|
|
["python3", "-u", "/app/src/engine/run.py"],
|
|
stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
|
|
text=True, env=env)
|
|
with _sim_lock:
|
|
_sim_procs[mode]["proc"] = proc
|
|
for line in proc.stdout:
|
|
with _sim_lock:
|
|
_sim_procs[mode]["output"].append(line.rstrip())
|
|
proc.wait()
|
|
with _sim_lock:
|
|
_sim_procs[mode]["returncode"] = proc.returncode
|
|
_sim_procs[mode]["running"] = False
|
|
if run_id:
|
|
try:
|
|
execute("UPDATE sim_runs SET status='stopped',stopped_at=NOW() WHERE id=%s", (run_id,))
|
|
except Exception:
|
|
pass
|
|
except Exception as e:
|
|
with _sim_lock:
|
|
_sim_procs[mode]["error"] = str(e)
|
|
_sim_procs[mode]["running"] = False
|
|
|
|
|
|
def _get_sim_data(sid: int) -> dict:
|
|
session = query_one("SELECT * FROM sessions WHERE id = %s", (sid,))
|
|
if not session:
|
|
session = query_one("SELECT * FROM sessions ORDER BY id DESC LIMIT 1")
|
|
|
|
characters = query("""
|
|
SELECT c.*, COALESCE(c.tier, 1) as tier
|
|
FROM characters c
|
|
WHERE c.session_id = %s
|
|
ORDER BY COALESCE(c.tier,1), c.is_alive DESC, c.name
|
|
""", (sid,))
|
|
alive_count = sum(1 for c in characters if c["is_alive"])
|
|
|
|
events = query("""
|
|
SELECT e.*, c.name as actor_name FROM events e
|
|
LEFT JOIN characters c ON c.id = e.actor_id
|
|
WHERE e.session_id = %s
|
|
AND e.event_type NOT IN ('encounter_lambda','encounter_group','encounter_actif','encounter_boss','cycle_tick')
|
|
ORDER BY e.day DESC, e.tick DESC, e.id DESC LIMIT 50
|
|
""", (sid,))
|
|
|
|
encounters = query("""
|
|
SELECT e.*, c.name as actor_name FROM events e
|
|
LEFT JOIN characters c ON c.id = e.actor_id
|
|
WHERE e.session_id = %s AND e.event_type LIKE 'encounter%%'
|
|
ORDER BY e.day DESC, e.tick DESC, e.id DESC LIMIT 30
|
|
""", (sid,))
|
|
|
|
world_state = query("""
|
|
SELECT DISTINCT ON (location_slug) *
|
|
FROM world_state WHERE session_id = %s
|
|
ORDER BY location_slug, day DESC
|
|
""", (sid,))
|
|
|
|
faction_relations = query("""
|
|
SELECT * FROM faction_relations WHERE session_id = %s
|
|
ORDER BY relation_score ASC
|
|
""", (sid,))
|
|
|
|
tier_labels = {0: "BOSS", 1: "ACTIFS SIM", 2: "PNJ+", 3: "PASSAGE"}
|
|
tier_raw = query("""
|
|
SELECT COALESCE(tier,1) as tier,
|
|
COUNT(*) FILTER (WHERE is_alive) as alive,
|
|
COUNT(*) FILTER (WHERE NOT is_alive) as dead
|
|
FROM characters WHERE session_id = %s
|
|
GROUP BY COALESCE(tier,1) ORDER BY COALESCE(tier,1)
|
|
""", (sid,))
|
|
tier_stats = [{"tier": r["tier"], "label": tier_labels.get(r["tier"], "?"),
|
|
"alive": r["alive"], "dead": r["dead"]} for r in tier_raw]
|
|
|
|
zone_stats = query("""
|
|
SELECT location_slug, COUNT(*) as cnt FROM characters
|
|
WHERE session_id = %s AND is_alive = TRUE
|
|
GROUP BY location_slug ORDER BY cnt DESC LIMIT 5
|
|
""", (sid,))
|
|
|
|
ev_total = query_one("SELECT COUNT(*) as n FROM events WHERE session_id=%s", (sid,))
|
|
cb_total = query_one("SELECT COUNT(*) as n FROM events WHERE session_id=%s AND event_type='combat'", (sid,))
|
|
dt_total = query_one("SELECT COUNT(*) as n FROM events WHERE session_id=%s AND event_type='death'", (sid,))
|
|
enc_total = query_one("SELECT COUNT(*) as n FROM events WHERE session_id=%s AND event_type LIKE 'encounter%%'", (sid,))
|
|
|
|
stats = {
|
|
"Événements total": ev_total["n"] if ev_total else 0,
|
|
"Combats": cb_total["n"] if cb_total else 0,
|
|
"Morts": dt_total["n"] if dt_total else 0,
|
|
"Rencontres": enc_total["n"] if enc_total else 0,
|
|
"PNJ vivants": alive_count,
|
|
"PNJ morts": len(characters) - alive_count,
|
|
}
|
|
|
|
boss_inventory = query("""
|
|
SELECT c.name as char_name, i.item_name, i.item_type, i.quantity, i.is_equipped
|
|
FROM inventory i
|
|
JOIN characters c ON c.id = i.character_id
|
|
WHERE c.session_id = %s AND COALESCE(c.tier,1) = 0
|
|
ORDER BY c.name, i.is_equipped DESC
|
|
""", (sid,))
|
|
|
|
return dict(
|
|
session=session,
|
|
characters=characters,
|
|
alive_count=alive_count,
|
|
total_count=len(characters),
|
|
events=events,
|
|
encounters=encounters,
|
|
world_state=world_state,
|
|
faction_relations=faction_relations,
|
|
tier_stats=tier_stats,
|
|
zone_stats=zone_stats,
|
|
stats=stats,
|
|
boss_inventory=boss_inventory,
|
|
)
|
|
|
|
|
|
@bp.route("/")
|
|
def index():
|
|
all_sessions = get_all_sessions()
|
|
sid = int(request.args.get("sid", all_sessions[-1]["id"] if all_sessions else 1))
|
|
data = _get_sim_data(sid)
|
|
return render_template("sim.html", tab="sim", current_sid=sid,
|
|
all_sessions=all_sessions, flash_msg=None, flash_ok=True, **data)
|
|
|
|
|
|
@bp.route("/api/sim/<mode>/run", methods=["POST"])
|
|
def sim_run(mode):
|
|
if mode not in ("truth", "enriched"):
|
|
return jsonify({"error": "mode invalide"}), 400
|
|
with _sim_lock:
|
|
if _sim_procs[mode].get("running"):
|
|
return jsonify({"error": f"Simulation {mode} déjà en cours"}), 400
|
|
data = request.get_json(silent=True) or {}
|
|
sid = int(data.get("sid", 1))
|
|
tick_speed_s = int(data.get("tick_speed_s", 5))
|
|
t = threading.Thread(target=_run_sim_bg, args=(mode, sid, tick_speed_s), daemon=True)
|
|
t.start()
|
|
return jsonify({"ok": True, "sid": sid, "mode": mode})
|
|
|
|
|
|
@bp.route("/api/sim/<mode>/status")
|
|
def sim_status(mode):
|
|
if mode not in ("truth", "enriched"):
|
|
return jsonify({"error": "mode invalide"}), 400
|
|
with _sim_lock:
|
|
state = {k: v for k, v in _sim_procs[mode].items() if k != "proc"}
|
|
return jsonify(state)
|
|
|
|
|
|
@bp.route("/api/sim/<mode>/stop", methods=["POST"])
|
|
def sim_stop(mode):
|
|
if mode not in ("truth", "enriched"):
|
|
return jsonify({"error": "mode invalide"}), 400
|
|
with _sim_lock:
|
|
p = _sim_procs[mode].get("proc")
|
|
if p:
|
|
try:
|
|
p.terminate()
|
|
except Exception:
|
|
pass
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/api/sim/<mode>/log")
|
|
def sim_log(mode):
|
|
if mode not in ("truth", "enriched"):
|
|
return jsonify({"error": "mode invalide"}), 400
|
|
import io
|
|
import json as _json
|
|
import datetime as _dt
|
|
run = query_one("SELECT * FROM sim_runs WHERE mode=%s ORDER BY id DESC LIMIT 1", (mode,))
|
|
if not run:
|
|
return jsonify({"error": "Aucun run trouvé — lancez d'abord une simulation"}), 404
|
|
sid = run["session_id"]
|
|
session = query_one("SELECT * FROM sessions WHERE id=%s", (sid,))
|
|
events = query("SELECT * FROM events WHERE session_id=%s ORDER BY id DESC LIMIT 500", (sid,))
|
|
with _sim_lock:
|
|
output_lines = list(_sim_procs[mode].get("output", []))
|
|
log_data = {
|
|
"meta": {
|
|
"sim_mode": mode,
|
|
"session_id": sid,
|
|
"session_name": session.get("name", "") if session else "",
|
|
"world": "Venice of Wasteland, Louisiane post-apo",
|
|
"tick_speed_s": run["tick_speed_s"],
|
|
"started_at": run["started_at"].isoformat() if run.get("started_at") else None,
|
|
"stopped_at": run["stopped_at"].isoformat() if run.get("stopped_at") else None,
|
|
"status": run["status"],
|
|
"exported_at": _dt.datetime.now().isoformat(),
|
|
},
|
|
"console_output": output_lines,
|
|
"recent_events": [dict(e) for e in events],
|
|
}
|
|
buf = io.BytesIO(_json.dumps(log_data, ensure_ascii=False, indent=2, default=str).encode("utf-8"))
|
|
return send_file(buf, mimetype="application/json", as_attachment=True,
|
|
download_name=f"sim_{mode}_{sid}.json")
|
|
|
|
|
|
@bp.route("/api/session/set-mode", methods=["POST"])
|
|
def session_set_mode():
|
|
data = request.get_json(silent=True) or {}
|
|
sid = int(data.get("sid", 1))
|
|
mode = data.get("mode", "").strip()
|
|
valid = {"pacifiste", "politique", "guerre_commerciale", "guerre", "survie_extreme"}
|
|
if mode not in valid:
|
|
return jsonify({"error": f"Mode invalide: {mode}"}), 400
|
|
try:
|
|
execute("UPDATE sessions SET mode=%s WHERE id=%s", (mode, sid))
|
|
return jsonify({"ok": True, "sid": sid, "mode": mode})
|
|
except Exception as e:
|
|
return jsonify({"error": str(e)}), 500
|
|
|
|
|
|
@bp.route("/api/state")
|
|
def api_state():
|
|
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,))
|
|
alive = query("""
|
|
SELECT id, name, hp, max_hp, tier, faction_slug, location_slug
|
|
FROM characters WHERE session_id=%s AND is_alive=TRUE
|
|
""", (sid,))
|
|
return jsonify({"session": session, "alive_pnj": alive})
|