619 lines
21 KiB
Python
619 lines
21 KiB
Python
from datetime import timedelta
|
|
from typing import Literal
|
|
|
|
from .models import GameSession, Player, Question, RoundConfig, RoundQuestion
|
|
|
|
SessionViewerRole = Literal["host", "player", "public"]
|
|
|
|
NON_HOST_PROMPT_PHASES = {
|
|
GameSession.Status.REVEAL,
|
|
GameSession.Status.SCOREBOARD,
|
|
GameSession.Status.FINISHED,
|
|
}
|
|
|
|
HOST_PHASE_THEMES = {
|
|
GameSession.Status.LOBBY: "host-atrium",
|
|
GameSession.Status.LIE: "host-spotlight",
|
|
GameSession.Status.GUESS: "host-signal",
|
|
GameSession.Status.REVEAL: "host-verdict",
|
|
GameSession.Status.SCOREBOARD: "host-podium",
|
|
GameSession.Status.FINISHED: "host-finale",
|
|
}
|
|
|
|
HOST_PHASE_ORNAMENTS = {
|
|
GameSession.Status.LOBBY: "atrium-banner",
|
|
GameSession.Status.LIE: "spotlight-beam",
|
|
GameSession.Status.GUESS: "signal-grid",
|
|
GameSession.Status.REVEAL: "verdict-wave",
|
|
GameSession.Status.SCOREBOARD: "podium-ribbon",
|
|
GameSession.Status.FINISHED: "finale-burst",
|
|
}
|
|
|
|
PLAYER_IDENTITY_TONES = (
|
|
"ember",
|
|
"lagoon",
|
|
"gold",
|
|
"sage",
|
|
"coral",
|
|
)
|
|
|
|
PLAYER_IDENTITY_ICONS = (
|
|
"spark",
|
|
"wave",
|
|
"comet",
|
|
"leaf",
|
|
"crown",
|
|
)
|
|
|
|
PLAYER_PHASE_THEMES = {
|
|
"join": "player-boarding",
|
|
"lobby": "player-ready",
|
|
"waiting": "player-holding",
|
|
"lie": "player-ink",
|
|
"guess": "player-choices",
|
|
"reveal": "player-ripple",
|
|
"result": "player-pennant",
|
|
}
|
|
|
|
PLAYER_PHASE_ORNAMENTS = {
|
|
"join": "boarding-pass",
|
|
"lobby": "ready-lantern",
|
|
"waiting": "holding-ring",
|
|
"lie": "ink-trace",
|
|
"guess": "choice-grid",
|
|
"reveal": "ripple-flare",
|
|
"result": "pennant-stack",
|
|
}
|
|
|
|
|
|
def build_player_ref(player: Player | None) -> dict | None:
|
|
if player is None:
|
|
return None
|
|
|
|
return {
|
|
"player_id": player.id,
|
|
"nickname": player.nickname,
|
|
}
|
|
|
|
|
|
def _player_identity_token(nickname: str, join_order: int) -> str:
|
|
initial = nickname.strip()[:1].upper() or "P"
|
|
return f"{initial}{join_order}"
|
|
|
|
|
|
def build_player_identity_payload(player: Player, *, join_order: int) -> dict:
|
|
return {
|
|
"token": _player_identity_token(player.nickname, join_order),
|
|
"tone": PLAYER_IDENTITY_TONES[(join_order - 1) % len(PLAYER_IDENTITY_TONES)],
|
|
"icon": PLAYER_IDENTITY_ICONS[(join_order - 1) % len(PLAYER_IDENTITY_ICONS)],
|
|
}
|
|
|
|
|
|
def build_session_players_payload(session: GameSession) -> list[dict]:
|
|
joined_players = list(session.players.order_by("created_at", "id"))
|
|
identities_by_id = {
|
|
player.id: build_player_identity_payload(player, join_order=index)
|
|
for index, player in enumerate(joined_players, start=1)
|
|
}
|
|
|
|
return [
|
|
{
|
|
"id": player.id,
|
|
"nickname": player.nickname,
|
|
"score": player.score,
|
|
"is_connected": player.is_connected,
|
|
"identity": identities_by_id[player.id],
|
|
}
|
|
for player in sorted(joined_players, key=lambda entry: (entry.nickname.casefold(), entry.id))
|
|
]
|
|
|
|
|
|
def _can_view_round_prompt(session: GameSession, viewer_role: SessionViewerRole) -> bool:
|
|
return viewer_role == "host" or session.status in NON_HOST_PROMPT_PHASES
|
|
|
|
|
|
def build_round_question_payload(
|
|
round_question: RoundQuestion | None,
|
|
*,
|
|
session: GameSession,
|
|
viewer_role: SessionViewerRole,
|
|
) -> dict | None:
|
|
if round_question is None:
|
|
return None
|
|
|
|
return {
|
|
"id": round_question.id,
|
|
"round_number": round_question.round_number,
|
|
"prompt": round_question.question.prompt if _can_view_round_prompt(session, viewer_role) else None,
|
|
"shown_at": round_question.shown_at.isoformat(),
|
|
"answers": [{"text": text} for text in (round_question.mixed_answers or [])],
|
|
}
|
|
|
|
|
|
def build_reveal_payload(
|
|
round_question: RoundQuestion | None,
|
|
*,
|
|
session: GameSession,
|
|
viewer_role: SessionViewerRole,
|
|
) -> dict | None:
|
|
if round_question is None:
|
|
return None
|
|
|
|
lies = [
|
|
{
|
|
**build_player_ref(lie.player),
|
|
"text": lie.text,
|
|
"created_at": lie.created_at.isoformat(),
|
|
}
|
|
for lie in round_question.lies.select_related("player").order_by("created_at", "id")
|
|
]
|
|
|
|
guesses = []
|
|
for guess in round_question.guesses.select_related("player", "fooled_player").order_by("created_at", "id"):
|
|
guess_payload = {
|
|
**build_player_ref(guess.player),
|
|
"selected_text": guess.selected_text,
|
|
"is_correct": guess.is_correct,
|
|
"created_at": guess.created_at.isoformat(),
|
|
"fooled_player_id": guess.fooled_player_id,
|
|
}
|
|
if guess.fooled_player is not None:
|
|
guess_payload["fooled_player_nickname"] = guess.fooled_player.nickname
|
|
guesses.append(guess_payload)
|
|
|
|
return {
|
|
"round_question_id": round_question.id,
|
|
"round_number": round_question.round_number,
|
|
"prompt": round_question.question.prompt if _can_view_round_prompt(session, viewer_role) else None,
|
|
"correct_answer": round_question.correct_answer,
|
|
"lies": lies,
|
|
"guesses": guesses,
|
|
}
|
|
|
|
|
|
def build_voice_cues_payload(
|
|
voice_cues: dict | None,
|
|
*,
|
|
session: GameSession,
|
|
viewer_role: SessionViewerRole,
|
|
) -> dict | None:
|
|
if voice_cues is None:
|
|
return None
|
|
|
|
if viewer_role == "host":
|
|
return voice_cues
|
|
|
|
# Keep non-host payloads role-correct: players can still receive generic intro/phase
|
|
# metadata later if needed, but prompt-bearing cues stay presenter-only until reveal.
|
|
return {
|
|
**voice_cues,
|
|
"question_prompt": None,
|
|
"question_reveal": voice_cues.get("question_reveal") if session.status in NON_HOST_PROMPT_PHASES else None,
|
|
}
|
|
|
|
|
|
def build_leaderboard(session: GameSession) -> list[dict]:
|
|
return list(
|
|
Player.objects.filter(session=session)
|
|
.order_by("-score", "nickname")
|
|
.values("id", "nickname", "score")
|
|
)
|
|
|
|
|
|
def build_lie_started_payload(session: GameSession, round_config: RoundConfig, round_question: RoundQuestion) -> dict:
|
|
lie_deadline_at = round_question.shown_at + timedelta(seconds=round_config.lie_seconds)
|
|
return {
|
|
"round_number": session.current_round,
|
|
"category": {"slug": round_config.category.slug, "name": round_config.category.name},
|
|
"round_question_id": round_question.id,
|
|
"prompt": round_question.question.prompt,
|
|
"shown_at": round_question.shown_at.isoformat(),
|
|
"lie_deadline_at": lie_deadline_at.isoformat(),
|
|
"lie_seconds": round_config.lie_seconds,
|
|
}
|
|
|
|
|
|
def _wait_cue_keys() -> tuple[str, str]:
|
|
return "host.presenter_scene_cue_wait_label", "host.presenter_scene_cue_wait_body"
|
|
|
|
|
|
def _resolve_authored_scene_ornament(
|
|
session: GameSession,
|
|
current_round_question: RoundQuestion | None,
|
|
) -> str | None:
|
|
if session.status not in {
|
|
GameSession.Status.LIE,
|
|
GameSession.Status.GUESS,
|
|
GameSession.Status.REVEAL,
|
|
}:
|
|
return None
|
|
if current_round_question is None:
|
|
return None
|
|
|
|
authored_ornament = current_round_question.question.scene_ornament
|
|
if authored_ornament in Question.SceneOrnament.values:
|
|
return authored_ornament
|
|
return None
|
|
|
|
|
|
def _build_host_phase_display_payload(
|
|
session: GameSession,
|
|
phase_view_model: dict,
|
|
*,
|
|
current_round_question: RoundQuestion | None = None,
|
|
) -> dict:
|
|
phase = session.status
|
|
host = phase_view_model["host"]
|
|
cue_label_key, cue_body_key = _wait_cue_keys()
|
|
|
|
if phase == GameSession.Status.FINISHED:
|
|
cue_label_key = "host.presenter_scene_cue_finished_label"
|
|
cue_body_key = "host.presenter_scene_cue_finished_body"
|
|
title_key = "host.presenter_scene_title_finished"
|
|
body_key = "host.presenter_scene_body_finished"
|
|
elif phase == GameSession.Status.LOBBY:
|
|
if host["can_start_round"]:
|
|
cue_label_key = "host.presenter_scene_cue_start_label"
|
|
cue_body_key = "host.presenter_scene_cue_start_body"
|
|
title_key = "host.presenter_scene_title_lobby"
|
|
body_key = "host.presenter_scene_body_lobby"
|
|
elif phase == GameSession.Status.GUESS:
|
|
if host["can_calculate_scores"]:
|
|
cue_label_key = "host.presenter_scene_cue_reveal_label"
|
|
cue_body_key = "host.presenter_scene_cue_reveal_body"
|
|
title_key = "host.presenter_scene_title_guess"
|
|
body_key = "host.presenter_scene_body_guess"
|
|
elif phase == GameSession.Status.REVEAL:
|
|
if host["can_reveal_scoreboard"]:
|
|
cue_label_key = "host.presenter_scene_cue_scoreboard_label"
|
|
cue_body_key = "host.presenter_scene_cue_scoreboard_body"
|
|
title_key = "host.presenter_scene_title_reveal"
|
|
body_key = "host.presenter_scene_body_reveal"
|
|
elif phase == GameSession.Status.SCOREBOARD:
|
|
if host["can_start_next_round"] or host["can_finish_game"]:
|
|
cue_label_key = "host.presenter_scene_cue_close_label"
|
|
cue_body_key = "host.presenter_scene_cue_close_body"
|
|
title_key = "host.presenter_scene_title_scoreboard"
|
|
body_key = "host.presenter_scene_body_scoreboard"
|
|
else:
|
|
if host["can_mix_answers"]:
|
|
cue_label_key = "host.presenter_scene_cue_mix_label"
|
|
cue_body_key = "host.presenter_scene_cue_mix_body"
|
|
elif host["can_show_question"]:
|
|
cue_label_key = "host.presenter_scene_cue_show_label"
|
|
cue_body_key = "host.presenter_scene_cue_show_body"
|
|
title_key = "host.presenter_scene_title"
|
|
body_key = "host.presenter_scene_body_lie"
|
|
|
|
return {
|
|
"theme": HOST_PHASE_THEMES.get(phase, HOST_PHASE_THEMES[GameSession.Status.LIE]),
|
|
"ornament": _resolve_authored_scene_ornament(session, current_round_question)
|
|
or HOST_PHASE_ORNAMENTS.get(phase, HOST_PHASE_ORNAMENTS[GameSession.Status.LIE]),
|
|
"title_key": title_key,
|
|
"body_key": body_key,
|
|
"cue_label_key": cue_label_key,
|
|
"cue_body_key": cue_body_key,
|
|
}
|
|
|
|
|
|
def _build_player_phase_display_payload(
|
|
session: GameSession,
|
|
phase_view_model: dict,
|
|
viewer_role: SessionViewerRole,
|
|
*,
|
|
current_round_question: RoundQuestion | None = None,
|
|
) -> dict:
|
|
phase = session.status
|
|
player = phase_view_model["player"]
|
|
authored_ornament = _resolve_authored_scene_ornament(session, current_round_question)
|
|
|
|
if viewer_role != "player" and player["can_join"]:
|
|
return {
|
|
"theme": PLAYER_PHASE_THEMES["join"],
|
|
"ornament": PLAYER_PHASE_ORNAMENTS["join"],
|
|
"title_key": "player.player_scene_title_join",
|
|
"body_key": "player.player_scene_body_join",
|
|
"cue_label_key": "player.player_scene_cue_join_label",
|
|
"cue_body_key": "player.player_scene_cue_join_body",
|
|
}
|
|
|
|
if player["can_submit_lie"]:
|
|
return {
|
|
"theme": PLAYER_PHASE_THEMES["lie"],
|
|
"ornament": authored_ornament or PLAYER_PHASE_ORNAMENTS["lie"],
|
|
"title_key": "player.submit_lie",
|
|
"body_key": "player.phase_summary_lie",
|
|
"cue_label_key": "player.active_scene_cue_lie_label",
|
|
"cue_body_key": "player.active_scene_cue_lie_body",
|
|
}
|
|
|
|
if player["can_submit_guess"]:
|
|
return {
|
|
"theme": PLAYER_PHASE_THEMES["guess"],
|
|
"ornament": authored_ornament or PLAYER_PHASE_ORNAMENTS["guess"],
|
|
"title_key": "player.submit_guess",
|
|
"body_key": "player.phase_summary_guess",
|
|
"cue_label_key": "player.active_scene_cue_guess_label",
|
|
"cue_body_key": "player.active_scene_cue_guess_body",
|
|
}
|
|
|
|
if phase == GameSession.Status.REVEAL:
|
|
return {
|
|
"theme": PLAYER_PHASE_THEMES["reveal"],
|
|
"ornament": authored_ornament or PLAYER_PHASE_ORNAMENTS["reveal"],
|
|
"title_key": "player.reveal_title",
|
|
"body_key": "player.phase_summary_reveal",
|
|
"cue_label_key": "player.active_scene_cue_reveal_label",
|
|
"cue_body_key": "player.active_scene_cue_reveal_body",
|
|
}
|
|
|
|
if phase in {GameSession.Status.SCOREBOARD, GameSession.Status.FINISHED} or player["can_view_final_result"]:
|
|
is_finished = phase == GameSession.Status.FINISHED or player["can_view_final_result"]
|
|
return {
|
|
"theme": PLAYER_PHASE_THEMES["result"],
|
|
"ornament": PLAYER_PHASE_ORNAMENTS["result"],
|
|
"title_key": "player.final_leaderboard" if is_finished else "player.scoreboard_title",
|
|
"body_key": "player.phase_summary_finished" if is_finished else "player.phase_summary_scoreboard",
|
|
"cue_label_key": "player.active_scene_cue_result_label",
|
|
"cue_body_key": "player.active_scene_cue_result_body",
|
|
}
|
|
|
|
if phase == GameSession.Status.LOBBY:
|
|
return {
|
|
"theme": PLAYER_PHASE_THEMES["lobby"],
|
|
"ornament": PLAYER_PHASE_ORNAMENTS["lobby"],
|
|
"title_key": "player.player_scene_title_lobby",
|
|
"body_key": "player.player_scene_body_lobby",
|
|
"cue_label_key": "player.player_scene_cue_lobby_label",
|
|
"cue_body_key": "player.player_scene_cue_lobby_body",
|
|
}
|
|
|
|
waiting_title_key = {
|
|
GameSession.Status.LIE: "player.player_scene_title_waiting_lie",
|
|
GameSession.Status.GUESS: "player.player_scene_title_waiting_guess",
|
|
}.get(phase, "player.player_scene_title_waiting")
|
|
return {
|
|
"theme": PLAYER_PHASE_THEMES["waiting"],
|
|
"ornament": authored_ornament or PLAYER_PHASE_ORNAMENTS["waiting"],
|
|
"title_key": waiting_title_key,
|
|
"body_key": "player.player_scene_body_waiting",
|
|
"cue_label_key": "player.player_scene_cue_waiting_label",
|
|
"cue_body_key": "player.player_scene_cue_waiting_body",
|
|
}
|
|
|
|
|
|
def build_phase_display_payload(
|
|
session: GameSession,
|
|
*,
|
|
viewer_role: SessionViewerRole,
|
|
phase_view_model: dict,
|
|
current_round_question: RoundQuestion | None = None,
|
|
) -> dict:
|
|
if viewer_role == "host":
|
|
return _build_host_phase_display_payload(
|
|
session,
|
|
phase_view_model,
|
|
current_round_question=current_round_question,
|
|
)
|
|
|
|
return _build_player_phase_display_payload(
|
|
session,
|
|
phase_view_model,
|
|
viewer_role,
|
|
current_round_question=current_round_question,
|
|
)
|
|
|
|
|
|
def build_phase_view_model(session: GameSession, *, players_count: int, has_round_question: bool) -> dict:
|
|
status = session.status
|
|
in_lobby = status == GameSession.Status.LOBBY
|
|
in_lie = status == GameSession.Status.LIE
|
|
in_guess = status == GameSession.Status.GUESS
|
|
in_scoreboard = status == GameSession.Status.SCOREBOARD
|
|
in_finished = status == GameSession.Status.FINISHED
|
|
|
|
min_players_reached = players_count >= 3
|
|
max_players_allowed = players_count <= 5
|
|
|
|
return {
|
|
"status": status,
|
|
"current_phase": status,
|
|
"round_number": session.current_round,
|
|
"players_count": players_count,
|
|
"constraints": {
|
|
"min_players_to_start": 3,
|
|
"max_players_mvp": 5,
|
|
"min_players_reached": min_players_reached,
|
|
"max_players_allowed": max_players_allowed,
|
|
},
|
|
"readiness": {
|
|
"question_ready": has_round_question,
|
|
"scoreboard_ready": status in {GameSession.Status.REVEAL, GameSession.Status.SCOREBOARD, GameSession.Status.FINISHED},
|
|
"can_advance_to_next_round": in_scoreboard,
|
|
},
|
|
"host": {
|
|
"can_start_round": in_lobby and min_players_reached and max_players_allowed,
|
|
"can_show_question": in_lie and has_round_question,
|
|
"can_mix_answers": (in_lie or in_guess) and has_round_question,
|
|
"can_calculate_scores": in_guess and has_round_question,
|
|
"can_reveal_scoreboard": status == GameSession.Status.REVEAL,
|
|
"can_start_next_round": in_scoreboard,
|
|
"can_finish_game": in_scoreboard,
|
|
},
|
|
"player": {
|
|
"can_join": status in {
|
|
GameSession.Status.LOBBY,
|
|
GameSession.Status.LIE,
|
|
GameSession.Status.GUESS,
|
|
GameSession.Status.REVEAL,
|
|
GameSession.Status.SCOREBOARD,
|
|
},
|
|
"can_submit_lie": in_lie and has_round_question,
|
|
"can_submit_guess": in_guess and has_round_question,
|
|
"can_view_final_result": in_finished,
|
|
},
|
|
}
|
|
|
|
|
|
def build_session_detail_gameplay_payload(
|
|
session: GameSession,
|
|
*,
|
|
current_round_question: RoundQuestion | None,
|
|
players_count: int,
|
|
viewer_role: SessionViewerRole,
|
|
voice_cues: dict | None = None,
|
|
) -> dict:
|
|
phase_view_model = build_phase_view_model(
|
|
session,
|
|
players_count=players_count,
|
|
has_round_question=bool(current_round_question),
|
|
)
|
|
return {
|
|
"round_question": build_round_question_payload(
|
|
current_round_question,
|
|
session=session,
|
|
viewer_role=viewer_role,
|
|
),
|
|
"reveal": build_reveal_payload(
|
|
current_round_question,
|
|
session=session,
|
|
viewer_role=viewer_role,
|
|
)
|
|
if session.status in {GameSession.Status.REVEAL, GameSession.Status.SCOREBOARD} and current_round_question
|
|
else None,
|
|
"scoreboard": build_scoreboard_phase_event(session)["payload"]["leaderboard"]
|
|
if session.status in {GameSession.Status.SCOREBOARD, GameSession.Status.FINISHED}
|
|
else None,
|
|
"voice_cues": build_voice_cues_payload(
|
|
voice_cues,
|
|
session=session,
|
|
viewer_role=viewer_role,
|
|
),
|
|
"phase_view_model": phase_view_model,
|
|
"phase_display": build_phase_display_payload(
|
|
session,
|
|
viewer_role=viewer_role,
|
|
phase_view_model=phase_view_model,
|
|
current_round_question=current_round_question,
|
|
),
|
|
}
|
|
|
|
|
|
def build_start_round_response(
|
|
session: GameSession,
|
|
round_config: RoundConfig,
|
|
round_question: RoundQuestion,
|
|
) -> dict:
|
|
lie_started_payload = build_lie_started_payload(session, round_config, round_question)
|
|
return {
|
|
"session": {
|
|
"code": session.code,
|
|
"status": session.status,
|
|
"current_round": session.current_round,
|
|
},
|
|
"round": {
|
|
"number": round_config.number,
|
|
"category": {
|
|
"slug": round_config.category.slug,
|
|
"name": round_config.category.name,
|
|
},
|
|
},
|
|
"round_question": {
|
|
"id": round_question.id,
|
|
"prompt": round_question.question.prompt,
|
|
"round_number": round_question.round_number,
|
|
"shown_at": round_question.shown_at.isoformat(),
|
|
"lie_deadline_at": lie_started_payload["lie_deadline_at"],
|
|
},
|
|
"config": {
|
|
"lie_seconds": round_config.lie_seconds,
|
|
},
|
|
}
|
|
|
|
|
|
def build_question_shown_payload(round_question: RoundQuestion, lie_deadline_at: str, lie_seconds: int) -> dict:
|
|
return {
|
|
"round_question_id": round_question.id,
|
|
"prompt": round_question.question.prompt,
|
|
"shown_at": round_question.shown_at.isoformat(),
|
|
"lie_deadline_at": lie_deadline_at,
|
|
"lie_seconds": lie_seconds,
|
|
}
|
|
|
|
|
|
def build_question_shown_response(round_question: RoundQuestion, lie_deadline_at: str, lie_seconds: int) -> dict:
|
|
return {
|
|
"round_question": {
|
|
"id": round_question.id,
|
|
"prompt": round_question.question.prompt,
|
|
"round_number": round_question.round_number,
|
|
"shown_at": round_question.shown_at.isoformat(),
|
|
"lie_deadline_at": lie_deadline_at,
|
|
},
|
|
"config": {
|
|
"lie_seconds": lie_seconds,
|
|
},
|
|
}
|
|
|
|
|
|
def build_start_next_round_response(
|
|
session: GameSession,
|
|
round_config: RoundConfig,
|
|
round_question: RoundQuestion,
|
|
) -> dict:
|
|
return build_start_round_response(session, round_config, round_question)
|
|
|
|
|
|
def build_start_next_round_phase_event(
|
|
session: GameSession,
|
|
round_config: RoundConfig,
|
|
round_question: RoundQuestion,
|
|
) -> dict:
|
|
return {
|
|
"name": "phase.lie_started",
|
|
"payload": build_lie_started_payload(session, round_config, round_question),
|
|
}
|
|
|
|
|
|
def build_scoreboard_phase_event(session: GameSession, leaderboard: list[dict] | None = None) -> dict:
|
|
return {
|
|
"name": "phase.scoreboard",
|
|
"payload": {
|
|
"leaderboard": leaderboard if leaderboard is not None else build_leaderboard(session),
|
|
"current_round": session.current_round,
|
|
},
|
|
}
|
|
|
|
|
|
def build_reveal_scoreboard_response(session: GameSession, leaderboard: list[dict]) -> dict:
|
|
return {
|
|
"session": {
|
|
"code": session.code,
|
|
"status": session.status,
|
|
"current_round": session.current_round,
|
|
},
|
|
"leaderboard": leaderboard,
|
|
}
|
|
|
|
|
|
def build_finish_game_phase_event(session: GameSession) -> dict:
|
|
leaderboard = build_leaderboard(session)
|
|
winner = leaderboard[0] if leaderboard else None
|
|
return {
|
|
"name": "phase.game_over",
|
|
"payload": {"winner": winner, "leaderboard": leaderboard},
|
|
}
|
|
|
|
|
|
def build_finish_game_response(session: GameSession) -> dict:
|
|
finish_event = build_finish_game_phase_event(session)
|
|
return {
|
|
"session": {
|
|
"code": session.code,
|
|
"status": GameSession.Status.FINISHED,
|
|
"current_round": session.current_round,
|
|
},
|
|
"winner": finish_event["payload"]["winner"],
|
|
"leaderboard": finish_event["payload"]["leaderboard"],
|
|
}
|