# { "Depends": "py-genlayer:test" } from genlayer import * import json from dataclasses import dataclass # ───────────────────────────────────────────────────────────────────────────── # Storage types — players identified by session_id not wallet address # ───────────────────────────────────────────────────────────────────────────── @allow_storage @dataclass class Game: name: str pin: str num_rounds: u32 duration_per_question: u32 scheduled_start: u64 status: str # "lobby" | "active" | "ended" categories_str: str # comma-separated e.g. "science,genlayer" questions_json: str # JSON string of all questions revealed_answers: str # comma-separated revealed correct choices e.g. "A,C,B" @allow_storage @dataclass class PlayerResult: display_name: str # chosen by player, no wallet needed session_id: str # random UUID generated by app for this player answers_str: str # comma-separated e.g. "A,C,B,D" times_str: str # comma-separated seconds e.g. "5,12,3,45" total_xp: u64 correct_count: u32 max_streak: u32 submitted: bool rank: u32 # ───────────────────────────────────────────────────────────────────────────── # Constants # ───────────────────────────────────────────────────────────────────────────── CATEGORIES = ["science", "history", "sports", "genlayer", "geography"] VALID_CHOICES = ["A", "B", "C", "D", ""] MAX_ROUNDS = 7 MIN_ROUNDS = 1 MAX_DURATION = 120 MIN_DURATION = 15 # ───────────────────────────────────────────────────────────────────────────── # Contract # ───────────────────────────────────────────────────────────────────────────── class TriviaBattle(gl.Contract): """ Trivia Battle — walletless multiplayer trivia on GenLayer. Players need NO wallet and sign NO transactions. Only the host wallet is needed (one person). Game flow: 1. Host calls create_game() — AI generates all questions upfront. 2. Players open app, enter PIN, type their name — that's it. App generates a session_id (UUID) for each player locally. 3. Host calls start_game(game_id) when ready. 4. Players answer questions locally — zero transactions. 5. App collects all answers locally during the game. 6. At end of game, host app calls submit_player_results() once per player (or in batch) — host wallet pays all gas. 7. Host calls end_game() — ranks everyone. 8. Results page shows full leaderboard by display name. XP per correct answer (speed-based): <= 10% time used → 1000 base XP <= 25% time used → 800 base XP <= 50% time used → 600 base XP <= 75% time used → 400 base XP > 75% time used → 300 base XP Wrong / skipped → 0 XP Difficulty: easy=1.0x medium=1.25x hard=1.5x Streak bonus: 3+ correct in a row → +200 XP per streak question """ games: TreeMap[u32, Game] game_count: u32 # key = "game_id:session_id" → player result results: TreeMap[str, PlayerResult] # key = game_id → comma-separated session_ids game_sessions: TreeMap[u32, str] host: Address def __init__(self): self.host = gl.message.sender_address self.game_count = u32(0) # ── Helpers ─────────────────────────────────────────────────────────────── def _rkey(self, game_id: int, session_id: str) -> str: return f"{game_id}:{session_id}" def _generate_pin(self, game_id: int) -> str: pin = (game_id * 7919 + 1234) % 9000 + 1000 return str(pin) def _calculate_xp(self, is_correct: bool, time_taken: int, duration: int, difficulty: str, streak: int) -> int: if not is_correct: return 0 ratio = time_taken / max(duration, 1) if ratio <= 0.10: base_xp = 1000 elif ratio <= 0.25: base_xp = 800 elif ratio <= 0.50: base_xp = 600 elif ratio <= 0.75: base_xp = 400 else: base_xp = 300 if difficulty == "hard": mult = 1.5 elif difficulty == "medium": mult = 1.25 else: mult = 1.0 streak_bonus = 200 if streak >= 3 else 0 return int(base_xp * mult) + streak_bonus # ── Host: create game ───────────────────────────────────────────────────── @gl.public.write def create_game( self, name: str, categories_csv: str, duration_per_question: u32, scheduled_start: u64, ) -> None: """ Host creates a game. AI generates all questions upfront. - name: e.g. "GenLayer Quiz #1" - categories_csv: comma-separated e.g. "science,genlayer,history" One per round. Max 7. - duration_per_question: seconds per question (15-120) - scheduled_start: unix timestamp, or 0 for manual start """ assert gl.message.sender_address == self.host, "Only the host can create games" name = name.strip() assert len(name) > 0, "Game name cannot be empty" assert int(duration_per_question) >= MIN_DURATION, f"Min duration {MIN_DURATION}s" assert int(duration_per_question) <= MAX_DURATION, f"Max duration {MAX_DURATION}s" cats = [c.strip().lower() for c in categories_csv.split(",") if c.strip()] assert len(cats) >= MIN_ROUNDS, f"Need at least {MIN_ROUNDS} category" assert len(cats) <= MAX_ROUNDS, f"Max {MAX_ROUNDS} categories" for c in cats: assert c in CATEGORIES, f"Invalid category '{c}'" num_rounds = len(cats) cat_list = "" for i, c in enumerate(cats): cat_list += f"Round {i+1}: {c}\n" has_genlayer = "genlayer" in cats def leader_fn(): genlayer_context = "" if has_genlayer: genlayer_context = gl.nondet.web.render( "https://docs.genlayer.com", mode="text" )[:2000] prompt = f"""You are a trivia host. Generate {num_rounds} multiple choice trivia questions. Round categories (one question per round in this exact order): {cat_list} {("GenLayer documentation (use for genlayer rounds):\n" + genlayer_context) if has_genlayer else ""} Return ONLY a JSON object in this exact format, no markdown, no extra text: {{ "questions": [ {{ "question": "What is the chemical symbol for gold?", "correct_answer": "Au", "wrong_answer_1": "Ag", "wrong_answer_2": "Fe", "wrong_answer_3": "Cu", "difficulty": "medium", "category": "science" }} ] }} RULES: - questions array must have exactly {num_rounds} items - Each question matches its round category in order - correct_answer is factually accurate - wrong answers are plausible but incorrect - All answers are 1-5 words - difficulty is ONLY: easy, medium, or hard - Return valid JSON only""" result = gl.nondet.exec_prompt(prompt) result = result.strip() if "```" in result: parts = result.split("```") for part in parts: part = part.strip() if part.startswith("json"): part = part[4:].strip() if part.startswith("{"): result = part break return result def validator_fn(leaders_res) -> bool: try: if not isinstance(leaders_res, gl.vm.Return): return False raw = leaders_res.calldata if not isinstance(raw, str): return False data = json.loads(raw.strip()) if not isinstance(data, dict): return False qs = data.get("questions", []) if not isinstance(qs, list) or len(qs) != num_rounds: return False for q in qs: if not isinstance(q, dict): return False for field in ["question", "correct_answer", "wrong_answer_1", "wrong_answer_2", "wrong_answer_3", "difficulty"]: if field not in q: return False if q["difficulty"] not in ["easy", "medium", "hard"]: return False return True except Exception: return False raw_result = gl.vm.run_nondet_unsafe(leader_fn, validator_fn) try: if not isinstance(raw_result, str): raise Exception(f"Expected str got {type(raw_result)}") data = json.loads(raw_result.strip()) qs = data["questions"] except Exception as e: raise Exception(f"Parse failed: {e} | raw: {str(raw_result)[:150]}") game_id = int(self.game_count) stored_qs = [] for i, q in enumerate(qs): correct = str(q["correct_answer"]) wrong1 = str(q["wrong_answer_1"]) wrong2 = str(q["wrong_answer_2"]) wrong3 = str(q["wrong_answer_3"]) slot = (game_id + i) % 4 if slot == 0: a, b, c, d, cc = correct, wrong1, wrong2, wrong3, "A" elif slot == 1: a, b, c, d, cc = wrong1, correct, wrong2, wrong3, "B" elif slot == 2: a, b, c, d, cc = wrong1, wrong2, correct, wrong3, "C" else: a, b, c, d, cc = wrong1, wrong2, wrong3, correct, "D" stored_qs.append({ "question": str(q["question"]), "choice_a": a, "choice_b": b, "choice_c": c, "choice_d": d, "correct_choice": cc, "difficulty": str(q["difficulty"]), "category": cats[i], }) self.games[u32(game_id)] = Game( name=name, pin=self._generate_pin(game_id), num_rounds=u32(num_rounds), duration_per_question=duration_per_question, scheduled_start=scheduled_start, status="lobby", categories_str=",".join(cats), questions_json=json.dumps(stored_qs), revealed_answers="", ) self.game_count = u32(game_id + 1) self.game_sessions[u32(game_id)] = "" # ── Host: manage game state ─────────────────────────────────────────────── @gl.public.write def start_game(self, game_id: u32) -> None: """Host starts a lobby game — all players in lobby auto-redirect.""" assert gl.message.sender_address == self.host, "Only the host can start games" game = self.games.get(game_id) assert game is not None, "Game not found" assert str(game.status) == "lobby", "Game is not in lobby state" self.games[game_id] = Game( name=str(game.name), pin=str(game.pin), num_rounds=game.num_rounds, duration_per_question=game.duration_per_question, scheduled_start=game.scheduled_start, status="active", categories_str=str(game.categories_str), questions_json=str(game.questions_json), revealed_answers=str(game.revealed_answers), ) @gl.public.write def end_game(self, game_id: u32) -> None: """Host ends game — calculates final rankings.""" assert gl.message.sender_address == self.host, "Only the host can end games" game = self.games.get(game_id) assert game is not None, "Game not found" assert str(game.status) == "active", "Game is not active" self._rank_players(int(game_id)) self.games[game_id] = Game( name=str(game.name), pin=str(game.pin), num_rounds=game.num_rounds, duration_per_question=game.duration_per_question, scheduled_start=game.scheduled_start, status="ended", categories_str=str(game.categories_str), questions_json=str(game.questions_json), revealed_answers=str(game.revealed_answers), ) def _rank_players(self, game_id: int) -> None: sessions_str = self.game_sessions.get(u32(game_id)) if sessions_str is None or str(sessions_str).strip() == "": return session_list = [s.strip() for s in str(sessions_str).split(",") if s.strip()] xp_pairs = [] for sid in session_list: key = self._rkey(game_id, sid) result = self.results.get(key) if result is not None and bool(result.submitted): xp_pairs.append((int(result.total_xp), sid)) xp_pairs.sort(key=lambda x: x[0], reverse=True) for rank_idx, (xp, sid) in enumerate(xp_pairs): key = self._rkey(game_id, sid) result = self.results.get(key) if result is None: continue self.results[key] = PlayerResult( display_name=str(result.display_name), session_id=str(result.session_id), answers_str=str(result.answers_str), times_str=str(result.times_str), total_xp=result.total_xp, correct_count=result.correct_count, max_streak=result.max_streak, submitted=result.submitted, rank=u32(rank_idx + 1), ) # ── Host: register player + submit results ──────────────────────────────── @gl.public.write def register_player(self, game_id: u32, session_id: str, display_name: str) -> None: """ Host registers a player who joined via PIN. Called by the host app when a player enters PIN + name. Player needs no wallet — host signs this transaction. - session_id: UUID generated by app for this player e.g. "abc123" - display_name: name the player typed e.g. "Chukwuma" """ assert gl.message.sender_address == self.host, "Only host can register players" game = self.games.get(game_id) assert game is not None, "Game not found" assert str(game.status) in ["lobby", "active"], "Game has already ended" session_id = session_id.strip() display_name = display_name.strip() assert len(session_id) > 0, "Session ID cannot be empty" assert len(display_name) > 0, "Display name cannot be empty" assert len(display_name) <= 30, "Name must be 30 characters or less" key = self._rkey(int(game_id), session_id) if self.results.get(key) is not None: return # already registered self.results[key] = PlayerResult( display_name=display_name, session_id=session_id, answers_str="", times_str="", total_xp=u64(0), correct_count=u32(0), max_streak=u32(0), submitted=False, rank=u32(0), ) current = self.game_sessions.get(game_id) current_str = str(current) if current is not None else "" self.game_sessions[game_id] = ( session_id if current_str == "" else current_str + "," + session_id ) @gl.public.write def submit_player_results( self, game_id: u32, session_id: str, answers_csv: str, times_csv: str, ) -> None: """ Host submits answers on behalf of a player after game ends. Player needs no wallet — host signs all these transactions. - session_id: the player's UUID - answers_csv: e.g. "A,C,B,D,A" (empty string for skipped) - times_csv: e.g. "5,12,3,45,8" (seconds taken, 0 for skipped) """ assert gl.message.sender_address == self.host, "Only host can submit player results" game = self.games.get(game_id) assert game is not None, "Game not found" assert str(game.status) in ["active", "ended"], "Game has not started" session_id = session_id.strip() key = self._rkey(int(game_id), session_id) result = self.results.get(key) assert result is not None, "Player not registered — call register_player first" assert not bool(result.submitted), "Already submitted for this player" num_rounds = int(game.num_rounds) answers = [a.strip().upper() for a in answers_csv.split(",")] times = [t.strip() for t in times_csv.split(",")] assert len(answers) == num_rounds, f"Expected {num_rounds} answers" assert len(times) == num_rounds, f"Expected {num_rounds} times" for a in answers: assert a in VALID_CHOICES, f"Invalid choice '{a}'" qs = json.loads(str(game.questions_json)) duration = int(game.duration_per_question) total_xp = 0 correct_count = 0 current_streak = 0 max_streak = 0 for i in range(num_rounds): choice = answers[i] time_taken = int(times[i]) if times[i].isdigit() else 0 correct = str(qs[i]["correct_choice"]) difficulty = str(qs[i]["difficulty"]) is_correct = (choice == correct and choice != "") if is_correct: current_streak += 1 max_streak = max(max_streak, current_streak) correct_count += 1 else: current_streak = 0 total_xp += self._calculate_xp( is_correct=is_correct, time_taken=time_taken, duration=duration, difficulty=difficulty, streak=current_streak, ) self.results[key] = PlayerResult( display_name=str(result.display_name), session_id=session_id, answers_str=answers_csv.upper(), times_str=times_csv, total_xp=u64(total_xp), correct_count=u32(correct_count), max_streak=u32(max_streak), submitted=True, rank=u32(0), ) @gl.public.write @gl.public.write def submit_all_player_results( self, game_id: u32, session_ids: str, all_answers: str, all_times: str, all_names: str, ) -> None: """ Host submits ALL players answers in one single transaction. No pre-registration needed — players auto-created from names. - session_ids: pipe-separated e.g. "abc|def|ghi" - all_answers: pipe-separated e.g. "A,C,B|B,A,D|C,C,A" - all_times: pipe-separated e.g. "5,12,3|8,4,20|15,9,6" - all_names: pipe-separated e.g. "Glory|Victor|Chukwuma" """ assert gl.message.sender_address == self.host, "Only host can submit results" game = self.games.get(game_id) assert game is not None, "Game not found" assert str(game.status) in ["active", "ended"], "Game has not started" sids = [s.strip() for s in session_ids.split("|") if s.strip()] answers_l = [a.strip() for a in all_answers.split("|")] times_l = [t.strip() for t in all_times.split("|")] names_l = [n.strip() for n in all_names.split("|")] assert len(sids) == len(answers_l) == len(times_l), \ "Mismatched number of players, answers, and times" num_rounds = int(game.num_rounds) qs = json.loads(str(game.questions_json)) duration = int(game.duration_per_question) for idx in range(len(sids)): sid = sids[idx] key = self._rkey(int(game_id), sid) result = self.results.get(key) # Auto-create player record if not registered — no pre-registration needed if result is None: name = names_l[idx] if idx < len(names_l) and names_l[idx] else f"Player{idx+1}" self.results[key] = PlayerResult( display_name=name, session_id=sid, answers_str="", times_str="", total_xp=u64(0), correct_count=u32(0), max_streak=u32(0), submitted=False, rank=u32(0), ) # Add to session list current = self.game_sessions.get(game_id) current_str = str(current) if current is not None else "" self.game_sessions[game_id] = ( sid if current_str == "" else current_str + "," + sid ) result = self.results.get(key) if bool(result.submitted): continue answers = [a.strip().upper() for a in answers_l[idx].split(",")] times = [t.strip() for t in times_l[idx].split(",")] if len(answers) != num_rounds or len(times) != num_rounds: continue total_xp = 0 correct_count = 0 current_streak = 0 max_streak = 0 for i in range(num_rounds): choice = answers[i] if i < len(answers) else "" time_taken = int(times[i]) if i < len(times) and times[i].isdigit() else 0 correct = str(qs[i]["correct_choice"]) difficulty = str(qs[i]["difficulty"]) is_correct = (choice == correct and choice != "") if is_correct: current_streak += 1 max_streak = max(max_streak, current_streak) correct_count += 1 else: current_streak = 0 total_xp += self._calculate_xp( is_correct=is_correct, time_taken=time_taken, duration=duration, difficulty=difficulty, streak=current_streak, ) self.results[key] = PlayerResult( display_name=str(result.display_name), session_id=sid, answers_str=answers_l[idx].upper(), times_str=times_l[idx], total_xp=u64(total_xp), correct_count=u32(correct_count), max_streak=u32(max_streak), submitted=True, rank=u32(0), ) # ── Read methods ────────────────────────────────────────────────────────── @gl.public.write def auto_end_game( self, game_id: u32, session_ids: str, all_answers: str, all_times: str, all_names: str, ) -> None: """ Submit all results AND end the game in one single transaction. Call this when the last question timer expires — fully automatic. No separate end_game call needed. """ assert gl.message.sender_address == self.host, "Only host can end games" game = self.games.get(game_id) assert game is not None, "Game not found" assert str(game.status) == "active", "Game is not active" # Submit all results first self.submit_all_player_results( game_id, session_ids, all_answers, all_times, all_names ) # Then rank and end self._rank_players(int(game_id)) self.games[game_id] = Game( name=str(game.name), pin=str(game.pin), num_rounds=game.num_rounds, duration_per_question=game.duration_per_question, scheduled_start=game.scheduled_start, status="ended", categories_str=str(game.categories_str), questions_json=str(game.questions_json), revealed_answers=str(game.revealed_answers), ) @gl.public.write def reveal_answer(self, game_id: u32, question_index: u32) -> None: """ Host reveals the correct answer for a specific question. Call this after each question timer expires. Players can then read revealed answers via get_revealed_answers(). No AI involved — instant, deterministic transaction. """ assert gl.message.sender_address == self.host, "Only host can reveal answers" game = self.games.get(game_id) assert game is not None, "Game not found" assert str(game.status) == "active", "Game is not active" qs = json.loads(str(game.questions_json)) idx = int(question_index) assert idx < len(qs), "Question index out of range" correct = str(qs[idx]["correct_choice"]) # Append to revealed answers string current = str(game.revealed_answers) if current == "": new_revealed = correct else: parts = current.split(",") # Only add if not already revealed if len(parts) <= idx: new_revealed = current + "," + correct else: new_revealed = current # already revealed self.games[game_id] = Game( name=str(game.name), pin=str(game.pin), num_rounds=game.num_rounds, duration_per_question=game.duration_per_question, scheduled_start=game.scheduled_start, status=str(game.status), categories_str=str(game.categories_str), questions_json=str(game.questions_json), revealed_answers=new_revealed, ) @gl.public.write def reveal_all_answers(self, game_id: u32) -> None: """ Host reveals ALL correct answers at once when game starts. Much better than reveal_answer — one transaction reveals everything. Players can read all answers immediately via get_revealed_answers(). """ assert gl.message.sender_address == self.host, "Only host can reveal answers" game = self.games.get(game_id) assert game is not None, "Game not found" assert str(game.status) in ["lobby", "active"], "Game not in valid state" qs = json.loads(str(game.questions_json)) choices = [str(q["correct_choice"]) for q in qs] revealed = ",".join(choices) self.games[game_id] = Game( name=str(game.name), pin=str(game.pin), num_rounds=game.num_rounds, duration_per_question=game.duration_per_question, scheduled_start=game.scheduled_start, status=str(game.status), categories_str=str(game.categories_str), questions_json=str(game.questions_json), revealed_answers=revealed, ) @gl.public.view def get_game(self, game_id: u32) -> dict: """Full game info. Correct answers hidden while active.""" game = self.games.get(game_id) assert game is not None, "Game not found" is_ended = str(game.status) == "ended" qs = json.loads(str(game.questions_json)) questions_out = [] for i, q in enumerate(qs): q_out = { "index": i, "question": q["question"], "choice_a": q["choice_a"], "choice_b": q["choice_b"], "choice_c": q["choice_c"], "choice_d": q["choice_d"], "difficulty": q["difficulty"], "category": q["category"], } if is_ended: q_out["correct_choice"] = q["correct_choice"] questions_out.append(q_out) # Parse revealed answers revealed_str = str(game.revealed_answers) revealed_list = revealed_str.split(",") if revealed_str else [] return { "game_id": int(game_id), "name": str(game.name), "pin": str(game.pin), "num_rounds": int(game.num_rounds), "duration_per_question": int(game.duration_per_question), "scheduled_start": int(game.scheduled_start), "status": str(game.status), "categories": str(game.categories_str).split(","), "questions": questions_out, "revealed_answers": revealed_list, } @gl.public.view def get_revealed_answers(self, game_id: u32) -> list: """ Returns list of revealed correct choices so far. Players poll this every second during the game. e.g. ["A", "C"] means round 1 answer is A, round 2 is C. Empty list means no answers revealed yet. """ game = self.games.get(game_id) if game is None: return [] revealed_str = str(game.revealed_answers) if not revealed_str: return [] return [r.strip() for r in revealed_str.split(",") if r.strip()] @gl.public.view def get_game_by_pin(self, pin: str) -> dict: """Find a game by its 4-digit PIN.""" pin = pin.strip() count = int(self.game_count) for i in range(count): g = self.games.get(u32(i)) if g is not None and str(g.pin) == pin: return self.get_game(u32(i)) return {} @gl.public.view def get_game_results(self, game_id: u32) -> dict: """Full ranked leaderboard. Names shown not wallet addresses.""" game = self.games.get(game_id) assert game is not None, "Game not found" sessions_str = self.game_sessions.get(game_id) if sessions_str is None or str(sessions_str).strip() == "": return {"game_id": int(game_id), "status": str(game.status), "players": []} is_ended = str(game.status) == "ended" qs = json.loads(str(game.questions_json)) session_list = [s.strip() for s in str(sessions_str).split(",") if s.strip()] out = [] for sid in session_list: key = self._rkey(int(game_id), sid) result = self.results.get(key) if result is None: continue breakdown = [] if is_ended and bool(result.submitted): answers = [a.strip() for a in str(result.answers_str).split(",")] times = [t.strip() for t in str(result.times_str).split(",")] for i, q in enumerate(qs): choice = answers[i] if i < len(answers) else "" is_correct = choice == q["correct_choice"] and choice != "" breakdown.append({ "round": i + 1, "category": q["category"], "question": q["question"], "player_choice": choice, "correct_choice": q["correct_choice"], "correct_answer": q["choice_" + q["correct_choice"].lower()], "is_correct": is_correct, "time_taken": int(times[i]) if i < len(times) and times[i].isdigit() else 0, "difficulty": q["difficulty"], }) out.append({ "session_id": sid, "name": str(result.display_name), "total_xp": int(result.total_xp), "correct_count": int(result.correct_count), "max_streak": int(result.max_streak), "submitted": bool(result.submitted), "rank": int(result.rank), "breakdown": breakdown, }) out.sort(key=lambda x: x["total_xp"], reverse=True) return { "game_id": int(game_id), "name": str(game.name), "status": str(game.status), "players": out, } @gl.public.view def get_player_count(self, game_id: u32) -> int: """Number of players registered in a game.""" sessions_str = self.game_sessions.get(game_id) if sessions_str is None or str(sessions_str).strip() == "": return 0 return len([s for s in str(sessions_str).split(",") if s.strip()]) @gl.public.view def get_active_games(self) -> list: """All games in lobby or active state.""" out = [] count = int(self.game_count) for i in range(count): g = self.games.get(u32(i)) if g is not None and str(g.status) in ["lobby", "active"]: out.append({ "game_id": i, "name": str(g.name), "pin": str(g.pin), "num_rounds": int(g.num_rounds), "duration_per_question": int(g.duration_per_question), "scheduled_start": int(g.scheduled_start), "status": str(g.status), "categories": str(g.categories_str).split(","), }) return out @gl.public.view def get_latest_game(self) -> dict: """Returns the most recently created game including PIN.""" count = int(self.game_count) if count == 0: return {} return self.get_game(u32(count - 1)) @gl.public.view def get_latest_game_id(self) -> int: """Returns ID of most recently created game. -1 if none exist.""" count = int(self.game_count) return count - 1 if count > 0 else -1 @gl.public.view def get_game_with_answers(self, game_id: u32, requester: Address) -> dict: """ Returns full game info INCLUDING correct answers. Only works if requester is the host address. Use this on the host manage page to broadcast correct answers to cloud. Players use cloud to get correct answers during intermission. """ assert requester == self.host, "Only host can see correct answers during game" game = self.games.get(game_id) assert game is not None, "Game not found" qs = json.loads(str(game.questions_json)) questions_out = [] for i, q in enumerate(qs): questions_out.append({ "index": i, "question": q["question"], "choice_a": q["choice_a"], "choice_b": q["choice_b"], "choice_c": q["choice_c"], "choice_d": q["choice_d"], "correct_choice": q["correct_choice"], "difficulty": q["difficulty"], "category": q["category"], }) # Parse revealed answers revealed_str = str(game.revealed_answers) revealed_list = revealed_str.split(",") if revealed_str else [] return { "game_id": int(game_id), "name": str(game.name), "pin": str(game.pin), "num_rounds": int(game.num_rounds), "duration_per_question": int(game.duration_per_question), "scheduled_start": int(game.scheduled_start), "status": str(game.status), "categories": str(game.categories_str).split(","), "questions": questions_out, "revealed_answers": revealed_list, } @gl.public.view def get_host(self) -> str: """Returns the host address.""" return str(self.host) @gl.public.view def get_game_count(self) -> int: """Total number of games created.""" return int(self.game_count)