__DRAGDROP_JS__
"""
dd_js = """
"""
sidebar = _inventar_sidebar()
return kopf + _spieler_banner() + sidebar + inhalt + fuss.replace("__DRAGDROP_JS__", dd_js)
# ─────────────────────────────────────────────────────────────────────────────
# U19 – Spielstand, Inventar, Zeitmessung & Scoreboards
# ─────────────────────────────────────────────────────────────────────────────
# Der Führerschein liegt von Anfang an im Inventar (Polizei-Kontrolle im Finale).
FUEHRERSCHEIN = {"id": "fuehrerschein", "name": "Führerschein", "icon": "🪪"}
# Jeder Einzelabschnitt, der zeitlich gemessen wird → eigener Scoreboard-Bereich.
STAGE_NAMES = {
11: "Hai-Fragen (Prüf-Weg)",
21: "Laser-Fragen (Prüf-Weg)",
31: "Laserhai-Fragen (Prüf-Weg)",
12: "Abkürzung Biologe",
22: "Abkürzung Elektriker",
32: "Abkürzung Cyborgs",
40: "Polizei-Kontrolle",
}
# Schlüssel/Zugangs-Items, die man beim Abschließen eines Abschnitts erhält.
STAGE_KEYS = {
31: {"id": "laserhai_key", "name": "Laserhai-Schlüssel", "icon": "🦈"},
12: {"id": "bio_card", "name": "Zugangskarte vom Biologen", "icon": "🔬"},
22: {"id": "elec_key", "name": "Sicherungsschlüssel des Elektrikers", "icon": "⚡"},
32: {"id": "cyborg_chip", "name": "Cyborg-Zugangschip", "icon": "🤖"},
}
# Alle Items, die den Kragle-Tresor entsperren können.
ACCESS_KEYS = ["laserhai_key", "bio_card", "elec_key", "cyborg_chip"]
# ── Inventar (Session ist Spielwahrheit, DB spiegelt für Persistenz) ──────────
def _inv_list():
return session.get("inv", [])
def _inv_has(item_id):
return any(x["id"] == item_id for x in session.get("inv", []))
def _inv_add(item):
inv = session.get("inv", [])
if not any(x["id"] == item["id"] for x in inv):
session["inv"] = inv + [item]
session.modified = True
sp = session.get("spieler")
if sp:
db = get_db()
db.execute("INSERT INTO inventar (spieler, gegenstand) VALUES (?,?)",
(sp, item["id"]))
db.commit(); db.close()
def _inv_remove(item_id):
session["inv"] = [x for x in session.get("inv", []) if x["id"] != item_id]
session.modified = True
sp = session.get("spieler")
if sp:
db = get_db()
db.execute("DELETE FROM inventar WHERE spieler=? AND gegenstand=?",
(sp, item_id))
db.commit(); db.close()
def _inv_hydrate_from_db(spieler):
"""Inventar aus der DB in die Session laden (z. B. bei App-Neustart)."""
item_map = {
"fuehrerschein": dict(FUEHRERSCHEIN),
"laserhai_key": STAGE_KEYS[31],
"bio_card": STAGE_KEYS[12],
"elec_key": STAGE_KEYS[22],
"cyborg_chip": STAGE_KEYS[32],
}
db = get_db()
rows = db.execute("SELECT gegenstand FROM inventar WHERE spieler=?", (spieler,)).fetchall()
db.close()
inv = []
for r in rows:
if r["gegenstand"] in item_map:
inv.append(dict(item_map[r["gegenstand"]]))
session["inv"] = inv
session.modified = True
def _spieler_banner():
if not session.get("spieler"):
return ""
return ('
Unterwegs als: %s
'
% esc(session["spieler"]))
def _inventar_sidebar():
"""Fixe Inventar-Leiste links – nur für angemeldete Spieler mit Items."""
inv = session.get("inv", [])
if not session.get("spieler") or not inv:
return ""
items = ""
for x in inv:
items += ('
%s'
'%s
'
% (esc(x["id"]), esc(x["name"]), x["icon"], esc(x["name"])))
return ('' % items)
# ── Zeitmessung: Einzelabschnitte (Stages) ───────────────────────────────────
def _stage_start(rid):
key = "stg_%d" % rid
if key not in session and not session.get("stgdone_%d" % rid):
session[key] = time.time()
session.modified = True
def _stage_finish(rid, grant_key=True):
"""Dauer des Abschnitts speichern; optional zugehörigen Schlüssel vergeben."""
key = "stg_%d" % rid
done_key = "stgdone_%d" % rid
sp = session.get("spieler")
if sp and key in session and not session.get(done_key):
dauer = time.time() - session[key]
db = get_db()
db.execute("INSERT INTO stage_zeiten (spieler, stage, dauer, zeit) "
"VALUES (?,?,?,?)",
(sp, STAGE_NAMES.get(rid, "Stage %d" % rid), dauer, time.time()))
db.commit(); db.close()
session[done_key] = True
session.pop(key, None)
session.modified = True
k = STAGE_KEYS.get(rid)
if grant_key and k:
_inv_add(k)
# ── Gesamtlauf protokollieren (Sieg/Niederlage) ──────────────────────────────
def _record_run(status):
sp = session.get("spieler"); st = session.get("run_start")
if sp and st:
now = time.time(); dauer = now - st
db = get_db()
db.execute("INSERT INTO laeufe (spieler, start_zeit, fertig_zeit, dauer, status) "
"VALUES (?,?,?,?,?)", (sp, st, now, dauer, status))
if status == "gewonnen":
db.execute("UPDATE spielstand SET fertig_zeit=? WHERE spieler=?", (now, sp))
# start_zeit leeren, damit der Lauf nicht erneut (re-hydratisiert) gezählt wird
db.execute("UPDATE spielstand SET start_zeit=NULL WHERE spieler=?", (sp,))
db.commit(); db.close()
session.pop("run_start", None)
session.modified = True
def _run_reset_keys():
"""Alle lauf-spezifischen Session-Keys entfernen (Name bleibt erhalten)."""
for key in [k for k in list(session.keys())
if k.startswith("raum_") or k.startswith("chal_")
or k.startswith("stg_") or k.startswith("stgdone_")
or k.startswith("fs40")
or k in ("inv", "run_start", "vault_unlocked")]:
session.pop(key, None)
session.modified = True
# ── Zeit-Formatierung & Scoreboards ──────────────────────────────────────────
def _fmt_zeit(sek):
if sek is None:
return "–"
sek = float(sek)
if sek < 60:
return "%.1f s" % sek
m = int(sek // 60); s = sek - m * 60
return "%d:%04.1f min" % (m, s)
def _sb_gesamt(limit=10):
db = get_db()
try:
rows = db.execute(
"SELECT spieler, dauer AS best FROM laeufe "
"WHERE status='gewonnen' ORDER BY dauer LIMIT ?", (limit,)
).fetchall()
except sqlite3.OperationalError:
rows = []
db.close(); return rows
def _sb_stage(stage, limit=3):
db = get_db()
try:
rows = db.execute(
"SELECT spieler, dauer AS best FROM stage_zeiten "
"WHERE stage=? ORDER BY dauer LIMIT ?", (stage, limit)
).fetchall()
except sqlite3.OperationalError:
rows = []
db.close(); return rows
def _scoreboard_html():
ges = _sb_gesamt(10)
rows = ""
if ges:
for i, r in enumerate(ges, 1):
medal = ["🥇", "🥈", "🥉"][i - 1] if i <= 3 else ("%d." % i)
rows += ('
Noch keine Zeiten – '
'sei die/der Erste, die/der entkommt!
')
stage_blocks = ""
for rid in sorted(STAGE_NAMES):
name = STAGE_NAMES[rid]
st = _sb_stage(name, 3)
items = ""
if st:
for i, r in enumerate(st, 1):
items += ('
""" % (rows, stage_blocks))
@app.route("/", methods=["GET", "POST"])
def start():
# ── Formular abgeschickt: Name → INSERT + neuen Lauf starten ──
if request.method == "POST":
name = request.form.get("name", "").strip()
if name:
_run_reset_keys() # evtl. alten Lauf verwerfen
session["spieler"] = name # App merkt sich: das bist du
session["run_start"] = time.time() # Gesamtzeit-Messung startet
session["inv"] = [dict(FUEHRERSCHEIN)] # Führerschein von Anfang an
session.modified = True
db = get_db()
db.execute(
"INSERT OR IGNORE INTO spielstand (spieler, raum_id, start_zeit) "
"VALUES (?, 1, ?)", (name, session["run_start"]))
db.execute("UPDATE spielstand SET raum_id=1, start_zeit=?, fertig_zeit=NULL "
"WHERE spieler=?", (session["run_start"], name))
db.execute("DELETE FROM inventar WHERE spieler=?", (name,))
db.execute("INSERT INTO inventar (spieler, gegenstand) VALUES (?,?)",
(name, FUEHRERSCHEIN["id"]))
db.commit(); db.close()
return redirect("/app/raum/1")
intro = """
LEGO • Geheimmission
Einbruch im Octan-Tower 🧱
Präsident Business hortet ganz oben in seinem Wolkenkratzer
das Kragle – und will damit die ganze Welt für immer festkleben.
Nur du kannst ihn stoppen! Kämpf dich Etage für Etage nach oben: vorbei an
Haien 🦈, Lasern 🔴 und – natürlich –
Laserhaien 🦈⚡.
Jede Etage gabelt sich: Der sichere Prüf-Weg
stellt thematische Fragen, die riskante Abkürzung läuft gegen die
Uhr. Unterwegs sammelst du Schlüssel ins Inventar – ganz oben
brauchst du einen davon, um den Kragle-Tresor zu öffnen.
Deine Zeit läuft mit und landet in der Bestenliste!
__MITTE__
"""
# ── Angemeldet? Dann „Willkommen zurück“ + Weiterspielen ──
mitte = ""
if session.get("spieler"):
sp = session["spieler"]
db = get_db()
s = db.execute("SELECT raum_id, start_zeit FROM spielstand WHERE spieler=?", (sp,)).fetchone()
anzahl = db.execute("SELECT COUNT(*) AS n FROM spielstand").fetchone()
db.close()
if not session.get("inv"):
_inv_hydrate_from_db(sp)
if s and s["start_zeit"] and not session.get("run_start"):
session["run_start"] = float(s["start_zeit"])
session.modified = True
weiter_raum = s["raum_id"] if s and s["raum_id"] else 1
mitte = (
'
'
% (esc(sp), weiter_raum, anzahl["n"]))
else:
db = get_db()
anzahl = db.execute("SELECT COUNT(*) AS n FROM spielstand").fetchone()
db.close()
mitte = (
''
'
%s""" % (zurueck, _scoreboard_html()))
return adventure_seite(inhalt)
@app.route("/frage")
def frage():
return redirect("/app/")
# ─── Adventure-Helfer: Sieg / Game Over / Challenge ──────────────────────────
def _clear_challenge(rid):
"""Timer- und Fortschritts-Keys einer Challenge aus der Session entfernen."""
session.pop("chal_%d_deadline" % rid, None)
session.pop("chal_%d_idx" % rid, None)
session.modified = True
def sieg_screen(text=None):
body = text or ("Du hast Präsident Business gestoppt und das Kragle gesichert. "
"Die Welt bleibt frei – und kreativ!")
_record_run("gewonnen")
zeit_html = ""
inhalt = ("""
""" % esc(grund))
return adventure_seite(inhalt, akzent="#f87171")
def challenge_raum(db, r):
"""Risk/Reward-Abkürzung mit Zeitlimit (Biologe, Elektriker, Cyborgs)."""
rid = r["id"]
limit = int(r["zeit_limit"] or 40)
ziel = int(r["ziel_anzahl"] or 10)
erfolg_raum = r["erfolg_raum"] or 0
erfolg_text = r["erfolg_text"] or ""
dl_key = "chal_%d_deadline" % rid
idx_key = "chal_%d_idx" % rid
fragen = db.execute(
"SELECT * FROM fragen WHERE raum_id=? ORDER BY id", (rid,)
).fetchall()
back = db.execute(
"SELECT nach_raum FROM ausgaenge WHERE von_raum=? ORDER BY rowid LIMIT 1",
(rid,)
).fetchone()
db.close()
back_raum = back["nach_raum"] if back else 1
gesamt = min(ziel, len(fragen)) if fragen else ziel
now = time.time()
# ── Noch nicht gestartet → Intro (die Entscheidung: Risk vs. Reward) ──
if dl_key not in session:
if request.args.get("start") == "1" and fragen:
session[dl_key] = now + limit
session[idx_key] = 0
session.modified = True
_stage_start(rid) # Zeitmessung dieses Abschnitts
return redirect("/app/raum/%d" % rid)
reward = ("🏆 Bei Erfolg: sofort gewonnen!" if not erfolg_raum
else "🏆 Bei Erfolg: Express ganz nach oben")
inhalt = ("""
⚠️ Risiko-Abkürzung · Etage %d
%s
%s
🎯 %d Fragen richtig⏱️ %d Sekunden%s💀 Ein Fehler = Aus
""" % (esc(erfolg_text), key_hinweis, erfolg_raum))
return adventure_seite(inhalt)
return sieg_screen(erfolg_text)
return redirect("/app/raum/%d" % rid)
# falsche Antwort → sofortiges Game Over
_clear_challenge(rid)
_stage_finish(rid, grant_key=False)
return gameover_screen(
"❌ Falsch! Dein Gegenüber durchschaut dich sofort und schlägt Alarm. "
"So knapp – aber der riskante Weg verzeiht keinen einzigen Fehler.")
# GET → aktuelle Frage mit Countdown zeigen
if idx >= len(fragen):
_clear_challenge(rid)
return sieg_screen(erfolg_text)
aktuelle = fragen[idx]
remaining = deadline - now
buttons = ""
for opt in aktuelle["optionen"].split("|"):
buttons += (''
% (esc(opt), esc(opt)))
tpl = """
⏱️ Risiko-Challenge · __NAME__
__NAME__
__REMAIN__ s
Frage __NR__ von __GES__ · schon richtig: __IDX__
__FRAGE__
"""
html = (tpl
.replace("__NAME__", esc(r["name"]))
.replace("__REMAINMS__", str(int(max(0.0, remaining) * 1000)))
.replace("__REMAIN__", "%.1f" % max(0.0, remaining))
.replace("__LIMIT__", str(limit))
.replace("__NR__", str(idx + 1))
.replace("__GES__", str(gesamt))
.replace("__IDX__", str(idx))
.replace("__FRAGE__", esc(aktuelle["frage"]))
.replace("__BTN__", buttons)
.replace("__ID__", str(rid)))
return adventure_seite(html, akzent="#f87171")
# ─── Polizei-Führerschein-Kontrolle vor dem Lord-Business-Finale (U18) ────────
# Die drei Aufgaben stammen aus der deutschen Führerschein-Theorieprüfung.
# "richtig" = Menge der (1-basierten) anzukreuzenden Optionen. Mehrfachauswahl!
FS_FRAGEN = [
{
"frage": "Welches Verhalten ist hier richtig?",
"bild": "/fs_frage1.png",
"optionen": ["Ich muss den roten Bus durchfahren lassen",
"Ich darf vor dem blauen Pkw fahren",
"Ich muss den blauen Pkw durchfahren lassen"],
"richtig": {1, 3},
},
{
"frage": "Wann kann es hier zu einer gefährlichen Situation kommen?",
"bild": "/fs_frage2.png",
"optionen": ["Wenn der Radfahrer am Ende des Radweges anhält",
"Wenn ich unvermindert weiterfahre",
"Wenn der Radfahrer auf meine Fahrbahn wechselt"],
"richtig": {2, 3},
},
{
"frage": "Warum ist man nach dem Konsum der Droge „Crystal Meth“ fahruntauglich?",
"bild": None,
"optionen": ["Weil plötzliche Erschöpfung eintreten kann",
"Weil Wahnvorstellungen auftreten können",
"Weil die eigene Leistungsfähigkeit überschätzt werden kann"],
"richtig": {1, 2, 3},
},
]
FS_IDX_KEY = "fs40_idx"
FS_DONE_KEY = "fs40_done"
def _tresor_schloss():
"""Finale-Gate: Der Kragle-Tresor lässt nur mit Zugangsschlüssel öffnen."""
have = [k for k in ACCESS_KEYS if _inv_has(k)]
accept = ",".join(have) if have else "none"
namen = {"laserhai_key": "Laserhai-Schlüssel", "bio_card": "Zugangskarte vom Biologen",
"elec_key": "Sicherungsschlüssel des Elektrikers", "cyborg_chip": "Cyborg-Chip"}
besitz = (", ".join(namen[k] for k in have)
if have else "leider kein passender Schlüssel")
inhalt = ("""
🔒 Kragle-Tresor · Zugang gesperrt
Der Tresor ist verriegelt
Ganz oben – doch ein schweres Sicherheitsschloss versperrt
den letzten Schritt. Setze deinen Zugangsschlüssel ein:
Zieh ihn aus dem Inventar (links) auf das Schloss.
🔒
Schlüssel hierher ziehen, um den Tresor zu öffnen
🎒 In deinem Besitz: %s
""" % (accept, esc(besitz)))
return adventure_seite(inhalt, akzent="#facc15")
def _blaulicht_intro():
"""Grelles deutsches Blaulicht + Polizei-Ansage vor der Kontrolle."""
inhalt = """
🚨
🚔 POLIZEI · VERKEHRSKONTROLLE
Anhalten – Fahrzeugkontrolle!
Kurz vor dem Kragle-Tresor stoppt dich eine Streife.
Ein Beamter tritt ans Fenster: „Guten Tag. Fahrzeugkontrolle –
Ihren Führerschein bitte!“
🪪
Zieh deinen Führerschein aus dem Inventar (links) hierher,
um ihn den Beamten vorzuzeigen.
"""
return adventure_seite(inhalt, akzent="#1e50ff")
def _fs_ansage():
"""Nach dem Vorzeigen des Führerscheins: misstrauische Ansage der Beamten."""
inhalt = """
🚨
🚔 POLIZEI · FÜHRERSCHEIN-PRÜFUNG
„Der ist doch nie echt!“
Die Beamten mustern deinen Führerschein misstrauisch:
„Diesen Lappen haben Sie doch nie im Leben ehrlich bestanden!
Wenn er echt ist, beweisen Sie es: Lösen Sie diese drei Aufgaben
aus der Theorieprüfung – dann dürfen Sie weiter.“
🚦 Achtung: Bei manchen Fragen ist
mehr als eine Antwort richtig. Kreuze alle
zutreffenden an – ein falsches Kreuz und du fällst durch.
')
# Spielstand fortschreiben: Wo war der Spieler zuletzt? (UPDATE)
if session.get("spieler"):
db.execute("UPDATE spielstand SET raum_id=? WHERE spieler=?",
(id, session["spieler"]))
if not session.get("inv"):
_inv_hydrate_from_db(session["spieler"])
if not session.get("run_start"):
st = db.execute("SELECT start_zeit FROM spielstand WHERE spieler=?",
(session["spieler"],)).fetchone()
if st and st["start_zeit"]:
session["run_start"] = float(st["start_zeit"])
session.modified = True
db.commit()
typ = r["typ"]
# ═══ Risk/Reward-Abkürzung mit Timer (Biologe / Elektriker / Cyborgs) ═══
if typ == "challenge":
return challenge_raum(db, r)
# ═══ Räume mit Fragen: thema (Prüf-Weg) · ziel (Finale) ═══
if typ in ("thema", "ziel"):
# ── Finale (Raum 40): erst Polizei-Kontrolle, dann Tresor-Schloss ──
if typ == "ziel" and id == 40:
# 1) Polizei-Führerschein-Kontrolle zuerst
if not session.get(FS_DONE_KEY):
_stage_start(40) # Polizei-Kontrolle Zeitmessung
db.close()
return fuehrerschein_kontrolle()
# 2) Danach: Zugangsschlüssel in den Kragle-Tresor (per Drag&Drop)
if request.args.get("unlock") == "1" and not session.get("vault_unlocked"):
used = next((k for k in ACCESS_KEYS if _inv_has(k)), None)
if used:
_inv_remove(used)
session["vault_unlocked"] = True
session.modified = True
db.close()
return redirect("/app/raum/40")
if not session.get("vault_unlocked"):
db.close()
return _tresor_schloss()
# ── Prüf-Weg-Räume: Zeitmessung dieses Abschnitts startet ──
if typ == "thema":
_stage_start(id)
fragen = db.execute(
"SELECT * FROM fragen WHERE raum_id=? ORDER BY id", (id,)
).fetchall()
prog_key = "raum_%d_idx" % id
idx = session.get(prog_key, 0)
# ── Noch offene Fragen → nächste Frage zeigen ──
if fragen and idx < len(fragen):
aktuelle = fragen[idx]
feedback = ""
if request.method == "POST":
gewaehlt = request.form.get("antwort", "").strip()
if gewaehlt.lower() == aktuelle["antwort"].strip().lower():
session[prog_key] = idx + 1
session.modified = True
db.close()
return redirect("/app/raum/%d" % id)
feedback = ('
🚨 Alarm! Falsche Antwort – '
'die Wächter werden fast auf dich aufmerksam. Nochmal!
')
optionen = aktuelle["optionen"].split("|")
db.close()
buttons = ""
for opt in optionen:
buttons += (''
% (esc(opt), esc(opt)))
if typ == "ziel":
label = "🧱 FINALE · %s" % esc(r["name"])
else:
label = "🔐 Sicherheitsprüfung · %s" % esc(r["name"])
inhalt = ("""
%s
%s
%s
Frage %d von %d
%s
%s
""" % (label, esc(r["name"]), esc(r["beschreibung"]),
idx + 1, len(fragen), feedback,
esc(aktuelle["frage"]), buttons))
return adventure_seite(inhalt)
# ── Alle Fragen dieses Raums beantwortet ──
ausgaenge = db.execute(
"SELECT richtung, nach_raum, hinweis FROM ausgaenge "
"WHERE von_raum=? ORDER BY rowid", (id,)
).fetchall()
db.close()
# ZIEL erreicht → Sieg
if typ == "ziel":
return sieg_screen(r["beschreibung"])
# THEMA gelöst → Erfolg + Ausgang zur nächsten Etage
_stage_finish(id) # Zeit speichern (+ ggf. Schlüssel)
k = STAGE_KEYS.get(id)
key_hinweis = ("" if not k else
'
🎒 Erhalten: %s %s – '
'damit öffnest du oben den Kragle-Tresor.
' % (esc(k["name"]), k["icon"]))
weiter = ausgaenge[0] if ausgaenge else None
weiter_btn = (
'%s'
% (weiter["nach_raum"], esc(weiter["richtung"]))
if weiter else
'Zurück zum Start')
inhalt = ("""
✅ Richtiger Weg
%s
%s
✅ Alle Fragen geknackt – der Weg nach oben ist frei!
%s
%s
""" % (esc(r["name"]), esc(r["beschreibung"]), key_hinweis, weiter_btn))
return adventure_seite(inhalt)
# ═══ Gang / Start: Beschreibung + Wege (Navigations-Entscheidung) ═══
ausgaenge = db.execute(
"SELECT richtung, nach_raum, hinweis FROM ausgaenge "
"WHERE von_raum=? ORDER BY rowid", (id,)
).fetchall()
db.close()
wege_html = ""
for a in ausgaenge:
wege_html += ("""