# { "Depends": "py-genlayer:test" } from genlayer import * import base64 import json class QuickDrawShowdown(gl.Contract): room_code: str owner: str round_id: u32 round_active: bool round_start_ms: u64 round_end_ms: u64 round_seconds: u32 mode: str topic: str prompt: str ai_mode: str judge_status: str last_error: str participants: DynArray[str] progress: TreeMap[str, u32] finish_ms: TreeMap[str, u64] drawings_b64: TreeMap[str, str] quality_scores: TreeMap[str, u32] final_scores: TreeMap[str, u32] reasons: TreeMap[str, str] ranking: DynArray[str] def __init__(self, room_code: str, owner: str): self.room_code = self._normalize_room(room_code) self.owner = owner self.round_id = u32(0) self.round_active = False self.round_start_ms = u64(0) self.round_end_ms = u64(0) self.round_seconds = u32(60) self.mode = "funny" self.topic = "" self.prompt = "Press start to get an AI prompt." self.ai_mode = "IDLE" self.judge_status = "NONE" self.last_error = "" pass @gl.public.write def start_round(self, room_code: str, mode: str, user_topic: str, now_ms: u64): self._ensure_room(room_code) if self.round_active: raise Exception("ROUND_ALREADY_ACTIVE") self.round_id = self.round_id + u32(1) self.round_active = True self.round_start_ms = now_ms self.round_end_ms = now_ms + u64(self.round_seconds) * u64(1000) self.mode = self._normalize_mode(mode) self.topic = user_topic.strip() self.judge_status = "OPEN" self.last_error = "" self.participants.clear() self.progress.clear() self.finish_ms.clear() self.drawings_b64.clear() self.quality_scores.clear() self.final_scores.clear() self.reasons.clear() self.ranking.clear() local_mode = self.mode local_topic = self.topic local_round = int(self.round_id) local_duration = int(self.round_seconds) def generate_idea(): task = f""" You are a creative game host for "Quick Draw Showdown". Generate ONE drawing prompt for a {local_duration}-second round. Mode: - funny: silly visual situations - crypto: web3/crypto visual scenarios - custom: use user topic as core inspiration Selected mode: {local_mode} User topic: {local_topic} Return JSON only with keys: - short_label: string, <= 30 chars - idea: string, concrete and drawable in one frame - tip: string, one practical drawing tip No markdown, no extra keys. """ return gl.nondet.exec_prompt(task, response_format="json") try: result = gl.eq_principle.strict_eq(generate_idea) idea = self._safe_get_str(result, "idea") tip = self._safe_get_str(result, "tip") short_label = self._safe_get_str(result, "short_label") if len(idea) < 8: raise Exception("IDEA_TOO_SHORT") self.prompt = f"[{short_label}] {idea} | Tip: {tip}" self.ai_mode = "AI" except Exception as e: self.prompt = self._fallback_prompt(local_mode, local_topic, local_round) self.ai_mode = "FALLBACK_ONCHAIN" self.last_error = f"IDEA_FALLBACK:{str(e)}" @gl.public.write def submit_drawing(self, room_code: str, player: str, image_b64: str, finish_ms: u64, progress_pct: u32): self._ensure_room(room_code) if not self.round_active: raise Exception("ROUND_NOT_ACTIVE") p = player.strip() if len(p) < 4: raise Exception("INVALID_PLAYER") if len(image_b64) < 64: raise Exception("EMPTY_IMAGE") if len(image_b64) > 900000: raise Exception("IMAGE_TOO_LARGE") if self.progress.get(p, u32(101)) == u32(101): self.participants.append(p) self.progress[p] = self._clamp_u32(progress_pct, u32(0), u32(100)) self.drawings_b64[p] = image_b64 if finish_ms < self.round_start_ms: finish_ms = self.round_start_ms if finish_ms > self.round_end_ms: finish_ms = self.round_end_ms self.finish_ms[p] = finish_ms @gl.public.write def close_round(self, room_code: str, now_ms: u64): self._ensure_room(room_code) if not self.round_active: raise Exception("ROUND_NOT_ACTIVE") if now_ms < self.round_end_ms: raise Exception("ROUND_TIMER_NOT_FINISHED") self.round_active = False self.judge_status = "READY" @gl.public.write def judge_round(self, room_code: str): self._ensure_room(room_code) if self.round_active: raise Exception("ROUND_STILL_ACTIVE") if len(self.participants) == 0: raise Exception("NO_SUBMISSIONS") fallback_count = 0 players = [p for p in self.participants] start_ms = int(self.round_start_ms) round_ms = max(1, int(self.round_seconds) * 1000) for p in players: drawing = self.drawings_b64.get(p, "") pg = int(self.progress.get(p, u32(0))) finish = int(self.finish_ms.get(p, u64(0))) quality = 0 reason = "No image" if len(drawing) > 0: try: payload = drawing.split(",", 1)[1] if "," in drawing else drawing image_bytes = base64.b64decode(payload) local_prompt = self.prompt local_pg = pg def score_image(): rubric = f""" You are a drawing judge. Task prompt: {local_prompt} Return JSON only: - quality: integer 0..100 - completeness: integer 0..100 - reason: short string <= 120 chars Criteria: - recognizability of prompt - composition clarity - completeness under time pressure Current declared progress: {local_pg} """ return gl.nondet.exec_prompt(rubric, response_format="json", images=[image_bytes]) data = gl.eq_principle.strict_eq(score_image) q = self._safe_get_int(data, "quality") c = self._safe_get_int(data, "completeness") reason = self._safe_get_str(data, "reason") quality = self._clamp_int((q + c) // 2, 0, 100) except Exception as e: fallback_count += 1 quality = self._fallback_quality(pg, len(drawing)) reason = f"Fallback quality from progress; {str(e)}" else: fallback_count += 1 quality = self._fallback_quality(pg, 0) reason = "Fallback quality (missing drawing)" if finish > 0: elapsed = max(0, finish - start_ms) elapsed = min(elapsed, round_ms) speed = self._clamp_int(100 - int((elapsed * 100) / round_ms), 0, 100) else: speed = 0 final_score = int((quality * 60 + speed * 40) / 100) if pg < 30: final_score = int(final_score * 0.6) elif pg < 60: final_score = int(final_score * 0.8) self.quality_scores[p] = u32(quality) self.final_scores[p] = u32(self._clamp_int(final_score, 0, 100)) self.reasons[p] = reason players.sort(key=lambda x: int(self.final_scores.get(x, u32(0))), reverse=True) self.ranking.clear() for p in players: self.ranking.append(p) self.judge_status = "DONE" if fallback_count == 0: self.ai_mode = "AI" elif fallback_count == len(players): self.ai_mode = "FALLBACK_ONCHAIN" else: self.ai_mode = "MIXED_FALLBACK" @gl.public.write def judge_round_manual(self, room_code: str, ranking_json: str, reason: str): self._ensure_room(room_code) self.ranking.clear() self.final_scores.clear() self.reasons.clear() self.quality_scores.clear() parsed = json.loads(ranking_json) for row in parsed: player = str(row.get("player", "")).strip() score = int(row.get("score", 0)) if len(player) == 0: continue self.ranking.append(player) self.final_scores[player] = u32(self._clamp_int(score, 0, 100)) self.reasons[player] = str(row.get("reason", ""))[:180] self.ai_mode = "FALLBACK_LOCAL" self.judge_status = "DONE" self.last_error = f"MANUAL:{reason[:120]}" @gl.public.view def get_round_state(self) -> str: data = { "room_code": self.room_code, "owner": self.owner, "round_id": int(self.round_id), "round_active": self.round_active, "round_start_ms": int(self.round_start_ms), "round_end_ms": int(self.round_end_ms), "round_seconds": int(self.round_seconds), "mode": self.mode, "topic": self.topic, "prompt": self.prompt, "ai_mode": self.ai_mode, "judge_status": self.judge_status, "participants_count": len(self.participants), "last_error": self.last_error, } return json.dumps(data) @gl.public.view def get_leaderboard(self) -> str: out = [] rank = 1 for p in self.ranking: out.append( { "rank": rank, "player": p, "score": int(self.final_scores.get(p, u32(0))), "quality": int(self.quality_scores.get(p, u32(0))), "reason": self.reasons.get(p, ""), "ai_mode": self.ai_mode, } ) rank += 1 return json.dumps(out) @gl.public.view def get_progress_snapshot(self) -> str: out = [] for p in self.participants: out.append( {"player": p, "progress": int(self.progress.get(p, u32(0))), "finish_ms": int(self.finish_ms.get(p, u64(0)))} ) return json.dumps(out) @gl.public.view def validate_room_code(self, room_code: str) -> bool: return self.room_code == self._normalize_room(room_code) def _normalize_room(self, raw: str) -> str: r = "".join([c for c in raw.upper() if ("A" <= c <= "Z") or ("0" <= c <= "9")]) return r[:6] def _ensure_room(self, room_code: str): if self._normalize_room(room_code) != self.room_code: raise Exception("ROOM_CODE_MISMATCH") def _normalize_mode(self, mode: str) -> str: m = mode.strip().lower() if m in ("funny", "crypto", "custom"): return m return "funny" def _clamp_u32(self, value: u32, lo: u32, hi: u32) -> u32: if value < lo: return lo if value > hi: return hi return value def _clamp_int(self, value: int, lo: int, hi: int) -> int: if value < lo: return lo if value > hi: return hi return value def _safe_get_str(self, obj, key: str) -> str: if isinstance(obj, dict): value = obj.get(key, "") return str(value).strip() return "" def _safe_get_int(self, obj, key: str) -> int: if isinstance(obj, dict): try: return int(obj.get(key, 0)) except Exception: return 0 return 0 def _fallback_quality(self, progress: int, image_len: int) -> int: base = self._clamp_int(int(progress * 0.8), 0, 80) if image_len > 20000: base += 12 elif image_len > 5000: base += 8 else: base += 3 return self._clamp_int(base, 0, 100) def _fallback_prompt(self, mode: str, topic: str, round_id: int) -> str: funny = [ "Draw a penguin trading NFTs with a cat on a skateboard.", "Draw a rocket delivery courier bringing pizza to the Moon.", "Draw a robot cooking spaghetti in zero gravity.", "Draw a dinosaur taking a selfie in a supermarket.", ] crypto = [ "Draw a bull and a bear in a blockchain boxing ring.", "Draw a hardware wallet as a treasure chest.", "Draw a miner surfing through candlestick waves.", "Draw a DAO vote happening in a cyber city square.", ] custom = [ f"Draw a scene inspired by: {topic}", f"Draw a comic frame about: {topic}", f"Draw an action poster based on: {topic}", f"Draw a symbolic illustration of: {topic}", ] pool = funny if mode == "crypto": pool = crypto elif mode == "custom": pool = custom idx = (round_id - 1) % len(pool) idea = pool[idx] return f"[{mode.upper()}] {idea} | Tip: clear silhouette + one strong detail."