# v0.2.17 # { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from genlayer import * import json PITS_PER_PLAYER = 6 STARTING_SEEDS = 4 BOARD_SIZE = 12 CAPTURE_THRESHOLD = 4 # exactly 4 seeds = capture (authentic Ayo Olopon) AI_SENTINEL = "0x000000000000000000000000000000000000A710" ACHIEVEMENT_DEFS = """ Available achievements (id -> unlock condition): first_blood : Won their first ever match precision_player : Made 3 or more captures in a single match multi_haul : Made captures in 4 or more different turns within a single match comeback_king : Won a match after being 10+ seeds behind at some point strategist : Won a ranked match veteran : Completed 10 or more total matches champion : Won 5 or more ranked matches total speed_run : Won a match in fewer than 15 turns ota_champion : Achieved a win streak of 3 or more consecutive wins (Ota status) ai_slayer : Defeated the AI opponent on any difficulty """ class AyoGen(gl.Contract): # ── core state ────────────────────────────────────────────────────────── owner: Address match_count: u256 profiles: TreeMap[Address, str] stats: TreeMap[Address, str] matches: TreeMap[str, str] player_matches: TreeMap[Address, str] # ── leaderboard ───────────────────────────────────────────────────────── all_players: str # JSON array of address strings (appended on set_profile) # ── intelligence state ─────────────────────────────────────────────────── ai_matches: TreeMap[str, str] coaching_cache: TreeMap[str, str] commentary_cache: TreeMap[str, str] hint_cache: TreeMap[str, str] style_cache: TreeMap[Address, str] achievements: TreeMap[Address, str] daily_puzzle: str puzzle_date: str def __init__(self): self.owner = gl.message.sender_address self.match_count = u256(0) self.all_players = "[]" self.daily_puzzle = "" self.puzzle_date = "" def _addr_key(self, player) -> Address: """ Normalise externally supplied address values before using them as keys in TreeMap[Address, str]. GenLayer storage expects Address keys, not raw Python strings; otherwise writes fail with: 'str' object has no attribute 'as_bytes'. """ return player if isinstance(player, Address) else Address(str(player)) def _json_cache(self, value) -> str: """ Store nondeterministic JSON responses safely. In normal successful cases run_nondet_unsafe returns the validated calldata directly. This helper also handles Return-like wrappers defensively. """ if hasattr(value, "calldata"): value = value.calldata return json.dumps(value) # ═══════════════════════════════════════════════════════════════════════ # PROFILES & STATS # ═══════════════════════════════════════════════════════════════════════ @gl.public.write def set_profile(self, username: str, avatar_id: str): assert len(username) >= 2, "Username too short" assert len(username) <= 24, "Username too long" sender = gl.message.sender_address profile = {"address": str(sender), "username": username, "avatarId": avatar_id} self.profiles[sender] = json.dumps(profile) if self.stats.get(sender, "") == "": self.stats[sender] = json.dumps( {"wins": 0, "losses": 0, "draws": 0, "matches": 0, "rating": 1000, "win_streak": 0}) players = json.loads(self.all_players) addr_str = str(sender) if addr_str not in players: players.append(addr_str) self.all_players = json.dumps(players) @gl.public.view def get_profile(self, player: Address) -> str: return self.profiles.get(self._addr_key(player), "") @gl.public.view def get_stats(self, player: Address) -> str: return self.stats.get(self._addr_key(player), "") @gl.public.view def get_leaderboard(self) -> str: players = json.loads(self.all_players) result = [] for addr_str in players: addr = Address(addr_str) profile_raw = self.profiles.get(addr, "") stats_raw = self.stats.get(addr, "") result.append({ "address": addr_str, "profile": json.loads(profile_raw) if profile_raw else None, "stats": json.loads(stats_raw) if stats_raw else None, }) return json.dumps(result) # ═══════════════════════════════════════════════════════════════════════ # MATCH LIFECYCLE # ═══════════════════════════════════════════════════════════════════════ @gl.public.write def create_match(self, invite_code: str, ranked: bool): creator = gl.message.sender_address assert len(invite_code) >= 4, "Invite code too short" assert self.matches.get(invite_code, "") == "", "Match code already exists" board = [STARTING_SEEDS for _ in range(BOARD_SIZE)] data = { "id": invite_code, "player1": str(creator), "player2": "", "ranked": ranked, "status": "waiting", "board": board, "store1": 0, "store2": 0, "currentPlayer": str(creator), "turn": 0, "winner": "", "moveHistory": [], "createdBy": str(creator) } self.matches[invite_code] = json.dumps(data) self.match_count = self.match_count + u256(1) self._add_player_match(creator, invite_code) @gl.public.write def create_ai_match(self, invite_code: str, ranked: bool, personality: str): creator = gl.message.sender_address assert len(invite_code) >= 4, "Invite code too short" assert self.matches.get(invite_code, "") == "", "Match code already exists" valid_personalities = ["novice", "balanced", "tactical", "strategic", "grandmaster"] if personality not in valid_personalities: personality = "balanced" board = [STARTING_SEEDS for _ in range(BOARD_SIZE)] data = { "id": invite_code, "player1": str(creator), "player2": AI_SENTINEL, "ranked": ranked, "status": "active", "board": board, "store1": 0, "store2": 0, "currentPlayer": str(creator), "turn": 0, "winner": "", "moveHistory": [], "createdBy": str(creator) } self.matches[invite_code] = json.dumps(data) self.ai_matches[invite_code] = json.dumps({"personality": personality, "aiPlayer": 2}) self.match_count = self.match_count + u256(1) self._add_player_match(creator, invite_code) @gl.public.write def join_match(self, invite_code: str): joiner = gl.message.sender_address raw = self.matches.get(invite_code, "") assert raw != "", "Match not found" data = json.loads(raw) assert data["status"] == "waiting", "Match not joinable" assert data["player1"] != str(joiner), "Cannot join your own match" data["player2"] = str(joiner) data["status"] = "active" self.matches[invite_code] = json.dumps(data) self._add_player_match(joiner, invite_code) @gl.public.write def cancel_match(self, invite_code: str): caller = gl.message.sender_address raw = self.matches.get(invite_code, "") assert raw != "", "Match not found" data = json.loads(raw) assert data["status"] == "waiting", "Only waiting matches can be cancelled" assert data["createdBy"] == str(caller), "Only creator can cancel" data["status"] = "cancelled" self.matches[invite_code] = json.dumps(data) @gl.public.write def resign_match(self, invite_code: str): caller = gl.message.sender_address raw = self.matches.get(invite_code, "") assert raw != "", "Match not found" data = json.loads(raw) assert data["status"] == "active", "Only active matches can be resigned" player1 = data["player1"] player2 = data["player2"] assert str(caller) == player1 or str(caller) == player2, "Not a player" winner = player2 if str(caller) == player1 else player1 data["status"] = "finished" data["winner"] = winner self._record_result(winner, str(caller), data["ranked"]) self.matches[invite_code] = json.dumps(data) # ═══════════════════════════════════════════════════════════════════════ # DETERMINISTIC MOVE ENGINE # ═══════════════════════════════════════════════════════════════════════ @gl.public.write def play_move(self, invite_code: str, pit_index: u256): player = gl.message.sender_address raw = self.matches.get(invite_code, "") assert raw != "", "Match not found" data = json.loads(raw) assert data["status"] == "active", "Match is not active" assert data["currentPlayer"] == str(player), "Not your turn" p = int(pit_index) player1, player2 = data["player1"], data["player2"] is_p1 = str(player) == player1 is_p2 = str(player) == player2 assert is_p1 or is_p2, "Not a player in this match" if is_p1: assert 0 <= p <= 5, "Player 1 must choose pits 0-5" else: assert 6 <= p <= 11, "Player 2 must choose pits 6-11" board = data["board"] assert board[p] > 0, "Pit is empty" if is_p1: opp_seeds = sum(board[i] for i in range(6, 12)) else: opp_seeds = sum(board[i] for i in range(0, 6)) if opp_seeds == 0: if is_p1: my_pits = [i for i in range(0, 6) if board[i] > 0] else: my_pits = [i for i in range(6, 12) if board[i] > 0] feeding = [pit for pit in my_pits if self._would_feed(board, pit, is_p1)] if len(feeding) == 0: self._end_game_sweep(invite_code, data, is_p1) return assert p in feeding, "Opponent has no seeds - you must choose a move that feeds them" self._run_move(invite_code, data, str(player), is_p1, p) @gl.public.write def ai_move(self, invite_code: str): """AI picks its move using an LLM. Callable by anyone.""" raw = self.matches.get(invite_code, "") assert raw != "", "Match not found" data = json.loads(raw) assert data["status"] == "active", "Match is not active" ai_raw = self.ai_matches.get(invite_code, "") assert ai_raw != "", "Not an AI match" ai_cfg = json.loads(ai_raw) ai_side = ai_cfg["aiPlayer"] ai_addr = data["player1"] if ai_side == 1 else data["player2"] assert data["currentPlayer"] == ai_addr, "Not the AI's turn" personality = ai_cfg["personality"] board = data["board"] is_ai_p1 = (ai_side == 1) if is_ai_p1: candidates = [i for i in range(0, 6) if board[i] > 0] opp_seeds = sum(board[i] for i in range(6, 12)) else: candidates = [i for i in range(6, 12) if board[i] > 0] opp_seeds = sum(board[i] for i in range(0, 6)) assert len(candidates) > 0, "No moves for AI" if opp_seeds == 0: feeding = [pit for pit in candidates if self._would_feed(board, pit, is_ai_p1)] if len(feeding) == 0: self._end_game_sweep(invite_code, data, is_ai_p1) return legal = feeding else: legal = candidates prompt = ( f"You are an Ayo Olopon AI playing as Player {ai_side}.\n" f"Board (0-5=P1, 6-11=P2): {board}\n" f"Captured: P1={data['store1']}, P2={data['store2']}\n" f"Your legal pits: {legal}\n" f"Personality: {personality} " f"(novice=make occasional mistakes, balanced=solid, " f"tactical=prioritise captures, strategic=long-term, grandmaster=optimal)\n" f"Rules: no relay sowing. Capture when last seed on opponent side makes exactly 4.\n" f"Reply with ONLY one integer from {legal}. Nothing else." ) def _leader(): return gl.nondet.exec_prompt(prompt) def _validator(lr) -> bool: if not isinstance(lr, gl.vm.Return): return False try: val = int(str(lr.calldata).strip().split()[0]) return val in legal except Exception: return False result = gl.vm.run_nondet_unsafe(_leader, _validator) try: chosen = int(str(result).strip().split()[0]) except Exception: chosen = legal[0] if chosen not in legal: chosen = legal[0] self._run_move(invite_code, data, ai_addr, is_ai_p1, chosen) # ═══════════════════════════════════════════════════════════════════════ # INTELLIGENCE ENGINE — WRITE # ═══════════════════════════════════════════════════════════════════════ @gl.public.write def request_coaching(self, invite_code: str): raw = self.matches.get(invite_code, "") assert raw != "", "Match not found" data = json.loads(raw) assert data["status"] == "finished", "Match must be finished for coaching" player1, player2 = data["player1"], data["player2"] winner_label = ("Player 1" if data["winner"] == player1 else "Player 2" if data["winner"] == player2 else "Draw") move_lines = "\n".join( f"Turn {m['turn']}: Player {'1' if m['player'] == player1 else '2'} " f"played pit {m['pit']} (P1 captured: {m['store1']}, P2 captured: {m['store2']})" for m in (data["moveHistory"] or []) ) prompt = ( f"You are an expert Ayo Olopon coach. Analyse this finished match.\n" f"Rules: capture by landing last seed on opponent side making exactly 4 seeds. No relay sowing.\n" f"Final score: P1={data['store1']} captured, P2={data['store2']} captured\n" f"Winner: {winner_label} | Total turns: {data['turn']}\n" f"Move history:\n{move_lines}\n\n" f"Return a JSON object with these exact keys:\n" f"summary (string), p1_strengths (array), p1_improvements (array), " f"p2_strengths (array), p2_improvements (array), " f"key_moments (array of {{turn, note}}), mvp_move ({{turn, pit, why}} or null)" ) def _leader(): return gl.nondet.exec_prompt(prompt, response_format="json") def _validate(lr) -> bool: if not isinstance(lr, gl.vm.Return): return False d = lr.calldata return isinstance(d, dict) and "summary" in d result = gl.vm.run_nondet_unsafe(_leader, _validate) self.coaching_cache[invite_code] = self._json_cache(result) @gl.public.write def request_commentary(self, invite_code: str): raw = self.matches.get(invite_code, "") assert raw != "", "Match not found" data = json.loads(raw) assert data["status"] == "finished", "Match must be finished for commentary" player1 = data["player1"] winner_label = ("Player 1" if data["winner"] == player1 else "Player 2" if data["winner"] != "draw" else "neither player - it was a draw") move_lines = "\n".join( f"Turn {m['turn']}: Player {'1' if m['player'] == player1 else '2'} chose pit {m['pit']}" for m in (data["moveHistory"] or []) ) prompt = ( f"Write an exciting match report for an Ayo Olopon game. " f"Write like a sports commentator - vivid, celebratory, culturally rich.\n" f"Capture happens when the last seed makes an opponent pit exactly 4 seeds.\n\n" f"{move_lines}\n\n" f"Final: P1 captured {data['store1']} seeds, P2 captured {data['store2']} seeds. " f"{winner_label} won.\n\n" f"Write 3-5 punchy paragraphs. Plain prose only, no JSON." ) def _leader(): return gl.nondet.exec_prompt(prompt) def _validate(lr) -> bool: if not isinstance(lr, gl.vm.Return): return False return isinstance(lr.calldata, str) and len(lr.calldata.strip()) > 0 result = gl.vm.run_nondet_unsafe(_leader, _validate) self.commentary_cache[invite_code] = result @gl.public.write def request_hint(self, invite_code: str): player = gl.message.sender_address raw = self.matches.get(invite_code, "") assert raw != "", "Match not found" data = json.loads(raw) assert data["status"] == "active", "Match must be active for a hint" assert data["currentPlayer"] == str(player), "It is not your turn" player1 = data["player1"] is_p1 = str(player) == player1 board = data["board"] if is_p1: legal = [i for i in range(0, 6) if board[i] > 0] else: legal = [i for i in range(6, 12) if board[i] > 0] if is_p1: opp_seeds = sum(board[i] for i in range(6, 12)) else: opp_seeds = sum(board[i] for i in range(0, 6)) if opp_seeds == 0: feeding = [p for p in legal if self._would_feed(board, p, is_p1)] if feeding: legal = feeding prompt = ( f"You are a friendly Ayo Olopon coach giving a hint.\n" f"Board: {board}\n" f"Player {'1' if is_p1 else '2'} legal moves: {legal}\n" f"P1 captured: {data['store1']}, P2 captured: {data['store2']}\n" f"Capture rule: last seed on opponent side makes exactly 4 seeds -> capture.\n" f"No relay sowing. Single-pit capture only.\n\n" f"Return a JSON object with keys: " f"suggested_pit (integer from {legal}), " f"explanation (string, 1-2 sentences), " f"warning (string or null)" ) def _leader(): return gl.nondet.exec_prompt(prompt, response_format="json") def _validate(lr) -> bool: if not isinstance(lr, gl.vm.Return): return False d = lr.calldata return isinstance(d, dict) and "suggested_pit" in d result = gl.vm.run_nondet_unsafe(_leader, _validate) self.hint_cache[invite_code] = self._json_cache(result) @gl.public.write def request_style_analysis(self, player: Address): player_key = self._addr_key(player) player_str = str(player_key) stats_raw = self.stats.get(player_key, "") stats = json.loads(stats_raw) if stats_raw else {"wins": 0, "losses": 0, "draws": 0, "matches": 0, "rating": 1000, "win_streak": 0} codes_raw = self.player_matches.get(player_key, "[]") codes = json.loads(codes_raw) recent = codes[-10:] if len(codes) > 10 else codes summaries = [] for code in recent: m_raw = self.matches.get(code, "") if m_raw == "": continue m = json.loads(m_raw) if m["status"] != "finished": continue is_p1 = m["player1"] == player_str my_c = m["store1"] if is_p1 else m["store2"] op_c = m["store2"] if is_p1 else m["store1"] my_mv = [mv for mv in (m["moveHistory"] or []) if mv["player"] == player_str] summaries.append( f"Match {code}: {'won' if m['winner'] == str(player) else 'lost' if m['winner'] != 'draw' else 'drew'}, " f"captured {my_c} vs opp {op_c}, {len(my_mv)} moves played" ) summary_str = "\n".join(summaries) if summaries else "No completed matches yet." prompt = ( f"Analyse this Ayo Olopon player's style.\n" f"Stats: {stats['wins']}W / {stats['losses']}L / {stats['draws']}D " f"| Rating: {stats['rating']} | Streak: {stats.get('win_streak', 0)}\n" f"Recent matches:\n{summary_str}\n\n" f"Return a JSON object with keys: " f"archetype (string, short catchy title), " f"description (string, 2-3 sentences), " f"strengths (array of 3 strings), " f"weaknesses (array of 2 strings), " f"tip (string, one actionable improvement), " f"capture_tendency (one of: high, medium, low)" ) def _leader(): return gl.nondet.exec_prompt(prompt, response_format="json") def _validate(lr) -> bool: if not isinstance(lr, gl.vm.Return): return False d = lr.calldata return isinstance(d, dict) and "archetype" in d result = gl.vm.run_nondet_unsafe(_leader, _validate) self.style_cache[player_key] = self._json_cache(result) @gl.public.write def check_achievements(self, player: Address): player_key = self._addr_key(player) player_str = str(player_key) stats_raw = self.stats.get(player_key, "") stats = json.loads(stats_raw) if stats_raw else {"wins": 0, "losses": 0, "draws": 0, "matches": 0, "rating": 1000, "win_streak": 0} codes_raw = self.player_matches.get(player_key, "[]") codes = json.loads(codes_raw) existing_raw = self.achievements.get(player_key, "[]") existing = json.loads(existing_raw) existing_ids = [a["id"] for a in existing] match_data = [] for code in codes[-20:]: m_raw = self.matches.get(code, "") if m_raw == "": continue m = json.loads(m_raw) if m["status"] != "finished": continue is_p1 = m["player1"] == player_str my_mv = [mv for mv in (m["moveHistory"] or []) if mv["player"] == player_str] captures = 0 prev = 0 for mv in my_mv: cur = mv["store1"] if is_p1 else mv["store2"] if cur > prev: captures += 1 prev = cur match_data.append({ "won": m["winner"] == player_str, "ranked": m["ranked"], "turns": m["turn"], "my_captured": m["store1"] if is_p1 else m["store2"], "opp_captured": m["store2"] if is_p1 else m["store1"], "vs_ai": (m["player2"] == AI_SENTINEL or m["player1"] == AI_SENTINEL), "captures_in_match": captures }) prompt = ( f"Check which Ayo Olopon achievements this player has newly unlocked.\n" f"{ACHIEVEMENT_DEFS}\n" f"Stats: {stats} | Win streak: {stats.get('win_streak', 0)}\n" f"Already earned: {existing_ids}\n" f"Recent match data: {match_data}\n\n" f"Return a JSON object with key 'achievements' whose value is an array " f"of newly earned achievement ID strings (not ones already earned). " f"Example: {{\"achievements\": [\"first_blood\", \"veteran\"]}} " f"If none are newly earned return {{\"achievements\": []}}" ) def _leader(): return gl.nondet.exec_prompt(prompt, response_format="json") def _validate(lr) -> bool: if not isinstance(lr, gl.vm.Return): return False d = lr.calldata return isinstance(d, dict) and isinstance(d.get("achievements"), list) result = gl.vm.run_nondet_unsafe(_leader, _validate) new_ids = result.get("achievements", []) if not isinstance(new_ids, list): new_ids = [] import time ts = int(time.time() * 1000) if hasattr(time, "time") else 0 new_entries = [{"id": aid, "earnedAt": ts} for aid in new_ids if isinstance(aid, str)] self.achievements[player_key] = json.dumps(existing + new_entries) @gl.public.write def generate_daily_puzzle(self, today: str): if self.puzzle_date == today and self.daily_puzzle != "": return prompt = ( "Generate an Ayo Olopon daily puzzle.\n" "Create a challenging but solvable 12-pit board position where one move leads " "to an excellent outcome (a capture or strong positional advantage).\n" "Rules: pits 0-5 belong to Player 1, pits 6-11 to Player 2. No stores.\n" "Capture: last seed on opponent side makes that pit hold EXACTLY 4 seeds.\n" "No relay sowing. No capture chains.\n\n" "Return a JSON object with keys: " "date (string YYYY-MM-DD), " "board (array of 12 non-negative integers, total between 20 and 40), " "currentPlayer (1 or 2), " "challenge (string, one sentence), " "solution_pit (integer, legal pit for currentPlayer), " "solution_explanation (string, 2-3 sentences), " "difficulty (one of: easy, medium, hard)" ) def _leader(): return gl.nondet.exec_prompt(prompt, response_format="json") def _validate(lr) -> bool: if not isinstance(lr, gl.vm.Return): return False d = lr.calldata return (isinstance(d, dict) and isinstance(d.get("board"), list) and len(d.get("board", [])) == 12) result = gl.vm.run_nondet_unsafe(_leader, _validate) self.daily_puzzle = self._json_cache(result) self.puzzle_date = today # ═══════════════════════════════════════════════════════════════════════ # INTELLIGENCE ENGINE — VIEWS # ═══════════════════════════════════════════════════════════════════════ @gl.public.view def get_coaching(self, invite_code: str) -> str: return self.coaching_cache.get(invite_code, "") @gl.public.view def get_commentary(self, invite_code: str) -> str: return self.commentary_cache.get(invite_code, "") @gl.public.view def get_hint(self, invite_code: str) -> str: return self.hint_cache.get(invite_code, "") @gl.public.view def get_style_analysis(self, player: Address) -> str: return self.style_cache.get(self._addr_key(player), "") @gl.public.view def get_achievements(self, player: Address) -> str: return self.achievements.get(self._addr_key(player), "[]") @gl.public.view def get_daily_puzzle(self) -> str: return self.daily_puzzle @gl.public.view def get_puzzle_date(self) -> str: return self.puzzle_date @gl.public.view def is_ai_match(self, invite_code: str) -> bool: return self.ai_matches.get(invite_code, "") != "" @gl.public.view def get_ai_config(self, invite_code: str) -> str: return self.ai_matches.get(invite_code, "") @gl.public.view def get_match(self, invite_code: str) -> str: return self.matches.get(invite_code, "") @gl.public.view def get_player_matches(self, player: Address) -> str: return self.player_matches.get(self._addr_key(player), "[]") @gl.public.view def total_matches(self) -> u256: return self.match_count # ═══════════════════════════════════════════════════════════════════════ # PRIVATE HELPERS # ═══════════════════════════════════════════════════════════════════════ def _would_feed(self, board: list, pit: int, is_p1: bool) -> bool: seeds = board[pit] if seeds == 0: return False opp_start, opp_end = (6, 11) if is_p1 else (0, 5) index = pit remaining = seeds while remaining > 0: index = (index + 1) % BOARD_SIZE if index == pit: continue remaining -= 1 if opp_start <= index <= opp_end: return True return False def _end_game_sweep(self, invite_code: str, data: dict, is_p1: bool): board = data["board"] store1 = data["store1"] store2 = data["store2"] player1 = data["player1"] player2 = data["player2"] remaining = sum(board) for i in range(BOARD_SIZE): board[i] = 0 if is_p1: store1 += remaining else: store2 += remaining if store1 > store2: winner = player1 elif store2 > store1: winner = player2 else: winner = "draw" data["board"] = board data["store1"] = store1 data["store2"] = store2 data["status"] = "finished" data["winner"] = winner if winner != "draw": loser = player2 if winner == player1 else player1 self._record_result(winner, loser, data["ranked"]) else: self._record_draw(player1, player2) self.matches[invite_code] = json.dumps(data) def _run_move(self, invite_code: str, data: dict, player_addr: str, is_p1: bool, p: int): board = data["board"] store1 = data["store1"] store2 = data["store2"] player1 = data["player1"] player2 = data["player2"] seeds = board[p] board[p] = 0 index = p while seeds > 0: index = (index + 1) % BOARD_SIZE if index == p: continue board[index] += 1 seeds -= 1 landing = index landed_count = board[landing] if is_p1: on_opp = (6 <= landing <= 11) else: on_opp = (0 <= landing <= 5) if on_opp and landed_count == CAPTURE_THRESHOLD: if is_p1: store1 += CAPTURE_THRESHOLD else: store2 += CAPTURE_THRESHOLD board[landing] = 0 next_player = player2 if is_p1 else player1 next_is_p1 = (next_player == player1) data["turn"] += 1 data["moveHistory"].append({ "player": player_addr, "pit": p, "turn": data["turn"], "store1": store1, "store2": store2 }) data["board"] = board data["store1"] = store1 data["store2"] = store2 if next_is_p1: next_seeds = sum(board[i] for i in range(0, 6)) else: next_seeds = sum(board[i] for i in range(6, 12)) if next_seeds == 0: self._end_game_sweep(invite_code, data, is_p1) else: data["currentPlayer"] = next_player self.matches[invite_code] = json.dumps(data) def _add_player_match(self, player: Address, code: str): player_key = self._addr_key(player) raw = self.player_matches.get(player_key, "[]") arr = json.loads(raw) arr.append(code) self.player_matches[player_key] = json.dumps(arr) def _record_result(self, winner: str, loser: str, ranked: bool): wa = Address(winner); la = Address(loser) default = {"wins": 0, "losses": 0, "draws": 0, "matches": 0, "rating": 1000, "win_streak": 0} w = json.loads(self.stats.get(wa, "")) if self.stats.get(wa, "") else dict(default) l = json.loads(self.stats.get(la, "")) if self.stats.get(la, "") else dict(default) if "win_streak" not in w: w["win_streak"] = 0 if "win_streak" not in l: l["win_streak"] = 0 w["wins"] += 1; w["matches"] += 1; w["win_streak"] += 1 l["losses"] += 1; l["matches"] += 1; l["win_streak"] = 0 if ranked: w["rating"] += 15 l["rating"] = max(100, l["rating"] - 10) self.stats[wa] = json.dumps(w) self.stats[la] = json.dumps(l) def _record_draw(self, p1: str, p2: str): a1 = Address(p1); a2 = Address(p2) default = {"wins": 0, "losses": 0, "draws": 0, "matches": 0, "rating": 1000, "win_streak": 0} s1 = json.loads(self.stats.get(a1, "")) if self.stats.get(a1, "") else dict(default) s2 = json.loads(self.stats.get(a2, "")) if self.stats.get(a2, "") else dict(default) if "win_streak" not in s1: s1["win_streak"] = 0 if "win_streak" not in s2: s2["win_streak"] = 0 s1["draws"] += 1; s1["matches"] += 1 s2["draws"] += 1; s2["matches"] += 1 self.stats[a1] = json.dumps(s1) self.stats[a2] = json.dumps(s2)