thejayman77
90cd0291a3
A calm second daily game, same philosophy as Daily Word — LLM proposes, code
disposes.
* LLM proposes a hopeful theme + ~8 words; code validates (alpha/length/dedup)
and PLACES every word in a date-seeded grid, so the puzzle is always solvable.
Curated fallback themes if the LLM is thin. Only placed words are returned;
the solution cells (placements) are never sent to the client.
* GET /api/puzzle/wordsearch → {theme, words, grid, size}. No answer to hide:
the grid and word list are meant to be seen — the play is finding them, which
the client validates by reading the selected line off the grid.
* WordSearchGame.svelte: pointer-drag selection snapped to the 8 straight
directions (mouse + touch), found-word highlighting, no-fail, no pressure
timer — time is recorded quietly and shown at the end with a personal best.
Spoiler-free share. localStorage progress (restores found cells + timer).
* Hub's Word Search card is now live with today's status; cycle pre-generates
both games with the LLM.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
273 lines
11 KiB
Python
273 lines
11 KiB
Python
"""Daily puzzles for the calm Play hub.
|
||
|
||
Principle: **the LLM proposes, code disposes.** The LLM only contributes
|
||
creative flavor (a one-line "why today's word matters"); the daily answer is
|
||
picked deterministically by code from a pre-validated hopeful pool (every word
|
||
is guaranteed to be in the guess dictionary, so it's always typeable). Puzzles
|
||
are stored per (date, game, variant) so everyone gets the same one and shares
|
||
are comparable. Generation never blocks on or trusts the LLM for correctness.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import hashlib
|
||
import json
|
||
import random
|
||
import re
|
||
import sqlite3
|
||
from pathlib import Path
|
||
|
||
_POOL = json.loads((Path(__file__).parent / "data" / "wordpool.json").read_text())
|
||
|
||
# Daily Word: 5 letters / 6 guesses · Long Word: 6 letters / 7 guesses.
|
||
WORD_VARIANTS = {"5": {"length": 5, "guesses": 6}, "6": {"length": 6, "guesses": 7}}
|
||
|
||
|
||
def _seed(*parts: str) -> int:
|
||
return int(hashlib.sha256(":".join(parts).encode()).hexdigest(), 16)
|
||
|
||
|
||
def _recent_answers(conn: sqlite3.Connection, variant: str, limit: int) -> set[str]:
|
||
rows = conn.execute(
|
||
"SELECT payload_json FROM daily_puzzles WHERE game='word' AND variant=? "
|
||
"ORDER BY puzzle_date DESC LIMIT ?",
|
||
(variant, limit),
|
||
).fetchall()
|
||
out = set()
|
||
for r in rows:
|
||
try:
|
||
out.add(json.loads(r["payload_json"])["answer"])
|
||
except (ValueError, KeyError, TypeError):
|
||
pass
|
||
return out
|
||
|
||
|
||
def _pick_answer(conn: sqlite3.Connection, date: str, variant: str) -> str:
|
||
pool = _POOL.get(variant, [])
|
||
recent = _recent_answers(conn, variant, max(1, len(pool) // 2))
|
||
start = _seed(date, "word", variant) % len(pool)
|
||
for i in range(len(pool)):
|
||
cand = pool[(start + i) % len(pool)]
|
||
if cand not in recent:
|
||
return cand
|
||
return pool[start] # pool fully cycled — allow a repeat rather than fail
|
||
|
||
|
||
def _why(client, word: str) -> str | None:
|
||
if client is None:
|
||
return None
|
||
try:
|
||
msg = [
|
||
{"role": "system", "content": "You write one short, warm, plain sentence (no preamble, no quotes) "
|
||
"on why a given word is a hopeful or uplifting one to sit with."},
|
||
{"role": "user", "content": f"Word: {word}"},
|
||
]
|
||
text = (client.chat_text(msg) or "").strip().strip('"').replace("\n", " ")
|
||
return text[:200] or None
|
||
except Exception: # noqa: BLE001 — flavor only; never block puzzle creation
|
||
return None
|
||
|
||
|
||
def generate_word_puzzle(conn: sqlite3.Connection, date: str, variant: str, client=None) -> dict:
|
||
"""Ensure a Daily/Long Word puzzle exists for (date, variant). Idempotent.
|
||
Code picks the answer; the LLM only adds the optional 'why' (with fallback)."""
|
||
if variant not in WORD_VARIANTS:
|
||
variant = "5"
|
||
existing = conn.execute(
|
||
"SELECT payload_json FROM daily_puzzles WHERE puzzle_date=? AND game='word' AND variant=?",
|
||
(date, variant),
|
||
).fetchone()
|
||
if existing:
|
||
return json.loads(existing["payload_json"])
|
||
answer = _pick_answer(conn, date, variant)
|
||
payload = {
|
||
"answer": answer,
|
||
"why": _why(client, answer),
|
||
"length": WORD_VARIANTS[variant]["length"],
|
||
"guesses": WORD_VARIANTS[variant]["guesses"],
|
||
}
|
||
conn.execute(
|
||
"INSERT OR IGNORE INTO daily_puzzles (puzzle_date, game, variant, payload_json) VALUES (?, 'word', ?, ?)",
|
||
(date, variant, json.dumps(payload)),
|
||
)
|
||
conn.commit()
|
||
row = conn.execute(
|
||
"SELECT payload_json FROM daily_puzzles WHERE puzzle_date=? AND game='word' AND variant=?",
|
||
(date, variant),
|
||
).fetchone()
|
||
return json.loads(row["payload_json"])
|
||
|
||
|
||
def word_puzzle_response(conn: sqlite3.Connection, date: str, variant: str) -> dict:
|
||
"""Public puzzle shape — deliberately holds NO answer. Guesses are adjudicated
|
||
server-side (see adjudicate_word_guess), so the day's word never sits in the
|
||
network response for a curious user to read."""
|
||
p = generate_word_puzzle(conn, date, variant) # create on demand (no LLM) if missing
|
||
return {
|
||
"game": "word",
|
||
"variant": variant,
|
||
"date": date,
|
||
"length": p["length"],
|
||
"guesses": p["guesses"],
|
||
}
|
||
|
||
|
||
def _color(guess: str, answer: str) -> list[str]:
|
||
"""Two-pass Wordle colouring: greens first, then presents limited by counts."""
|
||
res = ["absent"] * len(answer)
|
||
counts: dict[str, int] = {}
|
||
for ch in answer:
|
||
counts[ch] = counts.get(ch, 0) + 1
|
||
for i, ch in enumerate(guess):
|
||
if i < len(answer) and ch == answer[i]:
|
||
res[i] = "correct"; counts[ch] -= 1
|
||
for i, ch in enumerate(guess):
|
||
if res[i] == "correct":
|
||
continue
|
||
if counts.get(ch, 0) > 0:
|
||
res[i] = "present"; counts[ch] -= 1
|
||
return res
|
||
|
||
|
||
def adjudicate_word_guess(conn: sqlite3.Connection, date: str, variant: str, guess: str, n: int) -> dict:
|
||
"""Colour a guess against the day's answer server-side. The answer (and 'why')
|
||
are revealed ONLY once solved or the guesses are spent — never up front."""
|
||
if variant not in WORD_VARIANTS:
|
||
variant = "5"
|
||
p = generate_word_puzzle(conn, date, variant)
|
||
length, maxg, answer = p["length"], p["guesses"], p["answer"]
|
||
guess = (guess or "").strip().lower()
|
||
if len(guess) != length or not guess.isalpha():
|
||
return {"error": "bad guess"}
|
||
solved = guess == answer
|
||
reveal = solved or n >= maxg
|
||
return {
|
||
"colors": _color(guess, answer),
|
||
"solved": solved,
|
||
"answer": answer if reveal else None,
|
||
"why": p.get("why") if reveal else None,
|
||
}
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Word Search — LLM proposes a theme + words, code validates and PLACES them in
|
||
# the grid (so it's always solvable). No answer to hide: the grid and word list
|
||
# are inherently visible; the play is finding them.
|
||
# ---------------------------------------------------------------------------
|
||
|
||
WORDSEARCH_SIZE = 10
|
||
WORDSEARCH_COUNT = 8
|
||
_DIRS = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
|
||
|
||
# Curated fallbacks (all uppercase alpha, 4–8 letters) used if the LLM is thin.
|
||
_WS_FALLBACKS = [
|
||
("Kindness", ["KIND", "CARE", "GIVE", "SHARE", "GENTLE", "WARMTH", "THANKS", "FRIEND"]),
|
||
("In the garden", ["BLOOM", "PETAL", "ROOTS", "LEAF", "GARDEN", "FLOWER", "SUNNY", "SEEDS"]),
|
||
("Quiet calm", ["PEACE", "QUIET", "STILL", "SERENE", "REST", "SOOTHE", "GENTLE", "BREATHE"]),
|
||
("Bright skies", ["SUNNY", "CLOUD", "BREEZE", "LIGHT", "SHINE", "RAINBOW", "WARMTH", "DAWN"]),
|
||
("Small joys", ["SMILE", "LAUGH", "CHEER", "HAPPY", "MERRY", "DANCE", "DELIGHT", "GLOW"]),
|
||
]
|
||
|
||
|
||
def _ws_propose(client) -> tuple[str, list[str]] | None:
|
||
"""LLM proposes a theme + words; code disposes (alpha / length / dedup)."""
|
||
if client is None:
|
||
return None
|
||
try:
|
||
msg = [
|
||
{"role": "system", "content": "You set up a calm, hopeful word search. Reply exactly as two lines:\n"
|
||
"THEME: <2-4 word theme>\nWORDS: W1, W2, W3, W4, W5, W6, W7, W8\n"
|
||
"Each word a single real word, 4-8 letters, UPPERCASE, related to the theme, no phrases."},
|
||
{"role": "user", "content": "Give me one gentle, uplifting theme."},
|
||
]
|
||
text = client.chat_text(msg) or ""
|
||
theme, words = None, []
|
||
for line in text.splitlines():
|
||
s = line.strip()
|
||
if s.upper().startswith("THEME:"):
|
||
theme = s.split(":", 1)[1].strip()[:40]
|
||
elif s.upper().startswith("WORDS:"):
|
||
words = [w.strip().upper() for w in re.split(r"[,\s]+", s.split(":", 1)[1]) if w.strip()]
|
||
words = [w for w in dict.fromkeys(words) if w.isalpha() and 4 <= len(w) <= 8]
|
||
if theme and len(words) >= 6:
|
||
return theme, words[:WORDSEARCH_COUNT]
|
||
except Exception: # noqa: BLE001 — fall back to a curated theme
|
||
pass
|
||
return None
|
||
|
||
|
||
def generate_wordsearch_puzzle(conn: sqlite3.Connection, date: str, client=None) -> dict:
|
||
"""Ensure today's word search exists. Idempotent. Code places every word, so
|
||
the puzzle is guaranteed solvable; only placed words are returned."""
|
||
existing = conn.execute(
|
||
"SELECT payload_json FROM daily_puzzles WHERE puzzle_date=? AND game='wordsearch' AND variant=''", (date,)
|
||
).fetchone()
|
||
if existing:
|
||
return json.loads(existing["payload_json"])
|
||
rng = random.Random(_seed(date, "wordsearch"))
|
||
proposed = _ws_propose(client)
|
||
theme, words = proposed if proposed else _WS_FALLBACKS[rng.randrange(len(_WS_FALLBACKS))]
|
||
words = [w.upper() for w in words]
|
||
|
||
size = WORDSEARCH_SIZE
|
||
grid: list[list[str | None]] = [[None] * size for _ in range(size)]
|
||
placed = []
|
||
for word in sorted(words, key=len, reverse=True):
|
||
for _ in range(400):
|
||
dr, dc = rng.choice(_DIRS)
|
||
r0, c0 = rng.randrange(size), rng.randrange(size)
|
||
cells = [(r0 + dr * i, c0 + dc * i) for i in range(len(word))]
|
||
if any(not (0 <= r < size and 0 <= c < size) for r, c in cells):
|
||
continue
|
||
if all(grid[r][c] in (None, word[i]) for i, (r, c) in enumerate(cells)):
|
||
for i, (r, c) in enumerate(cells):
|
||
grid[r][c] = word[i]
|
||
placed.append({"word": word, "cells": cells})
|
||
break
|
||
for r in range(size):
|
||
for c in range(size):
|
||
if grid[r][c] is None:
|
||
grid[r][c] = chr(65 + rng.randrange(26))
|
||
payload = {
|
||
"theme": theme,
|
||
"words": sorted((p["word"] for p in placed), key=len, reverse=True),
|
||
"grid": ["".join(row) for row in grid],
|
||
"size": size,
|
||
"placements": placed, # stored, not sent to the client
|
||
}
|
||
conn.execute(
|
||
"INSERT OR IGNORE INTO daily_puzzles (puzzle_date, game, variant, payload_json) VALUES (?, 'wordsearch', '', ?)",
|
||
(date, json.dumps(payload)),
|
||
)
|
||
conn.commit()
|
||
row = conn.execute(
|
||
"SELECT payload_json FROM daily_puzzles WHERE puzzle_date=? AND game='wordsearch' AND variant=''", (date,)
|
||
).fetchone()
|
||
return json.loads(row["payload_json"])
|
||
|
||
|
||
def wordsearch_response(conn: sqlite3.Connection, date: str) -> dict:
|
||
"""Public shape: theme + word list + grid. The grid is meant to be seen — the
|
||
play is finding the words — so there's nothing to hide here (no placements)."""
|
||
p = generate_wordsearch_puzzle(conn, date) # on-demand (curated fallback) if missing
|
||
return {"game": "wordsearch", "date": date, "theme": p["theme"],
|
||
"words": p["words"], "grid": p["grid"], "size": p["size"]}
|
||
|
||
|
||
def generate_daily_puzzles(conn: sqlite3.Connection, date: str, client=None) -> int:
|
||
"""Cycle hook: pre-generate today's puzzles (word + word search) with the LLM."""
|
||
made = 0
|
||
for variant in WORD_VARIANTS:
|
||
before = conn.execute(
|
||
"SELECT 1 FROM daily_puzzles WHERE puzzle_date=? AND game='word' AND variant=?", (date, variant)
|
||
).fetchone()
|
||
if not before:
|
||
generate_word_puzzle(conn, date, variant, client=client)
|
||
made += 1
|
||
if not conn.execute(
|
||
"SELECT 1 FROM daily_puzzles WHERE puzzle_date=? AND game='wordsearch' AND variant=''", (date,)
|
||
).fetchone():
|
||
generate_wordsearch_puzzle(conn, date, client=client)
|
||
made += 1
|
||
return made
|