From 80956ce0f408a4cd6051c581a8fcf685820a11f3 Mon Sep 17 00:00:00 2001 From: blindxfish Date: Thu, 20 Aug 2026 23:30:02 +0200 Subject: [PATCH] Add Opinion Wars: week-long two-faction battles attached to posts A new post attachment type beside polls: the composer gains a Start Opinion War builder (same disabled-inputs opt-in as the poll builder) that names exactly two factions; the battle runs for exactly 7 days from post creation. Members join a side, may defect at any time (damage already dealt stays with the faction it was dealt to), and fight once per 24 hours per battle. A fight spends 25 Code Farm coins and deals deterministic level-weighted damage: 100 + 10 * min(level, 20) HP, so a newcomer deals 110 and a veteran caps at 300 - no randomness anywhere. The battle renders on the post card as a CSS pixel-art battlefield (box-shadow sprites: castles, faction flags, marching soldiers, a flickering campfire; steps() animation, disabled under reduced motion) with live HP bars, a countdown, the viewer's faction strip, top contributors and an event ticker. Live frames ride pub/sub on public.battle.{uid} via a relay on the service-lock owner, with the durable opinion_war_events trail (per-war atomic seq) as the source of truth and a 15s incremental poller as fallback. /battles lists battles with active/ended/mine filters, search and pagination. Every mutation is a conditional UPDATE via conditional_update_row: the fight sequence claims the cooldown first, then spends coins, then lands the damage, compensating earlier steps on any later refusal so a crash costs a turn, never coins. Resolution is lazy on read (no cron): an exactly-once CAS computes the winner in the statement, awards XP (participation, winner bonus, top damage dealer bonus; draws pay participation only), emits the result event and notifies fighters. The OpinionWarService backstop resolves unviewed wars and sends fight-ready notifications, exactly-once via a marker CAS. Fan-out: battle notification type, four badges, audit keys (battle.create/join/switch/fight/resolve), Devii actions (join/fight confirm-gated), API docs group, docs prose page, sitemap and topnav entries, REPORTABLE_TARGETS registration, post-delete cascades, README and nested CLAUDE.md documentation. Verified with the four-layer procedure: property checks over the full damage domain, 1200-step stateful fuzz (hp-sum invariant, coins never negative, resolved totals frozen), and real 8-process races proving exactly-once semantics for concurrent fights, double-spends across two wars, resolution XP and double-joins. Persisted tests in tests/unit/services/opinionwar, tests/api/battles, tests/e2e/battles and tests/api/posts/create.py. Co-Authored-By: Claude Fable 5 --- CLAUDE.md | 2 + README.md | 20 + devplacepy/config.py | 2 + devplacepy/content.py | 5 + devplacepy/database/content.py | 5 + devplacepy/database/moderation.py | 3 + devplacepy/database/notifications.py | 1 + devplacepy/database/ranking.py | 18 + devplacepy/database/schema.py | 92 ++ devplacepy/database/soft_delete.py | 3 + devplacepy/docs_api/groups/__init__.py | 2 + devplacepy/docs_api/groups/battles.py | 149 ++++ devplacepy/docs_api/groups/content.py | 16 + devplacepy/main.py | 4 + devplacepy/models.py | 13 + devplacepy/routers/CLAUDE.md | 1 + devplacepy/routers/battles.py | 129 +++ devplacepy/routers/docs/pages.py | 6 + devplacepy/routers/feed.py | 5 + devplacepy/routers/posts.py | 2 + devplacepy/routers/profile/index.py | 5 + devplacepy/routers/projects/index.py | 5 + devplacepy/schemas/__init__.py | 9 + devplacepy/schemas/battles.py | 82 ++ devplacepy/schemas/listings.py | 3 + devplacepy/seo.py | 1 + devplacepy/services/audit/CLAUDE.md | 2 +- devplacepy/services/audit/categories.py | 1 + .../devii/actions/catalog/__init__.py | 2 + .../services/devii/actions/catalog/battles.py | 85 ++ .../services/devii/actions/catalog/posts.py | 8 + .../services/devii/actions/dispatcher.py | 2 + devplacepy/services/opinionwar/CLAUDE.md | 134 +++ devplacepy/services/opinionwar/__init__.py | 6 + devplacepy/services/opinionwar/rules.py | 111 +++ devplacepy/services/opinionwar/service.py | 90 ++ devplacepy/services/opinionwar/store.py | 794 ++++++++++++++++++ devplacepy/static/css/opinionwar.css | 714 ++++++++++++++++ devplacepy/static/js/Application.js | 2 + devplacepy/static/js/WarComposer.js | 106 +++ .../static/js/components/AppOpinionWar.js | 254 ++++++ devplacepy/static/js/components/index.js | 1 + devplacepy/templates/_opinion_war.html | 95 +++ devplacepy/templates/_opinion_war_field.html | 14 + devplacepy/templates/_post_card.html | 4 + devplacepy/templates/_post_composer_form.html | 13 + devplacepy/templates/base.html | 3 + devplacepy/templates/battles.html | 53 ++ devplacepy/templates/docs/opinion-wars.html | 51 ++ devplacepy/templates/post.html | 4 + devplacepy/utils/CLAUDE.md | 1 + devplacepy/utils/__init__.py | 3 + devplacepy/utils/badges.py | 4 + devplacepy/utils/rewards.py | 6 + events.md | 5 + tests/api/battles/__init__.py | 0 tests/api/battles/_helpers.py | 78 ++ tests/api/battles/actions.py | 165 ++++ tests/api/battles/events.py | 43 + tests/api/battles/index.py | 73 ++ tests/api/battles/resolve.py | 94 +++ tests/api/posts/create.py | 106 +++ tests/e2e/battles/__init__.py | 0 tests/e2e/battles/index.py | 157 ++++ tests/unit/services/opinionwar/__init__.py | 0 tests/unit/services/opinionwar/rules.py | 94 +++ 66 files changed, 3960 insertions(+), 1 deletion(-) create mode 100644 devplacepy/docs_api/groups/battles.py create mode 100644 devplacepy/routers/battles.py create mode 100644 devplacepy/schemas/battles.py create mode 100644 devplacepy/services/devii/actions/catalog/battles.py create mode 100644 devplacepy/services/opinionwar/CLAUDE.md create mode 100644 devplacepy/services/opinionwar/__init__.py create mode 100644 devplacepy/services/opinionwar/rules.py create mode 100644 devplacepy/services/opinionwar/service.py create mode 100644 devplacepy/services/opinionwar/store.py create mode 100644 devplacepy/static/css/opinionwar.css create mode 100644 devplacepy/static/js/WarComposer.js create mode 100644 devplacepy/static/js/components/AppOpinionWar.js create mode 100644 devplacepy/templates/_opinion_war.html create mode 100644 devplacepy/templates/_opinion_war_field.html create mode 100644 devplacepy/templates/battles.html create mode 100644 devplacepy/templates/docs/opinion-wars.html create mode 100644 tests/api/battles/__init__.py create mode 100644 tests/api/battles/_helpers.py create mode 100644 tests/api/battles/actions.py create mode 100644 tests/api/battles/events.py create mode 100644 tests/api/battles/index.py create mode 100644 tests/api/battles/resolve.py create mode 100644 tests/e2e/battles/__init__.py create mode 100644 tests/e2e/battles/index.py create mode 100644 tests/unit/services/opinionwar/__init__.py create mode 100644 tests/unit/services/opinionwar/rules.py diff --git a/CLAUDE.md b/CLAUDE.md index 608f7642..203a7e6d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -155,6 +155,7 @@ Nested `CLAUDE.md` files (loaded automatically by Claude Code only when a file i | `devplacepy/services/pubsub/CLAUDE.md` | Database-free pub/sub bus | | `devplacepy/push/CLAUDE.md` | Push notification providers: the `PushProvider` protocol, the registry, Web Push and APNs, registration storage | | `devplacepy/services/game/CLAUDE.md` | Code Farm idle game (economy invariants, raids, the one-pure-function rule) | +| `devplacepy/services/opinionwar/CLAUDE.md` | Opinion Wars (week-long faction battles on posts: atomic fight/resolve transitions, cooldown-before-coins compensation, event seq allocation, relay-on-lock-owner) | | `devplacepy/services/quiz/CLAUDE.md` | Quizzes (the terminal publish lock, attempt atomicity, answer-key withholding, AI free-text grading, the best-attempt scoreboard) | | `devplacepy/services/CLAUDE.md` | Background task queue, AI correction/modifier, presence, live view relay, `BaseService`/`ServiceManager` | | `devplacepy/database/CLAUDE.md` | Dataset rules, indexing conventions, soft delete, tables, site settings | @@ -201,6 +202,7 @@ Routers in `devplacepy/routers/` are organised as a **directory tree that mirror | `/game` | game/ package - see `services/game/CLAUDE.md` | | `/reports`, `/admin/moderation`, `/workspaces` | reports.py, admin/moderation.py, workspaces.py - see `services/moderation/CLAUDE.md` | | `/quizzes` | quizzes/ package - see `services/quiz/CLAUDE.md` | +| `/battles` | battles.py - see `services/opinionwar/CLAUDE.md` | | (none) | push.py (web push/PWA), docs.py (see `routers/docs/CLAUDE.md`) | | `/pubsub` | pubsub.py - see `services/pubsub/CLAUDE.md` | | (none) | seo.py - `/robots.txt`, `/sitemap.xml` | diff --git a/README.md b/README.md index c555d9e6..9c59830d 100644 --- a/README.md +++ b/README.md @@ -97,6 +97,7 @@ devplacepy/ | `/leaderboard` | Contributor ranking by total stars earned | | `/game` | **Code Farm** cooperative idle game (member-only): plant projects that build over real time, harvest coins and XP, upgrade CI, buy plots, and water friends' builds at `/game/farm/{username}`. Live over pub/sub; every endpoint negotiates JSON | | `/quizzes` | **Quizzes**: author quizzes, play them, and climb the cross-quiz scoreboard. Three-column hub with filters (`all`/`todo`/`done`/`mine`/`drafts`), search, per-viewer state badges, and the scoreboard rail; `/quizzes/{slug}` detail, `/quizzes/{slug}/edit` builder, `/quizzes/{slug}/attempts/{uid}` player, `/quizzes/scoreboard` JSON. Publishing is permanent. Every endpoint negotiates JSON | +| `/battles` | **Opinion Wars**: week-long two-faction battles attached to posts, started from the composer's *Start Opinion War* builder. Members join a side and fight once a day (25 Code Farm coins, level-weighted damage); the pixel-art battle card shows live HP bars, a countdown, top contributors and an event ticker. `/battles` lists battles (`active`/`ended`/`mine` + search); `/battles/{uid}` state, `/battles/{uid}/events` replay, `/battles/{uid}/join` and `/battles/{uid}/fight` actions | | `/avatar` | Multiavatar proxy with in-memory cache | | `/issues` | Issue tracker backed by Gitea: list/detail/comment/status, AI-enhanced filing, an admin planning report over a selectable set of open tickets (each ticket's full text reproduced verbatim so the document hands straight to a coding agent), and file attachments on open issues and comments (mirrored to the Gitea tracker) | | `/admin/services` | Background service management (start/stop, config, status, logs) | @@ -169,6 +170,25 @@ scoreboard on the right. Guests read published quizzes and see the board; they c Retention: completed attempts are permanent; abandoned and expired ones are garbage-collected by `devplace quiz prune`. +## Opinion Wars + +**Opinion Wars** (`/battles`) are week-long two-faction battles attached to posts, in the spirit of +old eRepublik battles: settle tabs-versus-spaces by showing up daily and fighting for your side. + +- **Start one from the composer.** The *Start Opinion War* button next to *Add poll* names the two + factions; the battle runs for exactly 7 days from the moment the post is published. +- **Join and fight.** Any signed-in member picks a side and may fight once every 24 hours per + battle. A fight costs 25 Code Farm coins and deals deterministic, level-weighted damage + (100 HP + 10 per site level, capped at level 20) - no randomness, dedication wins wars. +- **Defection is allowed.** Switch factions any time; damage already dealt stays where it landed. +- **Live pixel-art card.** The battle renders on the post as a CSS pixel-art battlefield with HP + bars, a countdown, your rank, top contributors and a live event ticker (joins, defections, + fights, lead changes) over pub/sub with an incremental replay fallback. +- **Rewards.** When the week ends the bigger total wins: every fighter earns XP, the winning side + and the top damage dealer earn bonuses, and battle badges (*Instigator*, *First Blood*, + *War Veteran*, *Champion*) mark the milestones. Notifications cover lead changes, the result and + your next fight being ready. + ## Code Farm The **Code Farm** (`/game`) is a cooperative idle game in the spirit of Farmville, themed for developers. Each member owns a farm of plots and plays asynchronously - nothing has to happen in real time. diff --git a/devplacepy/config.py b/devplacepy/config.py index 8f93c00a..e335fe46 100644 --- a/devplacepy/config.py +++ b/devplacepy/config.py @@ -97,6 +97,8 @@ QUIZ_SCOREBOARD_LIMIT = 20 QUIZ_SCOREBOARD_CACHE_SECONDS = 15 QUIZ_LIST_PER_PAGE = 20 +BATTLES_LIST_PER_PAGE = 10 + DEFAULT_CORRECTION_PROMPT = "Leave literary as is, only do punctuation and casing" DEFAULT_MODIFIER_PROMPT = ( "Execute what is behind `@ai` (the prompt) and replace that part including `@ai`" diff --git a/devplacepy/content.py b/devplacepy/content.py index 597f9e65..81edad85 100644 --- a/devplacepy/content.py +++ b/devplacepy/content.py @@ -53,6 +53,7 @@ from devplacepy.utils import ( XP_UPVOTE, ) from devplacepy.services.audit import record as audit +from devplacepy.services.opinionwar import store as war_store from devplacepy.services.correction import schedule_correction from devplacepy.services.ai_modifier import schedule_modification from devplacepy.services.seo_meta import schedule_seo_meta_for_table @@ -627,6 +628,7 @@ def detail_context( "reactions": detail.get("reactions", {"counts": {}, "mine": []}), "bookmarked": detail.get("bookmarked", False), "poll": detail.get("poll"), + "war": detail.get("war"), "project_link": detail.get("project_link"), "maturity": detail.get("maturity", "general"), } @@ -817,6 +819,9 @@ def load_detail( "reactions": reactions, "bookmarked": bookmarked, "poll": get_poll_for_post(item["uid"], user) if target_type == "post" else None, + "war": war_store.get_war_serialized_for_post(item["uid"], user) + if target_type == "post" + else None, "project_link": get_project_by_uid(item.get("project_uid")) if target_type == "post" else None, "maturity": get_maturity(target_type, item["uid"])["level"], } diff --git a/devplacepy/database/content.py b/devplacepy/database/content.py index 50bfea27..63b7160f 100644 --- a/devplacepy/database/content.py +++ b/devplacepy/database/content.py @@ -89,6 +89,11 @@ def resolve_object_url(target_type: str, target_uid: str) -> str: if not poll: return "/feed" return resolve_object_url("post", poll.get("post_uid", "")) + if target_type == "battle": + war = get_table("opinion_wars").find_one(uid=target_uid) + if not war: + return "/battles" + return resolve_object_url("post", war.get("post_uid", "")) if target_type == "workspace": instance = get_table("instances").find_one(uid=target_uid) return f"/admin/containers/{instance['uid']}" if instance else "/admin/containers" diff --git a/devplacepy/database/moderation.py b/devplacepy/database/moderation.py index 7ee64859..7a9dcdc5 100644 --- a/devplacepy/database/moderation.py +++ b/devplacepy/database/moderation.py @@ -17,6 +17,7 @@ REPORTABLE_TARGETS: dict[str, str] = { "message": "messages", "quiz": "quizzes", "poll": "polls", + "battle": "opinion_wars", "award": "awards", "user": "users", "issue": "issue_tickets", @@ -48,6 +49,8 @@ UNREPORTABLE_TABLES: dict[str, str] = { "bookmarks": "private to the owner", "follows": "relationship rows, carry no authored content", "poll_votes": "private ballots", + "opinion_war_fighters": "membership and damage counters, carry no authored content", + "opinion_war_events": "server-composed battle log rows, not authored content", "quiz_attempts": "private to the participant", "quiz_answers": "private to the participant", "sessions": "authentication state", diff --git a/devplacepy/database/notifications.py b/devplacepy/database/notifications.py index 11422486..3496005f 100644 --- a/devplacepy/database/notifications.py +++ b/devplacepy/database/notifications.py @@ -19,6 +19,7 @@ NOTIFICATION_TYPES = [ {"key": "harvest_stolen", "label": "Farm raids", "description": "Someone steals a ready build from your Code Farm"}, {"key": "award", "label": "Awards", "description": "Someone gives you an award on your profile"}, {"key": "quiz_attempt", "label": "Quiz attempts", "description": "Someone completes one of your quizzes"}, + {"key": "battle", "label": "Opinion Wars", "description": "Lead changes, results and fight-ready alerts for battles you joined"}, {"key": "workspace", "label": "Dev workspaces", "description": "Idle, quota, retention and moderation notices for your dev workspaces"}, {"key": "moderation", "label": "Moderation", "description": "Acknowledgements for reports you file and decisions taken on your content"}, {"key": "system", "label": "System alerts", "description": "Platform infrastructure alerts (e.g. the AI gateway going down)"}, diff --git a/devplacepy/database/ranking.py b/devplacepy/database/ranking.py index 3c4a4ef0..dc22acb8 100644 --- a/devplacepy/database/ranking.py +++ b/devplacepy/database/ranking.py @@ -150,6 +150,16 @@ def soft_delete_engagement(target_type: str, target_uids: list, deleted_by: str) soft_delete("poll_votes", deleted_by, stamp=stamp, poll_uid=poll["uid"]) soft_delete("poll_options", deleted_by, stamp=stamp, poll_uid=poll["uid"]) soft_delete("polls", deleted_by, stamp=stamp, post_uid=uid) + if target_type == "post" and "opinion_wars" in db.tables: + for uid in uids: + for war in db["opinion_wars"].find(post_uid=uid, deleted_at=None): + soft_delete( + "opinion_war_fighters", deleted_by, stamp=stamp, war_uid=war["uid"] + ) + soft_delete( + "opinion_war_events", deleted_by, stamp=stamp, war_uid=war["uid"] + ) + soft_delete("opinion_wars", deleted_by, stamp=stamp, post_uid=uid) def delete_engagement(target_type: str, target_uids: list) -> None: @@ -181,6 +191,14 @@ def delete_engagement(target_type: str, target_uids: list) -> None: if "poll_options" in tables: db["poll_options"].delete(poll_uid=poll["uid"]) db["polls"].delete(post_uid=uid) + if target_type == "post" and "opinion_wars" in tables: + for uid in uids: + for war in db["opinion_wars"].find(post_uid=uid): + if "opinion_war_fighters" in tables: + db["opinion_war_fighters"].delete(war_uid=war["uid"]) + if "opinion_war_events" in tables: + db["opinion_war_events"].delete(war_uid=war["uid"]) + db["opinion_wars"].delete(post_uid=uid) def get_target_owner_uid(target_type: str, target_uid: str) -> str | None: diff --git a/devplacepy/database/schema.py b/devplacepy/database/schema.py index e34746da..180d408f 100644 --- a/devplacepy/database/schema.py +++ b/devplacepy/database/schema.py @@ -1580,6 +1580,98 @@ def init_db(): ) _index(db, "quiz_answers", "idx_quiz_answers_quiz", ["quiz_uid"]) + opinion_wars = get_table("opinion_wars") + for column, example in ( + ("uid", ""), + ("post_uid", ""), + ("user_uid", ""), + ("faction_a", ""), + ("faction_b", ""), + ("hp_a", 0), + ("hp_b", 0), + ("leader", ""), + ("status", "active"), + ("winner", ""), + ("created_at", ""), + ("ends_at", ""), + ("resolved_at", ""), + ("updated_at", ""), + ("deleted_at", ""), + ("deleted_by", ""), + ): + if not opinion_wars.has_column(column): + opinion_wars.create_column_by_example(column, example) + _index(db, "opinion_wars", "idx_opinion_wars_post", ["post_uid"], unique=True) + _index(db, "opinion_wars", "idx_opinion_wars_status_ends", ["status", "ends_at"]) + _index( + db, + "opinion_wars", + "idx_opinion_wars_live_created", + ["created_at"], + where="deleted_at IS NULL", + ) + + opinion_war_fighters = get_table("opinion_war_fighters") + for column, example in ( + ("uid", ""), + ("war_uid", ""), + ("user_uid", ""), + ("faction", ""), + ("hp_a", 0), + ("hp_b", 0), + ("fight_count", 0), + ("last_fight_at", ""), + ("cooldown_notified_at", ""), + ("created_at", ""), + ("updated_at", ""), + ("deleted_at", ""), + ("deleted_by", ""), + ): + if not opinion_war_fighters.has_column(column): + opinion_war_fighters.create_column_by_example(column, example) + _index( + db, + "opinion_war_fighters", + "idx_opinion_war_fighters_war_user", + ["war_uid", "user_uid"], + unique=True, + ) + _index( + db, + "opinion_war_fighters", + "idx_opinion_war_fighters_war_faction", + ["war_uid", "faction"], + ) + _index( + db, + "opinion_war_fighters", + "idx_opinion_war_fighters_last_fight", + ["last_fight_at"], + ) + + opinion_war_events = get_table("opinion_war_events") + for column, example in ( + ("uid", ""), + ("war_uid", ""), + ("seq", 0), + ("kind", ""), + ("message", ""), + ("payload", ""), + ("actor_uid", ""), + ("created_at", ""), + ("deleted_at", ""), + ("deleted_by", ""), + ): + if not opinion_war_events.has_column(column): + opinion_war_events.create_column_by_example(column, example) + _index( + db, + "opinion_war_events", + "idx_opinion_war_events_war_seq", + ["war_uid", "seq"], + unique=True, + ) + _index(db, "posts", "idx_posts_user_created", ["user_uid", "created_at"]) _index( db, diff --git a/devplacepy/database/soft_delete.py b/devplacepy/database/soft_delete.py index 6c132cd3..b345c08a 100644 --- a/devplacepy/database/soft_delete.py +++ b/devplacepy/database/soft_delete.py @@ -51,6 +51,9 @@ SOFT_DELETE_TABLES = [ "quiz_options", "quiz_attempts", "quiz_answers", + "opinion_wars", + "opinion_war_fighters", + "opinion_war_events", "content_reports", "moderation_actions", "content_maturity", diff --git a/devplacepy/docs_api/groups/__init__.py b/devplacepy/docs_api/groups/__init__.py index 5c903a85..17543982 100644 --- a/devplacepy/docs_api/groups/__init__.py +++ b/devplacepy/docs_api/groups/__init__.py @@ -22,6 +22,7 @@ from . import ( admin, game, quizzes, + battles, ) ORDERED_GROUPS = [ @@ -46,4 +47,5 @@ ORDERED_GROUPS = [ admin.GROUP, game.GROUP, quizzes.GROUP, + battles.GROUP, ] diff --git a/devplacepy/docs_api/groups/battles.py b/devplacepy/docs_api/groups/battles.py new file mode 100644 index 00000000..bd50f575 --- /dev/null +++ b/devplacepy/docs_api/groups/battles.py @@ -0,0 +1,149 @@ +# retoor + +from devplacepy.services.opinionwar import rules + +from .._shared import endpoint, field + +FILTER_KEYS = ["active", "ended", "mine"] + +SAMPLE_WAR = { + "uid": "0198f2c0-2222-7aaa-8bbb-000000000002", + "post_uid": "0198f2c0-3333-7aaa-8bbb-000000000003", + "post_url": "/posts/8bbb000000000003-tabs-or-spaces", + "post_title": "Tabs or spaces?", + "faction_a": "Tabs", + "faction_b": "Spaces", + "hp_a": 12548, + "hp_b": 7362, + "pct_a": 63, + "pct_b": 37, + "leader": "a", + "fighter_count": 42, + "status": "active", + "winner": "", + "ends_at": "2026-08-27T12:00:00+00:00", + "ends_in": "2d 14h 32m", + "last_seq": 87, + "fight_cost": rules.FIGHT_COST_COINS, + "top_contributors": [ + {"username": "code_warrior", "faction": "a", "hp": 982}, + ], + "recent_events": [ + {"seq": 87, "kind": "fight", "message": "code_warrior dealt 300 HP for Tabs", "faction": "a"}, + ], + "viewer": { + "faction": "a", + "hp": 256, + "rank": 7, + "can_fight": True, + "next_fight_at": "", + }, +} + +GROUP = { + "slug": "battles", + "title": "Opinion Wars", + "intro": f""" +# Opinion Wars + +An Opinion War is a week-long two-faction battle attached to a post. The creator names +exactly two factions when creating the post (the `war_faction_a` / `war_faction_b` fields +on `POST /posts/create`); from that moment the battle runs for exactly +{rules.WAR_DURATION_DAYS} days. + +Any signed-in member joins one of the two factions and may **fight** once every +{rules.FIGHT_COOLDOWN_HOURS} hours per battle. A fight costs {rules.FIGHT_COST_COINS} +Code Farm coins and deals deterministic, level-weighted damage for the fighter's faction: +`{rules.BASE_DAMAGE} + {rules.LEVEL_DAMAGE_STEP} * min(level, {rules.LEVEL_DAMAGE_CAP})` +HP, so a level 1 member deals {rules.damage_for(1)} HP and the bonus caps at +{rules.damage_for(rules.LEVEL_DAMAGE_CAP)} HP. There is no randomness. Switching factions +is allowed at any time; damage already dealt stays with the faction it was dealt to. + +When the week is over the faction with more HP wins. Resolution is evaluated lazily on +read (no background clock): the first read after the deadline freezes the totals, awards +XP (participation for every fighter with at least one fight, a bonus for the winning +side, a bonus for the single top damage dealer) and notifies every fighter. Equal totals +are a draw with participation XP only. + +Every battle keeps an ordered event log (kinds `join`, `switch`, `fight`, `lead_change`, +`result`) replayable with the `after` cursor; live frames are also published on the +pub/sub topic `public.battle.{{uid}}`. + +All endpoints negotiate HTML or JSON. POST bodies are form encoded. Action POSTs answer +`{{"ok": true, "redirect": "...", "data": {{...}}}}`; a refused action (cooldown, missing +coins, ended battle) answers `400` as `{{"error": {{"status": 400, "message": "..."}}}}`. +""", + "endpoints": [ + endpoint( + id="battles-list", + method="GET", + path="/battles", + title="Battle listing", + summary="Opinion Wars with HP totals, filter counts and the viewer's faction state.", + auth="public", + negotiation=True, + params=[ + field("search", "query", "string", False, "tabs", "Match a faction name or the creator's username."), + field("filter", "query", "enum", False, "active", "Which battles to list.", options=FILTER_KEYS), + field("page", "query", "integer", False, "1", "1-based page number."), + ], + sample_response={"battles": [SAMPLE_WAR], "counts": {"active": 3, "ended": 12, "mine": 1}}, + ), + endpoint( + id="battles-get", + method="GET", + path="/battles/{uid}", + title="Battle state", + summary="One battle's full serialized state, resolving it first when its week is over.", + auth="public", + params=[ + field("uid", "path", "string", True, SAMPLE_WAR["uid"], "Battle uid."), + ], + sample_response=SAMPLE_WAR, + ), + endpoint( + id="battles-events", + method="GET", + path="/battles/{uid}/events", + title="Battle events", + summary="The ordered battle event log, replayable incrementally with the after cursor.", + auth="public", + params=[ + field("uid", "path", "string", True, SAMPLE_WAR["uid"], "Battle uid."), + field("after", "query", "integer", False, "0", "Return only events with a seq greater than this."), + field("limit", "query", "integer", False, "500", "Maximum events to return."), + ], + sample_response={"events": SAMPLE_WAR["recent_events"], "status": "active"}, + ), + endpoint( + id="battles-join", + method="POST", + path="/battles/{uid}/join", + title="Join or switch faction", + summary="Join faction a or b, or switch an existing fighter to the other side.", + auth="user", + encoding="form", + params=[ + field("uid", "path", "string", True, SAMPLE_WAR["uid"], "Battle uid."), + field("faction", "body", "enum", True, "a", "Which side to join or switch to.", options=["a", "b"]), + ], + sample_response={"ok": True, "redirect": SAMPLE_WAR["post_url"], "data": {"war": SAMPLE_WAR}}, + ), + endpoint( + id="battles-fight", + method="POST", + path="/battles/{uid}/fight", + title="Fight", + summary=( + f"Spend {rules.FIGHT_COST_COINS} Code Farm coins and deal level-weighted HP damage " + f"for your faction. Once per {rules.FIGHT_COOLDOWN_HOURS} hours per battle." + ), + auth="user", + encoding="form", + params=[ + field("uid", "path", "string", True, SAMPLE_WAR["uid"], "Battle uid."), + ], + sample_response={"ok": True, "redirect": SAMPLE_WAR["post_url"], "data": {"war": SAMPLE_WAR, "damage": 300}}, + ), + ], +} diff --git a/devplacepy/docs_api/groups/content.py b/devplacepy/docs_api/groups/content.py index 61cc1680..80cb84c8 100644 --- a/devplacepy/docs_api/groups/content.py +++ b/devplacepy/docs_api/groups/content.py @@ -117,6 +117,22 @@ four ways to sign requests. "", "Repeat the field for each poll option, or send a single newline- or comma-separated string (2-6 options).", ), + field( + "war_faction_a", + "form", + "string", + False, + "", + "Optional Opinion War faction A name (max 30 chars). Both faction names start the week-long battle.", + ), + field( + "war_faction_b", + "form", + "string", + False, + "", + "Optional Opinion War faction B name (max 30 chars). Must differ from faction A.", + ), ], notes=["Returns a `302` redirect to `/posts/{slug}` on success."], ), diff --git a/devplacepy/main.py b/devplacepy/main.py index a3a5a104..56c82c67 100644 --- a/devplacepy/main.py +++ b/devplacepy/main.py @@ -49,6 +49,7 @@ from devplacepy.utils import get_current_user, time_ago, safe_next, client_ip from devplacepy.seo import base_seo_context, site_url, website_schema from devplacepy.routers import ( auth, + battles, feed, posts, comments, @@ -106,6 +107,7 @@ from devplacepy.services.backup import BackupService from devplacepy.services.dbapi.service import DbApiJobService from devplacepy.services.pubsub import PubSubService from devplacepy.services.notification_relay import NotificationRelayService +from devplacepy.services.opinionwar.service import OpinionWarService from devplacepy.services.live_view_relay import LiveViewRelayService from devplacepy.services.presence_relay import PresenceRelayService from devplacepy.services import presence @@ -272,6 +274,7 @@ async def lifespan(app: FastAPI): service_manager.register(DbApiJobService()) service_manager.register(PubSubService()) service_manager.register(NotificationRelayService()) + service_manager.register(OpinionWarService()) service_manager.register(LiveViewRelayService()) service_manager.register(PresenceRelayService()) service_manager.register(DeepsearchService()) @@ -504,6 +507,7 @@ app.include_router(dbapi.router, prefix="/dbapi") app.include_router(pubsub.router, prefix="/pubsub") app.include_router(game.router, prefix="/game") app.include_router(quizzes.router, prefix="/quizzes") +app.include_router(battles.router, prefix="/battles") app.include_router(workspaces.router, prefix="/workspaces") diff --git a/devplacepy/models.py b/devplacepy/models.py index 4417998a..46d75cfe 100644 --- a/devplacepy/models.py +++ b/devplacepy/models.py @@ -176,6 +176,8 @@ class PostForm(BaseModel): attachment_uids: list[str] = [] poll_question: str = Field(default="", max_length=200) poll_options: list[str] = [] + war_faction_a: str = Field(default="", max_length=30) + war_faction_b: str = Field(default="", max_length=30) @field_validator("poll_options") @classmethod @@ -198,6 +200,17 @@ class PostForm(BaseModel): return normalize_poll_options(value) +class WarJoinForm(BaseModel): + faction: str + + @field_validator("faction") + @classmethod + def valid_faction(cls, value): + if value not in ("a", "b"): + raise ValueError("Faction must be a or b") + return value + + class PostEditForm(BaseModel): content: str = Field(min_length=10, max_length=125000) title: str = Field(default="", max_length=500) diff --git a/devplacepy/routers/CLAUDE.md b/devplacepy/routers/CLAUDE.md index 344f29ca..a9afc17e 100644 --- a/devplacepy/routers/CLAUDE.md +++ b/devplacepy/routers/CLAUDE.md @@ -46,6 +46,7 @@ Prefixes are wired in `main.py`: | `/api` | devrant/ package - devRant-compatible REST protocol (`auth.py`, `rants.py`, `comments.py`, `notifs.py`). Translates devRant requests onto DevPlace data: rants<->posts, comments/votes onto the native engagement layer, devRant integer ids onto each table's auto-increment `id`. Token auth via `devrant_tokens`. See `routers/devrant/CLAUDE.md` for the deep detail on this tree | | `/dbapi` | dbapi/ package - **primary-administrator-only, strictly READ-ONLY** generic database API over `dataset` (never inserts/updates/deletes/restores; the write surface was removed because it bypassed every per-route admin safeguard). `tables.py` (`GET /tables`, `GET /{table}/schema`), `crud.py` (read only: `GET /{table}` + `GET /{table}/{key}/{value}`, `?include_deleted`), `query.py` (`POST /query` hard SELECT-only validated read-only run; `POST /query/async` + `GET /query/{uid}` + `WS /query/{uid}/ws` via `DbApiJobService` kind `dbquery`), `nl.py` (`POST /nl` natural-language->SQL via the AI gateway, returns validated SELECT, `execute=true` runs it read-only). **Auth = the PRIMARY administrator only** (the earliest-created Admin, `utils.is_primary_admin` / `database.get_primary_admin_uid` - the same identity that gates backup downloads) by session/api_key (`services/dbapi/policy.py`); every other administrator is refused like a member, and there is **no internal-key path** - the gateway `internal_gateway_key()` is NOT accepted (no service-to-service access). SQL validated by `services/dbapi/validate.py` (sqlglot classify + suspicious-flag + read-only `EXPLAIN` dry-run). Devii tools `db_*` are read-only (list/get/query/nl; no write tools) and flagged `requires_primary_admin=True`, so they are added to the LLM tool list ONLY for the primary administrator (every other session never sees them and Devii is unaware they exist). `services/pubsub/policy.py` resolves its own admin/internal actor and does NOT reuse `dbapi.policy.caller_for`, so the primary-admin restriction does not leak onto the pub/sub bus. See `devplacepy/services/dbapi/CLAUDE.md` | | `/quizzes` | quizzes/ package - **Quizzes**: `index.py` (hub, create, import, detail, export, edit, delete, publish, per-quiz leaderboard, cross-quiz scoreboard), `questions.py` (builder page + question CRUD + reorder), `attempts.py` (start/resume, play, answer, finish, results). The hub `GET /quizzes` is the approved three-column `.feed-layout` reused verbatim from `/feed`: filters + search left (`?filter=all|todo|done|mine|drafts`, `?search=`, `?page=`), the quiz list centre with the **New quiz** and **Create quiz with Devii** actions, and the cross-quiz **scoreboard** rail right (score per user, best attempt per quiz, 15s display cache). Publishing is terminal - every write on a published quiz is a 400 and there is no unpublish route. See `devplacepy/services/quiz/CLAUDE.md` | +| `/battles` | battles.py - **Opinion Wars**, week-long two-faction battles attached to posts: `GET ""` (listing, quizzes-style filters active/ended/mine + search), `GET /{uid}` (JSON-only full state, runs lazy resolution), `GET /{uid}/events?after=` (durable event trail replay), `POST /{uid}/join` (join or switch faction), `POST /{uid}/fight` (spend 25 Code Farm coins, deal level-weighted damage, 24h cooldown). The battle card renders on the parent post (no battle detail HTML page). See `devplacepy/services/opinionwar/CLAUDE.md` | | `/game` | game/ package - the **Code Farm** idle game (`index.py` + `farm.py`): `GET /game` (page), `GET /game/state`, `GET /game/leaderboard?board=`, `POST /game/{plant,harvest,buy-plot,upgrade,fertilize,daily,grant,perk,prestige,legacy,mastery,quests/claim}`, `POST /game/{defense/upgrade,defense/downgrade,infrastructure/buy,cosmetics/buy,cosmetics/equip}`, plus social `GET /game/farm/{username}` and `POST /game/farm/{username}/{water,steal}`. See `devplacepy/services/game/CLAUDE.md` | | (none) | push.py - push + PWA: `GET /push.json` (VAPID public key + the providers accepting registrations), `POST /push.json` (register with any active provider; a body without `provider` is a `webpush` body, so existing clients are unchanged; an unknown, disabled or unconfigured provider is a 400), `GET /service-worker.js`, `GET /manifest.json`. Provider protocol and delivery live in `devplacepy/push/` - see `devplacepy/push/CLAUDE.md` | | (none) | docs.py (docs/ package) - the documentation site (prose pages + API reference). See `routers/docs/CLAUDE.md` for the deep detail on this tree (`DOCS_PAGES`, audience tiers, prose rendering pipeline) | diff --git a/devplacepy/routers/battles.py b/devplacepy/routers/battles.py new file mode 100644 index 00000000..f2ba5fb2 --- /dev/null +++ b/devplacepy/routers/battles.py @@ -0,0 +1,129 @@ +# retoor + +from typing import Annotated +from urllib.parse import quote + +from fastapi import APIRouter, Depends, Request +from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse + +from devplacepy.database import resolve_object_url +from devplacepy.dependencies import json_or_form +from devplacepy.models import WarJoinForm +from devplacepy.responses import action_result, json_error, respond, wants_json +from devplacepy.schemas import BattlesOut, WarEventsOut, WarOut +from devplacepy.seo import base_seo_context +from devplacepy.services.opinionwar import WarError, rules, store +from devplacepy.utils import get_current_user, not_found, require_user + +router = APIRouter() + + +def _war_error(request: Request, message: str, redirect_url: str): + if wants_json(request): + return json_error(400, message) + separator = "&" if "?" in redirect_url else "?" + return RedirectResponse( + url=f"{redirect_url}{separator}error={quote(message)}", status_code=302 + ) + + +def _post_url(war: dict) -> str: + return resolve_object_url("post", war["post_uid"]) + + +@router.get("", response_class=HTMLResponse) +async def battles_page( + request: Request, filter: str = "active", search: str = "", page: int = 1 +): + user = get_current_user(request) + current_filter = filter if filter in store.FILTERS else "active" + battles, pagination = store.list_wars( + viewer=user, + war_filter=current_filter, + search=search, + page=max(1, page), + ) + seo_ctx = base_seo_context( + request, + title="Opinion Wars", + description=( + "Week-long faction battles between developers. Pick a side, fight once " + "a day and carry your faction to victory." + ), + breadcrumbs=[ + {"name": "Home", "url": "/feed"}, + {"name": "Battles", "url": "/battles"}, + ], + ) + return respond( + request, + "battles.html", + { + **seo_ctx, + "user": user, + "battles": battles, + "current_filter": current_filter, + "counts": store.filter_counts(user, search), + "search": search, + "pagination": pagination, + }, + model=BattlesOut, + ) + + +@router.get("/{war_uid}") +async def battle_state(request: Request, war_uid: str): + user = get_current_user(request) + serialized = store.get_war_serialized(store.get_war(war_uid), user) + if not serialized: + raise not_found("Battle not found") + return JSONResponse(WarOut.model_validate(serialized).model_dump()) + + +@router.get("/{war_uid}/events") +async def battle_events( + request: Request, war_uid: str, after: int = 0, limit: int = rules.EVENT_LIMIT_DEFAULT +): + war = store.resolve_if_due(store.get_war(war_uid)) + if not war: + raise not_found("Battle not found") + events = store.events_for(war_uid, after_seq=after, limit=limit) + return JSONResponse( + WarEventsOut.model_validate( + {"events": events, "status": war.get("status") or "active"} + ).model_dump() + ) + + +@router.post("/{war_uid}/join") +async def join_battle( + request: Request, + war_uid: str, + data: Annotated[WarJoinForm, Depends(json_or_form(WarJoinForm))], +): + user = require_user(request) + war = store.get_war(war_uid) + if not war: + raise not_found("Battle not found") + url = _post_url(war) + try: + war = store.join_war(war, user, data.faction, request) + except WarError as exc: + return _war_error(request, str(exc), url) + serialized = store.get_war_serialized(war, user) + return action_result(request, url, data={"war": serialized}) + + +@router.post("/{war_uid}/fight") +async def fight_battle(request: Request, war_uid: str): + user = require_user(request) + war = store.get_war(war_uid) + if not war: + raise not_found("Battle not found") + url = _post_url(war) + try: + war, damage = store.fight(war, user, request) + except WarError as exc: + return _war_error(request, str(exc), url) + serialized = store.get_war_serialized(war, user) + return action_result(request, url, data={"war": serialized, "damage": damage}) diff --git a/devplacepy/routers/docs/pages.py b/devplacepy/routers/docs/pages.py index f87b51d2..5e2a2912 100644 --- a/devplacepy/routers/docs/pages.py +++ b/devplacepy/routers/docs/pages.py @@ -82,6 +82,12 @@ DOCS_PAGES = [ "kind": "prose", "section": SECTION_GENERAL, }, + { + "slug": "opinion-wars", + "title": "Opinion Wars", + "kind": "prose", + "section": SECTION_GENERAL, + }, { "slug": "block-and-mute", "title": "Block and mute", diff --git a/devplacepy/routers/feed.py b/devplacepy/routers/feed.py index 0ee97b1a..7a068cfd 100644 --- a/devplacepy/routers/feed.py +++ b/devplacepy/routers/feed.py @@ -14,6 +14,9 @@ from devplacepy.database import ( get_reactions_by_targets, get_user_bookmarks, get_polls_by_post_uids, +) +from devplacepy.services.opinionwar import store as war_store +from devplacepy.database import ( paginate_diverse, text_search_clause, ) @@ -101,6 +104,7 @@ async def feed_page( get_user_bookmarks(user["uid"], "post", post_uids_list) if user else set() ) polls_map = get_polls_by_post_uids(post_uids_list, user) + wars_map = war_store.get_wars_by_post_uids(post_uids_list, user) for item in posts: uid = item["post"]["uid"] item["attachments"] = attachments_map.get(uid, []) @@ -108,6 +112,7 @@ async def feed_page( item["reactions"] = reactions_map.get(uid, {"counts": {}, "mine": []}) item["bookmarked"] = uid in bookmark_set item["poll"] = polls_map.get(uid) + item["war"] = wars_map.get(uid) seo_ctx = list_page_seo( request, diff --git a/devplacepy/routers/posts.py b/devplacepy/routers/posts.py index 5c033f04..90c19096 100644 --- a/devplacepy/routers/posts.py +++ b/devplacepy/routers/posts.py @@ -41,6 +41,7 @@ from devplacepy.seo import ( from devplacepy.attachments import save_inline_image from devplacepy.models import PostForm, PostEditForm from devplacepy.services.audit import record as audit +from devplacepy.services.opinionwar import store as war_store from devplacepy.dependencies import json_or_form logger = logging.getLogger(__name__) @@ -87,6 +88,7 @@ async def create_post(request: Request, data: Annotated[PostForm, Depends(json_o ) create_poll(uid, user, data.poll_question, data.poll_options, request) + war_store.create_war(uid, user, data.war_faction_a, data.war_faction_b, request) url = f"/posts/{post_slug}" return action_result(request, url, data={"uid": uid, "slug": post_slug, "url": url}) diff --git a/devplacepy/routers/profile/index.py b/devplacepy/routers/profile/index.py index e6d8c11e..708a0709 100644 --- a/devplacepy/routers/profile/index.py +++ b/devplacepy/routers/profile/index.py @@ -17,6 +17,9 @@ from devplacepy.database import ( get_reactions_by_targets, get_user_bookmarks, get_polls_by_post_uids, +) +from devplacepy.services.opinionwar import store as war_store +from devplacepy.database import ( get_activity_heatmap, get_activity_months, get_streaks, @@ -203,11 +206,13 @@ async def profile_page( else set() ) polls_map = get_polls_by_post_uids(post_uids, current_user) + wars_map = war_store.get_wars_by_post_uids(post_uids, current_user) for item in posts: uid = item["post"]["uid"] item["reactions"] = reactions_map.get(uid, {"counts": {}, "mine": []}) item["bookmarked"] = uid in bookmark_set item["poll"] = polls_map.get(uid) + item["war"] = wars_map.get(uid) badges = list(get_table("badges").find(user_uid=profile_user["uid"])) for b in badges: diff --git a/devplacepy/routers/projects/index.py b/devplacepy/routers/projects/index.py index bc516617..5f63709c 100644 --- a/devplacepy/routers/projects/index.py +++ b/devplacepy/routers/projects/index.py @@ -23,6 +23,9 @@ from devplacepy.database import ( get_reactions_by_targets, get_user_bookmarks, get_polls_by_post_uids, +) +from devplacepy.services.opinionwar import store as war_store +from devplacepy.database import ( paginate, text_search_clause, resolve_by_slug, @@ -289,12 +292,14 @@ async def project_detail(request: Request, project_slug: str, before: str = None get_user_bookmarks(user["uid"], "post", post_uids) if user else set() ) polls_map = get_polls_by_post_uids(post_uids, user) + wars_map = war_store.get_wars_by_post_uids(post_uids, user) for item in devlog_posts: uid = item["post"]["uid"] item["attachments"] = attachments_map.get(uid, []) item["reactions"] = reactions_map.get(uid, {"counts": {}, "mine": []}) item["bookmarked"] = uid in bookmark_set item["poll"] = polls_map.get(uid) + item["war"] = wars_map.get(uid) return respond( request, diff --git a/devplacepy/schemas/__init__.py b/devplacepy/schemas/__init__.py index 4f84d164..0e361184 100644 --- a/devplacepy/schemas/__init__.py +++ b/devplacepy/schemas/__init__.py @@ -151,6 +151,15 @@ from devplacepy.schemas.dbapi import ( DbTableOut, NlQueryOut, ) +from devplacepy.schemas.battles import ( + BattlesOut, + WarContributorOut, + WarEventOut, + WarEventsOut, + WarOut, + WarPersonOut, + WarViewerOut, +) from devplacepy.schemas.quiz import ( QuizAnswerOut, QuizAnswerResultOut, diff --git a/devplacepy/schemas/battles.py b/devplacepy/schemas/battles.py new file mode 100644 index 00000000..0c5d75ee --- /dev/null +++ b/devplacepy/schemas/battles.py @@ -0,0 +1,82 @@ +# retoor + +from __future__ import annotations + +from typing import Optional + +from devplacepy.schemas.base import _Out + + +class WarPersonOut(_Out): + uid: str = "" + username: str = "" + avatar_seed: Optional[str] = None + level: int = 1 + + +class WarContributorOut(WarPersonOut): + faction: str = "" + hp: int = 0 + + +class WarEventOut(_Out): + seq: int = 0 + kind: str = "" + message: str = "" + faction: str = "" + created_at: str = "" + hp_a: Optional[int] = None + hp_b: Optional[int] = None + damage: Optional[int] = None + winner: Optional[str] = None + + +class WarViewerOut(_Out): + faction: str = "" + hp: int = 0 + rank: int = 0 + fight_count: int = 0 + last_fight_at: str = "" + next_fight_at: str = "" + can_fight: bool = False + + +class WarOut(_Out): + uid: str = "" + post_uid: str = "" + post_url: str = "" + post_title: str = "" + author: Optional[WarPersonOut] = None + faction_a: str = "" + faction_b: str = "" + hp_a: int = 0 + hp_b: int = 0 + pct_a: int = 50 + pct_b: int = 50 + leader: str = "" + fighter_count: int = 0 + status: str = "active" + winner: str = "" + winner_label: str = "" + created_at: str = "" + ends_at: str = "" + ends_in: str = "" + resolved_at: str = "" + last_seq: int = 0 + fight_cost: int = 0 + top_contributors: list[WarContributorOut] = [] + recent_events: list[WarEventOut] = [] + viewer: Optional[WarViewerOut] = None + + +class BattlesOut(_Out): + battles: list[WarOut] = [] + current_filter: str = "active" + counts: dict = {} + search: str = "" + pagination: dict = {} + + +class WarEventsOut(_Out): + events: list[WarEventOut] = [] + status: str = "" diff --git a/devplacepy/schemas/listings.py b/devplacepy/schemas/listings.py index dcc0d44f..b1ed1841 100644 --- a/devplacepy/schemas/listings.py +++ b/devplacepy/schemas/listings.py @@ -5,6 +5,7 @@ from __future__ import annotations from typing import Any, Optional from devplacepy.schemas.base import _Out +from devplacepy.schemas.battles import WarOut from devplacepy.schemas.content import ( AttachmentOut, CommentItemOut, @@ -33,6 +34,7 @@ class FeedItemOut(_Out): reactions: ReactionsOut = ReactionsOut() bookmarked: bool = False poll: Optional[PollOut] = None + war: Optional[WarOut] = None project_link: Optional[ProjectLinkOut] = None @@ -134,6 +136,7 @@ class PostDetailOut(_Out): reactions: ReactionsOut = ReactionsOut() bookmarked: bool = False poll: Optional[PollOut] = None + war: Optional[WarOut] = None comment_count: Optional[int] = None related_posts: list[FeedItemOut] = [] topics: list[str] = [] diff --git a/devplacepy/seo.py b/devplacepy/seo.py index 5c4f32d1..2f1c4f16 100644 --- a/devplacepy/seo.py +++ b/devplacepy/seo.py @@ -426,6 +426,7 @@ def _build_sitemap(base_url): ) urlset.append(url_element(f"{base_url}/gists", changefreq="daily", priority="0.8")) urlset.append(url_element(f"{base_url}/quizzes", changefreq="daily", priority="0.8")) + urlset.append(url_element(f"{base_url}/battles", changefreq="daily", priority="0.7")) urlset.append( url_element(f"{base_url}/leaderboard", changefreq="daily", priority="0.7") ) diff --git a/devplacepy/services/audit/CLAUDE.md b/devplacepy/services/audit/CLAUDE.md index 2f5b4ba2..162a1863 100644 --- a/devplacepy/services/audit/CLAUDE.md +++ b/devplacepy/services/audit/CLAUDE.md @@ -2,7 +2,7 @@ This file documents the audit log subsystem. Claude Code auto-loads it when a fi ## Audit log (`services/audit/`) -**Admin-only, append-only** record of every state-changing action. The authoritative event catalogue is `events.md` (its storage model, relation vocabulary, and per-event specs are authoritative); the catalogue currently spans 288 keys across 42 domains. +**Admin-only, append-only** record of every state-changing action. The authoritative event catalogue is `events.md` (its storage model, relation vocabulary, and per-event specs are authoritative); the catalogue currently spans 293 keys across 43 domains. ### Package layout diff --git a/devplacepy/services/audit/categories.py b/devplacepy/services/audit/categories.py index 4ae6020c..da787a06 100644 --- a/devplacepy/services/audit/categories.py +++ b/devplacepy/services/audit/categories.py @@ -24,6 +24,7 @@ CATEGORY_BY_PREFIX: dict[str, str] = { "reaction": "engagement", "bookmark": "engagement", "poll": "engagement", + "battle": "engagement", "project": "project", "file": "project_files", "dir": "project_files", diff --git a/devplacepy/services/devii/actions/catalog/__init__.py b/devplacepy/services/devii/actions/catalog/__init__.py index 5994d8b3..305d66fb 100644 --- a/devplacepy/services/devii/actions/catalog/__init__.py +++ b/devplacepy/services/devii/actions/catalog/__init__.py @@ -5,6 +5,7 @@ from __future__ import annotations from ..spec import Action, Catalog from .admin import ADMIN_ACTIONS from .auth import AUTH_ACTIONS +from .battles import BATTLE_ACTIONS from .comments import COMMENTS_ACTIONS from .dbapi import DBAPI_ACTIONS from .engagement import ENGAGEMENT_ACTIONS @@ -48,6 +49,7 @@ ACTIONS: tuple[Action, ...] = ( + GATEWAY_ACTIONS + GAME_ACTIONS + QUIZ_ACTIONS + + BATTLE_ACTIONS + MODERATION_ACTIONS ) diff --git a/devplacepy/services/devii/actions/catalog/battles.py b/devplacepy/services/devii/actions/catalog/battles.py new file mode 100644 index 00000000..0e7f583b --- /dev/null +++ b/devplacepy/services/devii/actions/catalog/battles.py @@ -0,0 +1,85 @@ +# retoor + +from __future__ import annotations + +from ..spec import Action +from ._shared import body, confirm, path, query + +BATTLE_ACTIONS: tuple[Action, ...] = ( + Action( + name="list_battles", + method="GET", + path="/battles", + summary="List Opinion War battles", + description=( + "Returns week-long two-faction battles attached to posts, with HP totals, " + "percentages, top contributors and the viewer's own faction state." + ), + handler="http", + requires_auth=False, + read_only=True, + params=( + query("search", "Match a faction name or the creator's username."), + query("filter", "One of active, ended, mine. Defaults to active."), + query("page", "1-based page number."), + ), + ), + Action( + name="get_battle", + method="GET", + path="/battles/{uid}", + summary="Get one Opinion War battle's full state", + handler="http", + requires_auth=False, + read_only=True, + params=(path("uid", "Battle uid."),), + ), + Action( + name="battle_events", + method="GET", + path="/battles/{uid}/events", + summary="Read a battle's event log", + description=( + "Ordered battle events (join, switch, fight, lead_change, result). Pass " + "after to replay incrementally from a sequence number." + ), + handler="http", + requires_auth=False, + read_only=True, + params=( + path("uid", "Battle uid."), + query("after", "Return only events with a seq greater than this."), + query("limit", "Maximum events to return."), + ), + ), + Action( + name="join_battle", + method="POST", + path="/battles/{uid}/join", + summary="Join or switch to a faction in an Opinion War", + description=( + "Joins faction a or b, or switches an existing fighter to the other side. " + "Damage already dealt stays with the faction it was dealt to." + ), + handler="http", + requires_auth=True, + params=( + path("uid", "Battle uid."), + body("faction", "Which side to join or switch to: a or b.", required=True), + confirm(), + ), + ), + Action( + name="fight_battle", + method="POST", + path="/battles/{uid}/fight", + summary="Fight for your faction in an Opinion War", + description=( + "Spends 25 Code Farm coins and deals level-weighted HP damage for the " + "fighter's faction. Allowed once per 24 hours per battle." + ), + handler="http", + requires_auth=True, + params=(path("uid", "Battle uid."), confirm()), + ), +) diff --git a/devplacepy/services/devii/actions/catalog/posts.py b/devplacepy/services/devii/actions/catalog/posts.py index ea32e4c7..d2fd87ee 100644 --- a/devplacepy/services/devii/actions/catalog/posts.py +++ b/devplacepy/services/devii/actions/catalog/posts.py @@ -36,6 +36,14 @@ POSTS_ACTIONS: tuple[Action, ...] = ( "poll_options", "Poll options as a JSON array of strings, or one option per line, or comma separated. At least two are required for the poll to be created.", ), + body( + "war_faction_a", + "Optional Opinion War faction A name (max 30 chars). Both faction names are required to start the week-long battle.", + ), + body( + "war_faction_b", + "Optional Opinion War faction B name (max 30 chars). Must differ from faction A.", + ), ), ), Action( diff --git a/devplacepy/services/devii/actions/dispatcher.py b/devplacepy/services/devii/actions/dispatcher.py index 54ec706c..e6d09250 100644 --- a/devplacepy/services/devii/actions/dispatcher.py +++ b/devplacepy/services/devii/actions/dispatcher.py @@ -32,6 +32,8 @@ from .spec import Action, Catalog MUTATING_METHODS = ("POST", "DELETE", "PUT", "PATCH") CONFIRM_REQUIRED = { + "join_battle", + "fight_battle", "delete_my_account", "decide_report", "suspend_user", diff --git a/devplacepy/services/opinionwar/CLAUDE.md b/devplacepy/services/opinionwar/CLAUDE.md new file mode 100644 index 00000000..6ab5d504 --- /dev/null +++ b/devplacepy/services/opinionwar/CLAUDE.md @@ -0,0 +1,134 @@ +# Opinion Wars (`devplacepy/services/opinionwar/`, `devplacepy/routers/battles.py`) + +This file documents the Opinion War subsystem. Claude Code auto-loads it when a file under +`devplacepy/services/opinionwar/` is read or edited. + +## Overview + +An Opinion War is a week-long two-faction battle attached to a post, structurally a sibling of +polls: one `opinion_wars` row keyed by `post_uid`, created inside `POST /posts/create` when both +`war_faction_a` and `war_faction_b` are submitted (the composer's "Start Opinion War" builder, +same disabled-inputs opt-in as the poll builder, driven by `static/js/WarComposer.js`). Malformed +faction input (blank, equal casefolded, over 30 chars, or a second war on the same post) silently +creates no war - the `create_poll` precedent. Wars are create-time only: there is deliberately NO +war builder in the post edit modal, because `ends_at` anchors to `created_at + 7 days` and a war +attached later would either be born expired or break that anchor. + +Members join faction `a` or `b`, may switch any time (damage already dealt STAYS with the faction +it was dealt to - fighters carry per-side `hp_a`/`hp_b` columns so the sum invariant survives +defection), and fight once per 24h per war. A fight costs `FIGHT_COST_COINS` (25) Code Farm coins +and deals `damage_for(level)` = `100 + 10 * min(level, 20)` HP - deterministic by design (no RNG: +purchasable randomness is an app-store conditional the platform must never trigger). After 7 days +the faction with more HP wins; equal totals are a draw. + +## Package layout + +``` +services/opinionwar/ + rules.py pure constants and formulas: damage_for, ends_at_for, is_ended, cooldown math, + leader_of/winner_of, pct_split, ends_in_label. No DB, no network. + store.py all DB access: create/join/fight/resolve, the atomic transitions, event + allocation, batch serialization, the /battles listing queries. + service.py OpinionWarService (BaseService): pub/sub relay + resolution/cooldown backstop. +``` + +`store.py` is the only place that touches the tables. `rules.py` never imports `store`. The +router (`routers/battles.py`) never issues SQL. + +## Tables + +`opinion_wars` (uid, post_uid UNIQUE, user_uid, faction_a/b, hp_a/b, leader, status +active|resolved, winner a|b|draw, created_at, ends_at, resolved_at), `opinion_war_fighters` +(war_uid+user_uid UNIQUE, faction, hp_a/b = damage dealt FOR each side, fight_count, +last_fight_at, cooldown_notified_at), `opinion_war_events` (war_uid+seq UNIQUE, kind, message, +payload JSON, actor_uid). All three are in `SOFT_DELETE_TABLES` with born-live inserts; columns + +indexes ensured in `init_db()`. Moderation classification: `battle` -> `opinion_wars` in +`REPORTABLE_TARGETS` (creator-authored faction names), fighters/events in `UNREPORTABLE_TABLES`. +`resolve_object_url("battle", uid)` resolves to the parent post URL. Post deletion cascades +soft+hard through `database/ranking.py` under the shared stamp. + +## Atomicity: every transition is a conditional UPDATE + +All mutations go through `database/atomic.py::conditional_update_row` (which writes `updated_at` +in every statement - the wars and fighters tables carry the column for this reason; the events +table is insert-only and does not). + +| Transition | Precondition | rowcount 0 means | +|---|---|---| +| Claim the cooldown | `COALESCE(last_fight_at,'')='' OR last_fight_at <= :cutoff` | fought within 24h - refuse, money untouched | +| Spend the coins | `COALESCE(coins,0) >= :cost` (`conditional_update_farm`) | broke - restore the cooldown, refuse | +| Land the damage | `status='active' AND ends_at > :now` | war ended mid-flight - refund coins, restore cooldown, resolve | +| Switch faction | `faction != :faction` | already on that side - no event | +| Claim a lead flip | `COALESCE(leader,'') != :leader AND status='active'` | someone else owns the flip - no duplicate event/notifications | +| Resolve | `status='active'` (winner computed IN the statement via CASE) | already resolved - no second XP, no second result event | +| Cooldown notification | `cooldown_notified_at != last_fight_at AND last_fight_at = :last` | already notified for this fight - never repeats, re-arms on the next fight | + +**The fight sequence is cooldown-first with compensation, a deliberate deviation from the game's +charge-then-claim:** a crash mid-sequence must cost the user one turn, never coins. Claim the +cooldown, then spend, then deal damage; each later failure compensates the earlier steps +(cooldown restore is itself a CAS guarded on the exact value just written, so a concurrent +legitimate fight is never clobbered). Accepted residual: a process crash between the cooldown +stamp and the damage write loses one turn and self-heals in 24h. + +**Event seq allocation is one atomic statement** (`allocate_event`): a raw +`INSERT ... SELECT COALESCE(MAX(seq),0)+1 ... WHERE war_uid = :w` inside `with db:` (raw writes +do not auto-commit). The MAX deliberately scans ALL rows including soft-deleted so seq stays +monotonic across a trash restore. This differs from isslop, whose seq counter lives in the single +worker process - war events originate in request handlers on any worker. + +## Resolution is lazy, exactly-once, no cron + +`resolve_if_due(war)` runs at every read and mutation entry (the batch card loader, the listing, +`GET /battles/{uid}`, events, join, fight). The CAS winner (rowcount 1) alone awards XP via +`award_rewards` (participation `XP_BATTLE_PART` for every fighter with `fight_count > 0`, winners +add `XP_BATTLE_WIN` + `track_action("battle_win")`, the single top damage dealer war-wide adds +`XP_BATTLE_TOP`; a draw pays participation only), emits the `result` event, defers the result +notifications to ALL joined fighters (zero-fight members get the notification, no XP), and +records `battle.resolve` via `audit.record_system`. Race-proven: 8 concurrent resolvers award +exactly once. + +## Live events: relay on the lock owner, DB trail is the source of truth + +Request handlers NEVER call `services.pubsub.publish` - it is in-process and WS subscribers +converge on the service-lock-owner worker, so a handler-side publish on the other worker would +silently drop the frame. `OpinionWarService` (2s tick, registered in `main.py` beside +`NotificationRelayService`) relays: watermark on `opinion_war_events.id`, publish each new row to +`public.battle.{war_uid}`. The same tick runs a 60s-throttled sweep resolving ended wars nobody +viewed and sending the fight-ready notifications. Clients (`dp-opinion-war`, +`static/js/components/AppOpinionWar.js`) pair the subscription with a 15s `Poller` on +`GET /battles/{uid}/events?after={lastSeq}` and dedupe by seq, so guests, reconnects and +disabled-services test runs all replay from the durable trail. + +## Notifications + +Type `battle` in `database.NOTIFICATION_TYPES`. Three messages: lead change (to that war's +fighters, actor excluded, actor as `related_uid` so block/mute applies), the result (to all +fighters, recipient-self as `related_uid`), and "Your Fight is ready" (the service sweep, marker +CAS above). All `target_url`s are the post URL, so `view_post`'s existing +`mark_notifications_read_by_target` clears them on view with zero new code. + +## The card and the listing + +`templates/_opinion_war.html` (local `_war`) renders wherever `_post_card.html`/`post.html` +render, attached by `store.get_wars_by_post_uids` at the four poll-map call sites (feed, profile +posts tab, project devlog, `content.load_detail`). The battlefield strip is the self-contained +`_opinion_war_field.html` + the `.war-field*` layer in `static/css/opinionwar.css`: CSS pixel-art +sprites (castles, soldiers, campfire) drawn with the box-shadow pixel technique on a `--px` unit, +animated with `steps()` keyframes, fully disabled under `prefers-reduced-motion`. The stylesheet +is global in `base.html` (the `engagement.css` precedent - the card renders across many pages) +and opens with the file-scoped `--war-*` palette block (the `isslop.css` pattern). Faction names +are user content: always rendered through `render_title`. + +`GET /battles` is the listing (quizzes-pattern: page pagination, active/ended/mine filters, +`_sidebar_search.html`); there is NO battle detail HTML page - `GET /battles/{uid}` is JSON-only +and the post page is the surface. `serialize_war` is the single card/JSON shape (`WarOut`). + +## Verification + +The feature is a spendable resource + bounded state machine + multi-path read-then-write, so the +root CLAUDE.md four-layer procedure applies to any change here: property checks on `rules.py` +across the full domain, stateful fuzz asserting `war.hp_x == SUM(fighters.hp_x)` and +`coins >= 0` after every action, and REAL multi-process races (concurrent fight = exactly one +lands and exactly one fee; two wars vs 1.5x the fee = exactly one lands; concurrent resolve = +XP once; concurrent join = one fighter row). Persisted tests: `tests/unit/services/opinionwar/`, +`tests/api/battles/`, `tests/api/posts/create.py` (war creation), `tests/e2e/battles/`. diff --git a/devplacepy/services/opinionwar/__init__.py b/devplacepy/services/opinionwar/__init__.py new file mode 100644 index 00000000..9f103413 --- /dev/null +++ b/devplacepy/services/opinionwar/__init__.py @@ -0,0 +1,6 @@ +# retoor + +from . import rules, store +from .store import WarError + +__all__ = ["rules", "store", "WarError"] diff --git a/devplacepy/services/opinionwar/rules.py b/devplacepy/services/opinionwar/rules.py new file mode 100644 index 00000000..a5d7feda --- /dev/null +++ b/devplacepy/services/opinionwar/rules.py @@ -0,0 +1,111 @@ +# retoor + +from __future__ import annotations + +from datetime import datetime, timedelta, timezone + +WAR_DURATION_DAYS = 7 +FIGHT_COST_COINS = 25 +FIGHT_COOLDOWN_HOURS = 24 +BASE_DAMAGE = 100 +LEVEL_DAMAGE_STEP = 10 +LEVEL_DAMAGE_CAP = 20 +FACTION_NAME_MAX = 30 +TOP_CONTRIBUTORS = 3 +EVENT_TICKER_LIMIT = 5 +EVENT_LIMIT_DEFAULT = 500 + +EVENT_KINDS = ("join", "switch", "fight", "lead_change", "result") + + +def _parse(value: str | None) -> datetime | None: + if not value: + return None + try: + parsed = datetime.fromisoformat(value) + except (TypeError, ValueError): + return None + if parsed.tzinfo is None: + parsed = parsed.replace(tzinfo=timezone.utc) + return parsed + + +def _now(now: datetime | None = None) -> datetime: + return now or datetime.now(timezone.utc) + + +def damage_for(level) -> int: + try: + value = int(level or 1) + except (TypeError, ValueError): + value = 1 + return BASE_DAMAGE + LEVEL_DAMAGE_STEP * min(max(value, 1), LEVEL_DAMAGE_CAP) + + +def ends_at_for(created_at: str) -> str: + start = _parse(created_at) or _now() + return (start + timedelta(days=WAR_DURATION_DAYS)).isoformat() + + +def is_ended(ends_at: str, now: datetime | None = None) -> bool: + ends = _parse(ends_at) + if not ends: + return False + return _now(now) >= ends + + +def cooldown_cutoff(now: datetime | None = None) -> str: + return (_now(now) - timedelta(hours=FIGHT_COOLDOWN_HOURS)).isoformat() + + +def cooldown_ready_at(last_fight_at: str) -> str: + last = _parse(last_fight_at) + if not last: + return "" + return (last + timedelta(hours=FIGHT_COOLDOWN_HOURS)).isoformat() + + +def can_fight_at(last_fight_at: str, now: datetime | None = None) -> bool: + ready = _parse(cooldown_ready_at(last_fight_at)) + if not ready: + return True + return _now(now) >= ready + + +def leader_of(hp_a: int, hp_b: int) -> str: + if hp_a > hp_b: + return "a" + if hp_b > hp_a: + return "b" + return "" + + +def winner_of(hp_a: int, hp_b: int) -> str: + return leader_of(hp_a, hp_b) or "draw" + + +def pct_split(hp_a: int, hp_b: int) -> tuple[int, int]: + left = max(0, int(hp_a or 0)) + right = max(0, int(hp_b or 0)) + total = left + right + if not total: + return 50, 50 + pct_a = round(left * 100 / total) + return pct_a, 100 - pct_a + + +def ends_in_label(ends_at: str, now: datetime | None = None) -> str: + ends = _parse(ends_at) + if not ends: + return "" + remaining = (ends - _now(now)).total_seconds() + if remaining <= 0: + return "" + minutes = int(remaining // 60) + days, minutes = divmod(minutes, 1440) + hours, minutes = divmod(minutes, 60) + if days: + return f"{days}d {hours}h {minutes}m" + if hours: + return f"{hours}h {minutes}m" + return f"{max(minutes, 1)}m" diff --git a/devplacepy/services/opinionwar/service.py b/devplacepy/services/opinionwar/service.py new file mode 100644 index 00000000..c8da5e05 --- /dev/null +++ b/devplacepy/services/opinionwar/service.py @@ -0,0 +1,90 @@ +# retoor + +from __future__ import annotations + +import time + +from devplacepy.database import db +from devplacepy.services.base import BaseService +from devplacepy.services.pubsub import publish as pubsub_publish + +from . import store + +BATCH_LIMIT = 500 +SWEEP_SECONDS = 60 + + +def battle_topic(war_uid: str) -> str: + return f"public.battle.{war_uid}" + + +class OpinionWarService(BaseService): + title = "Opinion Wars" + description = ( + "Relays persisted battle events onto the pub/sub bus for live cards, resolves " + "ended wars that nobody viewed, and sends the fight-cooldown-ready " + "notifications. Runs on the service lock owner, where every pub/sub " + "subscriber converges; the event table stays the source of truth." + ) + default_enabled = True + + def __init__(self): + super().__init__(name="opinionwar", interval_seconds=2) + self._watermark = 0 + self._primed = False + self._last_sweep = 0.0 + + def _max_id(self) -> int: + if "opinion_war_events" not in db.tables: + return 0 + rows = list(db.query("SELECT MAX(id) AS max_id FROM opinion_war_events")) + value = rows[0]["max_id"] if rows else None + return int(value or 0) + + async def _relay_events(self) -> None: + if "opinion_war_events" not in db.tables: + return + if not self._primed: + self._watermark = self._max_id() + self._primed = True + return + rows = list( + db.query( + "SELECT * FROM opinion_war_events WHERE id > :wm " + "ORDER BY id ASC LIMIT :lim", + wm=self._watermark, + lim=BATCH_LIMIT, + ) + ) + if not rows: + return + delivered = 0 + for row in rows: + delivered += await pubsub_publish( + battle_topic(row["war_uid"]), store._event_dict(dict(row)) + ) + self._watermark = max(row["id"] for row in rows) + if delivered: + self.log(f"relayed {len(rows)} battle event(s), {delivered} live frame(s)") + + def _sweep(self) -> None: + now = time.monotonic() + if now - self._last_sweep < SWEEP_SECONDS: + return + self._last_sweep = now + resolved = store.resolve_due_wars() + if resolved: + self.log(f"resolved {resolved} ended war(s)") + notified = 0 + for fighter in store.cooldown_ready_fighters(): + if store.notify_cooldown_ready(fighter): + notified += 1 + if notified: + self.log(f"sent {notified} fight-ready notification(s)") + + async def run_once(self) -> None: + await self._relay_events() + self._sweep() + + def collect_metrics(self) -> dict: + return {"watermark": self._watermark, "primed": self._primed} diff --git a/devplacepy/services/opinionwar/store.py b/devplacepy/services/opinionwar/store.py new file mode 100644 index 00000000..141db9b8 --- /dev/null +++ b/devplacepy/services/opinionwar/store.py @@ -0,0 +1,794 @@ +# retoor + +from __future__ import annotations + +import json +from datetime import datetime, timezone + +from sqlalchemy import or_ +from sqlalchemy.exc import IntegrityError + +from devplacepy import config +from devplacepy.database import ( + _in_clause, + build_pagination, + conditional_update_row, + db, + get_blocked_uids, + get_table, + get_users_by_uids, + resolve_object_url, + text_search_clause, +) +from devplacepy.services.audit import record as audit +from devplacepy.services.background import background +from devplacepy.services.game.store import ( + conditional_update_farm, + ensure_farm, + refund_farm, +) +from devplacepy.utils import create_notification, generate_uid, track_action +from devplacepy.utils.rewards import ( + XP_BATTLE_PART, + XP_BATTLE_TOP, + XP_BATTLE_WIN, + award_rewards, +) + +from . import rules + +FILTERS = ("active", "ended", "mine") + + +class WarError(Exception): + pass + + +def _now() -> datetime: + return datetime.now(timezone.utc) + + +def _iso(value: datetime | None = None) -> str: + return (value or _now()).isoformat() + + +def _wars(): + return get_table("opinion_wars") + + +def _fighters(): + return get_table("opinion_war_fighters") + + +def _events(): + return get_table("opinion_war_events") + + +def born_live(fields: dict) -> dict: + stamp = _iso() + return { + **fields, + "created_at": fields.get("created_at") or stamp, + "updated_at": stamp, + "deleted_at": None, + "deleted_by": None, + } + + +def faction_label(war: dict, faction: str) -> str: + return war.get("faction_a") if faction == "a" else war.get("faction_b") + + +def get_war(war_uid: str) -> dict | None: + if not war_uid: + return None + return _wars().find_one(uid=war_uid, deleted_at=None) + + +def get_war_for_post(post_uid: str) -> dict | None: + if not post_uid: + return None + return _wars().find_one(post_uid=post_uid, deleted_at=None) + + +def create_war( + post_uid: str, user: dict, faction_a: str, faction_b: str, request=None +) -> str | None: + faction_a = (faction_a or "").strip() + faction_b = (faction_b or "").strip() + if not faction_a or not faction_b: + return None + if len(faction_a) > rules.FACTION_NAME_MAX or len(faction_b) > rules.FACTION_NAME_MAX: + return None + if faction_a.casefold() == faction_b.casefold(): + return None + if get_war_for_post(post_uid): + return None + uid = generate_uid() + created_at = _iso() + _wars().insert( + born_live( + { + "uid": uid, + "post_uid": post_uid, + "user_uid": user["uid"], + "faction_a": faction_a, + "faction_b": faction_b, + "hp_a": 0, + "hp_b": 0, + "leader": "", + "status": "active", + "winner": "", + "created_at": created_at, + "ends_at": rules.ends_at_for(created_at), + "resolved_at": "", + } + ) + ) + label = f"{faction_a} vs {faction_b}" + audit.record( + request, + "battle.create", + user=user, + target_type="battle", + target_uid=uid, + target_label=label, + metadata={"faction_a": faction_a, "faction_b": faction_b}, + summary=f"{user['username']} started Opinion War {label}", + links=[audit.target("battle", uid, label), audit.parent("post", post_uid)], + ) + track_action(user["uid"], "battle_create") + return uid + + +def join_war(war: dict, user: dict, faction: str, request=None) -> dict: + war = resolve_if_due(war) + if not war or war.get("status") != "active": + raise WarError("This battle has ended.") + if faction not in ("a", "b"): + raise WarError("Pick faction a or b.") + label = faction_label(war, faction) + fighter = _fighters().find_one(war_uid=war["uid"], user_uid=user["uid"]) + if fighter and fighter.get("deleted_at"): + _fighters().update( + { + "id": fighter["id"], + "faction": faction, + "deleted_at": None, + "deleted_by": None, + "updated_at": _iso(), + }, + ["id"], + ) + kind = "join" + elif fighter: + rows = conditional_update_row( + "opinion_war_fighters", + fighter["uid"], + "faction = :faction", + "faction != :faction AND deleted_at IS NULL", + {"faction": faction}, + ) + if not rows: + return war + kind = "switch" + else: + try: + _fighters().insert( + born_live( + { + "uid": generate_uid(), + "war_uid": war["uid"], + "user_uid": user["uid"], + "faction": faction, + "hp_a": 0, + "hp_b": 0, + "fight_count": 0, + "last_fight_at": "", + "cooldown_notified_at": "", + } + ) + ) + except IntegrityError: + return join_war(get_war(war["uid"]) or war, user, faction, request) + kind = "join" + verb = "defected to" if kind == "switch" else "joined" + allocate_event( + war["uid"], + kind, + f"{user['username']} {verb} {label}", + {"faction": faction}, + user["uid"], + ) + audit.record( + request, + f"battle.{kind}", + user=user, + target_type="battle", + target_uid=war["uid"], + target_label=label, + metadata={"faction": faction}, + summary=f"{user['username']} {verb} {label}", + links=[audit.target("battle", war["uid"], label), audit.parent("post", war["post_uid"])], + ) + return get_war(war["uid"]) or war + + +def fight(war: dict, user: dict, request=None) -> tuple[dict, int]: + war = resolve_if_due(war) + if not war or war.get("status") != "active": + raise WarError("This battle has ended.") + fighter = _fighters().find_one( + war_uid=war["uid"], user_uid=user["uid"], deleted_at=None + ) + if not fighter: + raise WarError("Join a faction first.") + now = _iso() + previous = fighter.get("last_fight_at") or "" + claimed = conditional_update_row( + "opinion_war_fighters", + fighter["uid"], + "last_fight_at = :now", + "(COALESCE(last_fight_at, '') = '' OR last_fight_at <= :cutoff) AND deleted_at IS NULL", + {"now": now, "cutoff": rules.cooldown_cutoff()}, + ) + if not claimed: + raise WarError("You can fight once every 24 hours.") + farm = ensure_farm(user["uid"]) + spent = conditional_update_farm( + farm["uid"], + "coins = COALESCE(coins, 0) - :cost", + "COALESCE(coins, 0) >= :cost", + {"cost": rules.FIGHT_COST_COINS}, + ) + if not spent: + _restore_cooldown(fighter["uid"], previous, now) + raise WarError( + f"A fight costs {rules.FIGHT_COST_COINS} Code Farm coins - earn some on your farm first." + ) + faction = "a" if fighter.get("faction") != "b" else "b" + side = "hp_a" if faction == "a" else "hp_b" + damage = rules.damage_for(user.get("level")) + landed = conditional_update_row( + "opinion_wars", + war["uid"], + f"{side} = COALESCE({side}, 0) + :damage", + "status = 'active' AND ends_at > :now AND deleted_at IS NULL", + {"damage": damage, "now": now}, + ) + if not landed: + refund_farm(farm["uid"], rules.FIGHT_COST_COINS) + _restore_cooldown(fighter["uid"], previous, now) + resolve_if_due(get_war(war["uid"])) + raise WarError("The battle ended before your attack landed.") + conditional_update_row( + "opinion_war_fighters", + fighter["uid"], + f"{side} = COALESCE({side}, 0) + :damage, fight_count = COALESCE(fight_count, 0) + 1", + "1 = 1", + {"damage": damage}, + ) + label = faction_label(war, faction) + fresh = get_war(war["uid"]) or war + allocate_event( + war["uid"], + "fight", + f"{user['username']} dealt {damage} HP for {label}", + { + "faction": faction, + "damage": damage, + "hp_a": int(fresh.get("hp_a") or 0), + "hp_b": int(fresh.get("hp_b") or 0), + }, + user["uid"], + ) + _claim_lead(fresh, user) + track_action(user["uid"], "battle_fight") + audit.record( + request, + "battle.fight", + user=user, + target_type="battle", + target_uid=war["uid"], + target_label=label, + metadata={"faction": faction, "damage": damage, "cost": rules.FIGHT_COST_COINS}, + summary=f"{user['username']} dealt {damage} HP for {label}", + links=[audit.target("battle", war["uid"], label), audit.parent("post", war["post_uid"])], + ) + return get_war(war["uid"]) or fresh, damage + + +def _restore_cooldown(fighter_uid: str, previous: str, claimed: str) -> None: + conditional_update_row( + "opinion_war_fighters", + fighter_uid, + "last_fight_at = :previous", + "last_fight_at = :claimed", + {"previous": previous, "claimed": claimed}, + ) + + +def _claim_lead(war: dict, user: dict) -> None: + new_leader = rules.leader_of(int(war.get("hp_a") or 0), int(war.get("hp_b") or 0)) + if not new_leader: + return + rows = conditional_update_row( + "opinion_wars", + war["uid"], + "leader = :leader", + "COALESCE(leader, '') != :leader AND status = 'active'", + {"leader": new_leader}, + ) + if not rows: + return + label = faction_label(war, new_leader) + allocate_event( + war["uid"], + "lead_change", + f"{label} took the lead!", + { + "faction": new_leader, + "hp_a": int(war.get("hp_a") or 0), + "hp_b": int(war.get("hp_b") or 0), + }, + user["uid"], + ) + background.submit( + _notify_fighters, + war["uid"], + f"{label} took the lead in an Opinion War you fight in", + user["uid"], + user["uid"], + ) + + +def _notify_fighters( + war_uid: str, message: str, related_uid: str | None, exclude_uid: str | None +) -> None: + war = get_war(war_uid) + if not war: + return + url = resolve_object_url("post", war["post_uid"]) + for row in _fighters().find(war_uid=war_uid, deleted_at=None): + recipient = row.get("user_uid") or "" + if not recipient or recipient == exclude_uid: + continue + create_notification( + recipient, "battle", message, related_uid or recipient, target_url=url + ) + + +def allocate_event( + war_uid: str, kind: str, message: str, payload: dict | None = None, actor_uid: str = "" +) -> dict: + uid = generate_uid() + created_at = _iso() + with db: + db.query( + "INSERT INTO opinion_war_events " + "(uid, war_uid, seq, kind, message, payload, actor_uid, created_at, deleted_at, deleted_by) " + "SELECT :uid, :war_uid, COALESCE(MAX(seq), 0) + 1, :kind, :message, :payload, " + ":actor_uid, :created_at, NULL, NULL " + "FROM opinion_war_events WHERE war_uid = :war_uid", + uid=uid, + war_uid=war_uid, + kind=kind, + message=message, + payload=json.dumps(payload or {}, ensure_ascii=False), + actor_uid=actor_uid or "", + created_at=created_at, + ) + row = _events().find_one(uid=uid) + return _event_dict(row) if row else { + "seq": 0, + "kind": kind, + "message": message, + "faction": (payload or {}).get("faction", ""), + "created_at": created_at, + } + + +def _event_dict(row: dict) -> dict: + try: + payload = json.loads(row.get("payload") or "{}") + except (TypeError, ValueError): + payload = {} + if not isinstance(payload, dict): + payload = {} + event = { + "seq": int(row.get("seq") or 0), + "kind": row.get("kind") or "", + "message": row.get("message") or "", + "faction": payload.get("faction", ""), + "created_at": row.get("created_at") or "", + } + for key in ("hp_a", "hp_b", "damage", "winner"): + if key in payload: + event[key] = payload[key] + return event + + +def events_for(war_uid: str, after_seq: int = 0, limit: int = rules.EVENT_LIMIT_DEFAULT) -> list[dict]: + capped = max(1, min(int(limit or 1), rules.EVENT_LIMIT_DEFAULT)) + rows = _events().find( + war_uid=war_uid, + seq={">": max(0, int(after_seq or 0))}, + deleted_at=None, + order_by=["seq"], + _limit=capped, + ) + return [_event_dict(dict(row)) for row in rows] + + +def resolve_if_due(war: dict | None) -> dict | None: + if not war or war.get("status") != "active": + return war + if not rules.is_ended(war.get("ends_at") or ""): + return war + return resolve_war(war) + + +def resolve_war(war: dict) -> dict: + rows = conditional_update_row( + "opinion_wars", + war["uid"], + "status = 'resolved', resolved_at = :now, " + "winner = CASE WHEN COALESCE(hp_a, 0) > COALESCE(hp_b, 0) THEN 'a' " + "WHEN COALESCE(hp_b, 0) > COALESCE(hp_a, 0) THEN 'b' ELSE 'draw' END", + "status = 'active' AND deleted_at IS NULL", + {"now": _iso()}, + ) + resolved = get_war(war["uid"]) or war + if rows: + _award_and_announce(resolved) + return resolved + + +def _award_and_announce(war: dict) -> None: + winner = war.get("winner") or "draw" + hp_a = int(war.get("hp_a") or 0) + hp_b = int(war.get("hp_b") or 0) + fighters = list(_fighters().find(war_uid=war["uid"], deleted_at=None)) + active = [row for row in fighters if int(row.get("fight_count") or 0) > 0] + for row in active: + award_rewards(row["user_uid"], XP_BATTLE_PART) + if winner in ("a", "b") and row.get("faction") == winner: + award_rewards(row["user_uid"], XP_BATTLE_WIN) + track_action(row["user_uid"], "battle_win") + if winner in ("a", "b") and active: + top = min( + active, + key=lambda row: ( + -(int(row.get("hp_a") or 0) + int(row.get("hp_b") or 0)), + int(row.get("id") or 0), + ), + ) + award_rewards(top["user_uid"], XP_BATTLE_TOP) + if winner == "a": + message = f"Battle over: {war['faction_a']} wins {hp_a} to {hp_b}" + elif winner == "b": + message = f"Battle over: {war['faction_b']} wins {hp_b} to {hp_a}" + else: + message = f"Battle over: a draw at {hp_a} HP each" + allocate_event( + war["uid"], "result", message, {"winner": winner, "hp_a": hp_a, "hp_b": hp_b}, "" + ) + background.submit(_notify_fighters, war["uid"], message, None, None) + audit.record_system( + "battle.resolve", + target_type="battle", + target_uid=war["uid"], + target_label=f"{war['faction_a']} vs {war['faction_b']}", + metadata={"winner": winner, "hp_a": hp_a, "hp_b": hp_b}, + summary=message, + links=[ + audit.target("battle", war["uid"], f"{war['faction_a']} vs {war['faction_b']}"), + audit.parent("post", war["post_uid"]), + ], + ) + + +def resolve_due_wars(limit: int = 25) -> int: + if "opinion_wars" not in db.tables: + return 0 + due = list( + _wars().find( + status="active", + ends_at={"<=": _iso()}, + deleted_at=None, + order_by=["ends_at"], + _limit=max(1, limit), + ) + ) + resolved = 0 + for war in due: + if resolve_war(dict(war)).get("status") == "resolved": + resolved += 1 + return resolved + + +def cooldown_ready_fighters(limit: int = 50) -> list[dict]: + if "opinion_war_fighters" not in db.tables: + return [] + rows = db.query( + "SELECT f.* FROM opinion_war_fighters f " + "JOIN opinion_wars w ON w.uid = f.war_uid " + "WHERE f.deleted_at IS NULL AND w.deleted_at IS NULL AND w.status = 'active' " + "AND COALESCE(f.last_fight_at, '') != '' AND f.last_fight_at <= :cutoff " + "AND COALESCE(f.cooldown_notified_at, '') != f.last_fight_at " + "LIMIT :limit", + cutoff=rules.cooldown_cutoff(), + limit=max(1, limit), + ) + return [dict(row) for row in rows] + + +def notify_cooldown_ready(fighter: dict) -> bool: + last = fighter.get("last_fight_at") or "" + rows = conditional_update_row( + "opinion_war_fighters", + fighter["uid"], + "cooldown_notified_at = :last", + "COALESCE(cooldown_notified_at, '') != :last AND last_fight_at = :last", + {"last": last}, + ) + if not rows: + return False + war = get_war(fighter.get("war_uid") or "") + if not war: + return True + create_notification( + fighter["user_uid"], + "battle", + "Your Fight is ready - return to the battle", + fighter["user_uid"], + target_url=resolve_object_url("post", war["post_uid"]), + ) + return True + + +def get_wars_by_post_uids(post_uids: list, user: dict | None = None) -> dict: + uids = [uid for uid in (post_uids or []) if uid] + if not uids or "opinion_wars" not in db.tables: + return {} + placeholders, params = _in_clause(uids) + wars = [ + dict(row) + for row in db.query( + f"SELECT * FROM opinion_wars WHERE post_uid IN ({placeholders}) " + "AND deleted_at IS NULL", + **params, + ) + ] + if not wars: + return {} + serialized = serialize_wars(wars, user) + return {item["post_uid"]: item for item in serialized} + + +def get_war_serialized(war: dict | None, user: dict | None = None) -> dict | None: + if not war: + return None + items = serialize_wars([dict(war)], user) + return items[0] if items else None + + +def get_war_serialized_for_post(post_uid: str, user: dict | None = None) -> dict | None: + return get_war_serialized(get_war_for_post(post_uid), user) + + +def serialize_wars(wars: list[dict], user: dict | None = None) -> list[dict]: + wars = [resolve_if_due(war) for war in wars] + war_uids = [war["uid"] for war in wars] + placeholders, params = _in_clause(war_uids) + fighters_by_war: dict[str, list[dict]] = {uid: [] for uid in war_uids} + if "opinion_war_fighters" in db.tables: + for row in db.query( + f"SELECT * FROM opinion_war_fighters WHERE war_uid IN ({placeholders}) " + "AND deleted_at IS NULL", + **params, + ): + fighters_by_war.setdefault(row["war_uid"], []).append(dict(row)) + events_by_war: dict[str, list[dict]] = {uid: [] for uid in war_uids} + if "opinion_war_events" in db.tables: + for row in db.query( + "SELECT * FROM (" + "SELECT e.*, ROW_NUMBER() OVER (PARTITION BY war_uid ORDER BY seq DESC) AS rn " + f"FROM opinion_war_events e WHERE war_uid IN ({placeholders}) " + "AND deleted_at IS NULL) WHERE rn <= :ticker", + **params, + ticker=rules.EVENT_TICKER_LIMIT, + ): + events_by_war.setdefault(row["war_uid"], []).append(dict(row)) + posts_by_uid: dict[str, dict] = {} + post_placeholders, post_params = _in_clause([war["post_uid"] for war in wars]) + if "posts" in db.tables: + for row in db.query( + f"SELECT uid, slug, title FROM posts WHERE uid IN ({post_placeholders}) " + "AND deleted_at IS NULL", + **post_params, + ): + posts_by_uid[row["uid"]] = dict(row) + user_uids = {war["user_uid"] for war in wars} + for rows in fighters_by_war.values(): + ranked = _ranked(rows) + for fighter in ranked[: rules.TOP_CONTRIBUTORS]: + user_uids.add(fighter["user_uid"]) + users = get_users_by_uids(list(user_uids)) + return [ + _serialize_war( + war, + _ranked(fighters_by_war.get(war["uid"], [])), + events_by_war.get(war["uid"], []), + posts_by_uid.get(war["post_uid"]), + users, + user, + ) + for war in wars + ] + + +def _ranked(fighters: list[dict]) -> list[dict]: + return sorted( + fighters, + key=lambda row: ( + -(int(row.get("hp_a") or 0) + int(row.get("hp_b") or 0)), + int(row.get("id") or 0), + ), + ) + + +def _person(users: dict, uid: str) -> dict: + row = users.get(uid) or {} + return { + "uid": uid, + "username": row.get("username") or "unknown", + "avatar_seed": row.get("avatar_seed"), + "level": int(row.get("level") or 1), + } + + +def _serialize_war( + war: dict, + ranked: list[dict], + event_rows: list[dict], + post: dict | None, + users: dict, + viewer: dict | None, +) -> dict: + hp_a = int(war.get("hp_a") or 0) + hp_b = int(war.get("hp_b") or 0) + pct_a, pct_b = rules.pct_split(hp_a, hp_b) + events = sorted((_event_dict(row) for row in event_rows), key=lambda e: -e["seq"]) + last_seq = events[0]["seq"] if events else 0 + status = war.get("status") or "active" + winner = war.get("winner") or "" + viewer_row = None + viewer_uid = (viewer or {}).get("uid") or "" + if viewer_uid: + for index, row in enumerate(ranked): + if row.get("user_uid") == viewer_uid: + viewer_row = { + "faction": row.get("faction") or "", + "hp": int(row.get("hp_a") or 0) + int(row.get("hp_b") or 0), + "rank": index + 1, + "fight_count": int(row.get("fight_count") or 0), + "last_fight_at": row.get("last_fight_at") or "", + "next_fight_at": rules.cooldown_ready_at(row.get("last_fight_at") or ""), + "can_fight": status == "active" + and rules.can_fight_at(row.get("last_fight_at") or ""), + } + break + top_contributors = [ + { + **_person(users, row["user_uid"]), + "faction": row.get("faction") or "", + "hp": int(row.get("hp_a") or 0) + int(row.get("hp_b") or 0), + } + for row in ranked[: rules.TOP_CONTRIBUTORS] + if int(row.get("hp_a") or 0) + int(row.get("hp_b") or 0) > 0 + ] + slug = (post or {}).get("slug") or war["post_uid"] + return { + "uid": war["uid"], + "post_uid": war["post_uid"], + "post_url": f"/posts/{slug}", + "post_title": (post or {}).get("title") or "", + "author": _person(users, war["user_uid"]), + "faction_a": war.get("faction_a") or "", + "faction_b": war.get("faction_b") or "", + "hp_a": hp_a, + "hp_b": hp_b, + "pct_a": pct_a, + "pct_b": pct_b, + "leader": war.get("leader") or "", + "fighter_count": len(ranked), + "status": status, + "winner": winner, + "winner_label": faction_label(war, winner) or "" if winner in ("a", "b") else "", + "created_at": war.get("created_at") or "", + "ends_at": war.get("ends_at") or "", + "ends_in": rules.ends_in_label(war.get("ends_at") or ""), + "resolved_at": war.get("resolved_at") or "", + "last_seq": last_seq, + "fight_cost": rules.FIGHT_COST_COINS, + "top_contributors": top_contributors, + "recent_events": events, + "viewer": viewer_row, + } + + +def list_wars( + *, + viewer: dict | None = None, + war_filter: str = "active", + search: str = "", + page: int = 1, + per_page: int = config.BATTLES_LIST_PER_PAGE, +) -> tuple[list[dict], dict]: + table = _wars() + resolve_due_wars() + clauses, filters = _list_clauses(table, viewer, war_filter, search) + if clauses is None: + return [], build_pagination(1, 0, per_page) + total = table.count(*clauses, deleted_at=None, **filters) + pagination = build_pagination(page, total, per_page) + offset = (pagination["page"] - 1) * pagination["per_page"] + rows = list( + table.find( + *clauses, + deleted_at=None, + order_by=["-created_at"], + _limit=pagination["per_page"], + _offset=offset, + **filters, + ) + ) + return serialize_wars([dict(row) for row in rows], viewer), pagination + + +def filter_counts(viewer: dict | None, search: str = "") -> dict[str, int]: + table = _wars() + counts: dict[str, int] = {} + for name in FILTERS: + clauses, filters = _list_clauses(table, viewer, name, search) + counts[name] = ( + 0 if clauses is None else table.count(*clauses, deleted_at=None, **filters) + ) + return counts + + +def _joined_war_uids(viewer_uid: str) -> list[str]: + return [ + row["war_uid"] + for row in _fighters().find(user_uid=viewer_uid, deleted_at=None) + ] + + +def _list_clauses(table, viewer, war_filter, search): + if not table.exists: + return None, {} + viewer_uid = (viewer or {}).get("uid", "") + columns = table.table.columns + clauses = [] + filters: dict = {} + if war_filter == "ended": + filters["status"] = "resolved" + elif war_filter == "mine": + if not viewer_uid: + return None, {} + joined = _joined_war_uids(viewer_uid) + own = columns.user_uid == viewer_uid + clauses.append(or_(own, columns.uid.in_(joined)) if joined else own) + else: + filters["status"] = "active" + if viewer_uid and war_filter != "mine": + blocked = get_blocked_uids(viewer_uid) + if blocked: + clauses.append(columns.user_uid.notin_(blocked)) + match = text_search_clause( + table, search, ("faction_a", "faction_b"), author_field="user_uid" + ) + if match is not None: + clauses.append(match) + return clauses, filters diff --git a/devplacepy/static/css/opinionwar.css b/devplacepy/static/css/opinionwar.css new file mode 100644 index 00000000..25754a9e --- /dev/null +++ b/devplacepy/static/css/opinionwar.css @@ -0,0 +1,714 @@ +:root { + --war-a-rgb: 66, 133, 244; + --war-a: rgb(var(--war-a-rgb)); + --war-b-rgb: 234, 67, 53; + --war-b: rgb(var(--war-b-rgb)); + --war-stone: #9b93ad; + --war-stone-dark: #5b5372; + --war-window: #ffd66b; + --war-door: #241b31; + --war-skin: #e8b98c; + --war-steel: #cfd6e4; + --war-flame: #ffb02e; + --war-flame-hot: #ff5a1f; + --war-wood: #7a4a2b; + --war-ground-top: #35502f; + --war-ground-deep: #22371f; + --war-sky-top: #120c26; + --war-sky-deep: #322357; + --war-leg: #2c2440; + --war-gold: #f4c542; +} + +dp-opinion-war { + display: block; +} + +.war-card { + position: relative; + z-index: 1; + margin: var(--space-md) 0; + padding: var(--space-md); + border: 1px solid var(--border-light); + border-radius: var(--radius-lg); + background: var(--bg-secondary); +} + +.war-head { + display: flex; + align-items: center; + justify-content: space-between; + gap: var(--space-sm); + margin-bottom: var(--space-md); +} + +.war-head-title { + font-family: var(--font-mono); + font-weight: 700; + text-transform: uppercase; + letter-spacing: 0.18em; + color: var(--accent-light); +} + +.war-countdown { + font-family: var(--font-mono); + font-size: 0.8rem; + color: var(--text-secondary); +} + +.war-bars { + display: grid; + grid-template-columns: minmax(0, 1fr) auto minmax(0, 1fr); + align-items: center; + gap: var(--space-md); + margin-bottom: var(--space-md); +} + +.war-side { + display: flex; + flex-direction: column; + gap: var(--space-xs); + min-width: 0; +} + +.war-side-b { + text-align: right; +} + +.war-side-name { + font-weight: 700; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.war-side-a .war-side-name { + color: var(--war-a); +} + +.war-side-b .war-side-name { + color: var(--war-b); +} + +.war-vs { + font-family: var(--font-mono); + font-weight: 700; + font-size: 1.1rem; + color: var(--war-gold); +} + +.war-bar { + position: relative; + height: 20px; + border: 1px solid var(--border-light); + border-radius: 4px; + background: var(--bg-input); + overflow: hidden; + font-family: var(--font-mono); + font-size: 0.75rem; +} + +.war-bar-fill { + position: absolute; + inset: 0; + width: var(--war-pct, 0%); + transition: width 0.4s ease; +} + +.war-bar-a .war-bar-fill { + background: rgba(var(--war-a-rgb), 0.55); +} + +.war-bar-b .war-bar-fill { + left: auto; + right: 0; + background: rgba(var(--war-b-rgb), 0.55); +} + +.war-bar-pct { + position: absolute; + top: 50%; + transform: translateY(-50%); + color: var(--text-primary); + z-index: 1; +} + +.war-bar-a .war-bar-pct { + left: var(--space-sm); +} + +.war-bar-b .war-bar-pct { + right: var(--space-sm); +} + +.war-side-hp { + font-family: var(--font-mono); + font-size: 0.8rem; + color: var(--text-secondary); +} + +.war-field { + --px: 3px; + position: relative; + display: flex; + align-items: flex-end; + justify-content: space-between; + gap: var(--space-sm); + height: 96px; + padding: 0 var(--space-md) 12px; + border-radius: var(--radius); + background: linear-gradient(var(--war-sky-top), var(--war-sky-deep)); + overflow: hidden; + margin-bottom: var(--space-md); +} + +.war-ground { + position: absolute; + left: 0; + right: 0; + bottom: 0; + height: 10px; + background: linear-gradient(var(--war-ground-top), var(--war-ground-deep)); +} + +.war-px { + position: absolute; + top: 0; + left: 0; + width: var(--px); + height: var(--px); +} + +.war-castle { + position: relative; + z-index: 1; + width: calc(var(--px) * 5); + height: calc(var(--px) * 8); + flex-shrink: 0; +} + +.war-castle-b { + transform: scaleX(-1); +} + +.war-castle-px { + background: var(--war-stone-dark); + box-shadow: + calc(var(--px) * 2) 0 0 0 var(--war-stone-dark), + calc(var(--px) * 4) 0 0 0 var(--war-stone-dark), + 0 var(--px) 0 0 var(--war-stone-dark), + var(--px) var(--px) 0 0 var(--war-stone-dark), + calc(var(--px) * 2) var(--px) 0 0 var(--war-stone-dark), + calc(var(--px) * 3) var(--px) 0 0 var(--war-stone-dark), + calc(var(--px) * 4) var(--px) 0 0 var(--war-stone-dark), + 0 calc(var(--px) * 2) 0 0 var(--war-stone-dark), + var(--px) calc(var(--px) * 2) 0 0 var(--war-stone), + calc(var(--px) * 2) calc(var(--px) * 2) 0 0 var(--war-stone), + calc(var(--px) * 3) calc(var(--px) * 2) 0 0 var(--war-stone), + calc(var(--px) * 4) calc(var(--px) * 2) 0 0 var(--war-stone-dark), + 0 calc(var(--px) * 3) 0 0 var(--war-stone-dark), + var(--px) calc(var(--px) * 3) 0 0 var(--war-stone), + calc(var(--px) * 2) calc(var(--px) * 3) 0 0 var(--war-window), + calc(var(--px) * 3) calc(var(--px) * 3) 0 0 var(--war-stone), + calc(var(--px) * 4) calc(var(--px) * 3) 0 0 var(--war-stone-dark), + 0 calc(var(--px) * 4) 0 0 var(--war-stone-dark), + var(--px) calc(var(--px) * 4) 0 0 var(--war-stone), + calc(var(--px) * 2) calc(var(--px) * 4) 0 0 var(--war-stone), + calc(var(--px) * 3) calc(var(--px) * 4) 0 0 var(--war-stone), + calc(var(--px) * 4) calc(var(--px) * 4) 0 0 var(--war-stone-dark), + 0 calc(var(--px) * 5) 0 0 var(--war-stone-dark), + var(--px) calc(var(--px) * 5) 0 0 var(--war-stone), + calc(var(--px) * 2) calc(var(--px) * 5) 0 0 var(--war-stone), + calc(var(--px) * 3) calc(var(--px) * 5) 0 0 var(--war-stone), + calc(var(--px) * 4) calc(var(--px) * 5) 0 0 var(--war-stone-dark), + 0 calc(var(--px) * 6) 0 0 var(--war-stone-dark), + var(--px) calc(var(--px) * 6) 0 0 var(--war-stone), + calc(var(--px) * 2) calc(var(--px) * 6) 0 0 var(--war-door), + calc(var(--px) * 3) calc(var(--px) * 6) 0 0 var(--war-stone), + calc(var(--px) * 4) calc(var(--px) * 6) 0 0 var(--war-stone-dark), + 0 calc(var(--px) * 7) 0 0 var(--war-stone-dark), + var(--px) calc(var(--px) * 7) 0 0 var(--war-stone), + calc(var(--px) * 2) calc(var(--px) * 7) 0 0 var(--war-door), + calc(var(--px) * 3) calc(var(--px) * 7) 0 0 var(--war-stone), + calc(var(--px) * 4) calc(var(--px) * 7) 0 0 var(--war-stone-dark); +} + +.war-flag { + top: calc(var(--px) * -4); + left: calc(var(--px) * 2); + background: var(--war-stone-dark); + box-shadow: + 0 var(--px) 0 0 var(--war-stone-dark), + 0 calc(var(--px) * 2) 0 0 var(--war-stone-dark), + 0 calc(var(--px) * 3) 0 0 var(--war-stone-dark), + var(--px) 0 0 0 var(--war-flag-color), + calc(var(--px) * 2) 0 0 0 var(--war-flag-color), + var(--px) var(--px) 0 0 var(--war-flag-color); +} + +.war-flag-a { + --war-flag-color: var(--war-a); +} + +.war-flag-b { + --war-flag-color: var(--war-b); +} + +.war-troops { + position: relative; + z-index: 1; + display: flex; + gap: var(--space-sm); + flex-shrink: 1; + min-width: 0; + transition: transform 0.6s ease; +} + +.war-field-lead-a .war-troops-a { + transform: translateX(calc(var(--px) * 2)); +} + +.war-field-lead-b .war-troops-b { + transform: translateX(calc(var(--px) * -2)); +} + +.war-soldier { + position: relative; + display: block; + width: calc(var(--px) * 6); + height: calc(var(--px) * 7); + animation: war-march 1.2s steps(1, end) infinite; +} + +.war-soldier:nth-child(2) { + animation-delay: 0.4s; +} + +.war-soldier:nth-child(3) { + animation-delay: 0.8s; +} + +.war-soldier:nth-child(4) { + animation-delay: 0.2s; +} + +.war-soldier-a { + --war-soldier-main: var(--war-a); +} + +.war-soldier-b { + --war-soldier-main: var(--war-b); + transform: scaleX(-1); +} + +.war-soldier-px { + background: transparent; + box-shadow: + var(--px) 0 0 0 var(--war-soldier-main), + calc(var(--px) * 2) 0 0 0 var(--war-soldier-main), + calc(var(--px) * 3) 0 0 0 var(--war-soldier-main), + var(--px) var(--px) 0 0 var(--war-skin), + calc(var(--px) * 2) var(--px) 0 0 var(--war-skin), + calc(var(--px) * 3) var(--px) 0 0 var(--war-skin), + calc(var(--px) * 5) var(--px) 0 0 var(--war-steel), + 0 calc(var(--px) * 2) 0 0 var(--war-soldier-main), + var(--px) calc(var(--px) * 2) 0 0 var(--war-soldier-main), + calc(var(--px) * 2) calc(var(--px) * 2) 0 0 var(--war-soldier-main), + calc(var(--px) * 3) calc(var(--px) * 2) 0 0 var(--war-soldier-main), + calc(var(--px) * 4) calc(var(--px) * 2) 0 0 var(--war-soldier-main), + calc(var(--px) * 5) calc(var(--px) * 2) 0 0 var(--war-steel), + var(--px) calc(var(--px) * 3) 0 0 var(--war-soldier-main), + calc(var(--px) * 2) calc(var(--px) * 3) 0 0 var(--war-soldier-main), + calc(var(--px) * 3) calc(var(--px) * 3) 0 0 var(--war-soldier-main), + calc(var(--px) * 4) calc(var(--px) * 3) 0 0 var(--war-skin), + calc(var(--px) * 5) calc(var(--px) * 3) 0 0 var(--war-steel), + var(--px) calc(var(--px) * 4) 0 0 var(--war-soldier-main), + calc(var(--px) * 2) calc(var(--px) * 4) 0 0 var(--war-soldier-main), + calc(var(--px) * 3) calc(var(--px) * 4) 0 0 var(--war-soldier-main), + var(--px) calc(var(--px) * 5) 0 0 var(--war-leg), + calc(var(--px) * 3) calc(var(--px) * 5) 0 0 var(--war-leg), + var(--px) calc(var(--px) * 6) 0 0 var(--war-leg), + calc(var(--px) * 3) calc(var(--px) * 6) 0 0 var(--war-leg); +} + +.war-campfire { + position: relative; + z-index: 1; + width: calc(var(--px) * 5); + height: calc(var(--px) * 5); + flex-shrink: 0; +} + +.war-fire-logs { + background: transparent; + box-shadow: + var(--px) calc(var(--px) * 3) 0 0 var(--war-wood), + calc(var(--px) * 2) calc(var(--px) * 3) 0 0 var(--war-wood), + calc(var(--px) * 3) calc(var(--px) * 3) 0 0 var(--war-wood), + 0 calc(var(--px) * 4) 0 0 var(--war-wood), + var(--px) calc(var(--px) * 4) 0 0 var(--war-wood), + calc(var(--px) * 2) calc(var(--px) * 4) 0 0 var(--war-wood), + calc(var(--px) * 3) calc(var(--px) * 4) 0 0 var(--war-wood), + calc(var(--px) * 4) calc(var(--px) * 4) 0 0 var(--war-wood); +} + +.war-fire-flame { + background: transparent; + animation: war-flicker 0.8s steps(1, end) infinite; + box-shadow: + calc(var(--px) * 2) 0 0 0 var(--war-flame-hot), + var(--px) var(--px) 0 0 var(--war-flame), + calc(var(--px) * 3) var(--px) 0 0 var(--war-flame), + var(--px) calc(var(--px) * 2) 0 0 var(--war-flame), + calc(var(--px) * 2) calc(var(--px) * 2) 0 0 var(--war-flame-hot), + calc(var(--px) * 3) calc(var(--px) * 2) 0 0 var(--war-flame); +} + +.war-victory { + display: flex; + align-items: center; + justify-content: center; + padding: var(--space-md); + margin-bottom: var(--space-md); + border: 1px solid var(--war-gold); + border-radius: var(--radius); + background: rgba(var(--accent-rgb), 0.12); +} + +.war-victory-title { + font-family: var(--font-mono); + font-weight: 700; + color: var(--war-gold); +} + +.war-mine { + display: flex; + align-items: center; + justify-content: space-between; + gap: var(--space-sm); + padding: var(--space-sm) var(--space-md); + margin-bottom: var(--space-md); + border: 1px solid var(--border); + border-radius: var(--radius); + background: var(--bg-card); +} + +.war-mine-faction { + font-weight: 700; +} + +.war-tag-a { + color: var(--war-a); +} + +.war-tag-b { + color: var(--war-b); +} + +.war-mine-stats { + font-family: var(--font-mono); + font-size: 0.8rem; + color: var(--text-secondary); +} + +.war-actions { + display: flex; + flex-wrap: wrap; + align-items: center; + gap: var(--space-sm); + margin-bottom: var(--space-md); +} + +.war-join-btn.war-join-a { + border-color: rgba(var(--war-a-rgb), 0.6); +} + +.war-join-btn.war-join-b { + border-color: rgba(var(--war-b-rgb), 0.6); +} + +.war-fight-btn[disabled] { + opacity: 0.6; + cursor: not-allowed; +} + +.war-block-label { + display: block; + font-size: 0.72rem; + font-weight: 700; + text-transform: uppercase; + letter-spacing: 0.12em; + color: var(--text-muted); + margin-bottom: var(--space-xs); +} + +.war-contributors { + margin-bottom: var(--space-md); +} + +.war-contributor-list { + list-style: none; + margin: 0; + padding: 0; + display: flex; + flex-direction: column; + gap: var(--space-xs); +} + +.war-contributor { + display: flex; + align-items: center; + gap: var(--space-sm); + padding: var(--space-xs) var(--space-sm); + border: 1px solid var(--border); + border-radius: var(--radius); + background: var(--bg-card); +} + +.war-contributor-hp { + margin-left: auto; + font-family: var(--font-mono); + font-size: 0.8rem; +} + +.war-text-a { + color: var(--war-a); +} + +.war-text-b { + color: var(--war-b); +} + +.war-events { + margin-bottom: var(--space-md); +} + +.war-ticker { + list-style: none; + margin: 0; + padding: 0; + display: flex; + flex-direction: column; + gap: var(--space-xs); +} + +.war-event { + display: flex; + align-items: center; + gap: var(--space-sm); + padding: var(--space-xs) var(--space-sm); + border: 1px solid var(--border); + border-radius: var(--radius); + background: var(--bg-card); + font-size: 0.85rem; + min-width: 0; +} + +.war-event-empty { + color: var(--text-muted); +} + +.war-event-dot { + flex-shrink: 0; + width: 8px; + height: 8px; + background: var(--text-muted); +} + +.war-dot-a { + background: var(--war-a); +} + +.war-dot-b { + background: var(--war-b); +} + +.war-event-message { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.war-event-time { + margin-left: auto; + flex-shrink: 0; + font-size: 0.72rem; + color: var(--text-muted); +} + +.war-foot { + display: flex; + align-items: center; + justify-content: space-between; + gap: var(--space-sm); +} + +.war-all-link { + font-weight: 600; + color: var(--accent-light); +} + +.war-foot-btn { + display: inline-flex; + align-items: center; + gap: var(--space-xs); + padding: var(--space-xs) var(--space-sm); + border: none; + border-radius: var(--radius); + background: transparent; + color: var(--text-muted); + cursor: pointer; + font-size: 0.8rem; +} + +.war-foot-btn:hover { + color: var(--text-primary); + background: var(--bg-card-hover); +} + +@keyframes war-march { + 0%, + 100% { + transform: translateY(0); + } + + 50% { + transform: translateY(calc(var(--px) * -1)); + } +} + +@keyframes war-flicker { + 0%, + 100% { + box-shadow: + calc(var(--px) * 2) 0 0 0 var(--war-flame-hot), + var(--px) var(--px) 0 0 var(--war-flame), + calc(var(--px) * 3) var(--px) 0 0 var(--war-flame), + var(--px) calc(var(--px) * 2) 0 0 var(--war-flame), + calc(var(--px) * 2) calc(var(--px) * 2) 0 0 var(--war-flame-hot), + calc(var(--px) * 3) calc(var(--px) * 2) 0 0 var(--war-flame); + } + + 50% { + box-shadow: + var(--px) 0 0 0 var(--war-flame), + calc(var(--px) * 2) var(--px) 0 0 var(--war-flame-hot), + calc(var(--px) * 3) 0 0 0 var(--war-flame), + var(--px) calc(var(--px) * 2) 0 0 var(--war-flame-hot), + calc(var(--px) * 2) calc(var(--px) * 2) 0 0 var(--war-flame), + calc(var(--px) * 3) calc(var(--px) * 2) 0 0 var(--war-flame); + } +} + +.war-soldier-b.war-soldier { + animation-name: war-march-b; +} + +@keyframes war-march-b { + 0%, + 100% { + transform: scaleX(-1) translateY(0); + } + + 50% { + transform: scaleX(-1) translateY(calc(var(--px) * -1)); + } +} + +.war-filter-count { + margin-left: auto; + font-family: var(--font-mono); + font-size: 0.75rem; + color: var(--text-muted); +} + +.war-listing-head { + display: flex; + align-items: baseline; + justify-content: space-between; + gap: var(--space-sm); + flex-wrap: wrap; +} + +.war-listing-meta { + font-size: 0.8rem; + color: var(--text-muted); +} + +.war-builder { + margin: var(--space-sm) 0; + padding: var(--space-md); + border: 1px dashed var(--border-light); + border-radius: var(--radius); +} + +.war-builder[hidden] { + display: none; +} + +.war-builder-hint { + margin: 0 0 var(--space-sm); + font-size: 0.82rem; + color: var(--text-secondary); +} + +.war-builder-row { + display: flex; + align-items: center; + gap: var(--space-sm); +} + +.war-builder-row input { + flex: 1; + min-width: 0; +} + +.war-builder-vs { + font-family: var(--font-mono); + font-weight: 700; + color: var(--war-gold); +} + +.war-builder-error { + margin: var(--space-sm) 0 0; + color: var(--danger); + font-size: 0.82rem; +} + +@media (max-width: 768px) { + .war-field { + --px: 2px; + height: 76px; + } +} + +@media (max-width: 480px) { + .war-bars { + gap: var(--space-sm); + } + + .war-vs { + font-size: 0.9rem; + } + + .war-bar-pct { + display: none; + } + + .war-builder-row { + flex-direction: column; + align-items: stretch; + } +} + +@media (prefers-reduced-motion: reduce) { + .war-soldier, + .war-fire-flame { + animation: none; + } + + .war-bar-fill, + .war-troops { + transition: none; + } +} diff --git a/devplacepy/static/js/Application.js b/devplacepy/static/js/Application.js index 228382b6..4c7744b7 100644 --- a/devplacepy/static/js/Application.js +++ b/devplacepy/static/js/Application.js @@ -15,6 +15,7 @@ import { CounterManager } from "./CounterManager.js"; import { ReactionBar } from "./ReactionBar.js"; import { BookmarkManager } from "./BookmarkManager.js"; import { PollManager } from "./PollManager.js"; +import { WarComposer } from "./WarComposer.js"; import { ApiKeyManager } from "./ApiKeyManager.js"; import { AvatarRegenerator } from "./AvatarRegenerator.js"; import { CustomizationToggle } from "./CustomizationToggle.js"; @@ -87,6 +88,7 @@ class Application { this.reactions = new ReactionBar(); this.bookmarks = new BookmarkManager(); this.polls = new PollManager(); + this.warComposer = new WarComposer(); this.apiKey = new ApiKeyManager(); this.avatarRegenerator = new AvatarRegenerator(); this.customizationToggle = new CustomizationToggle(); diff --git a/devplacepy/static/js/WarComposer.js b/devplacepy/static/js/WarComposer.js new file mode 100644 index 00000000..4bc6d760 --- /dev/null +++ b/devplacepy/static/js/WarComposer.js @@ -0,0 +1,106 @@ +// retoor + +export class WarComposer { + constructor() { + document.addEventListener("click", (event) => this.onClick(event)); + document.addEventListener("submit", (event) => this.onSubmit(event), true); + } + + onClick(event) { + const toggle = event.target.closest("[data-war-toggle]"); + if (toggle) { + event.preventDefault(); + this.toggleBuilder(toggle); + return; + } + const pollToggle = event.target.closest("[data-poll-toggle]"); + if (pollToggle) { + this.closeWhenPollOpens(pollToggle); + } + } + + toggleBuilder(toggle) { + const form = toggle.closest("form"); + const builder = form ? form.querySelector("[data-war-builder]") : null; + if (!builder) { + return; + } + const activating = builder.hidden; + if (activating) { + this.closePollBuilder(form); + } + builder.hidden = !activating; + this.setWarEnabled(builder, activating); + const label = toggle.querySelector("[data-war-toggle-label]"); + if (label) { + label.textContent = activating ? "Remove Opinion War" : "Start Opinion War"; + } + } + + closePollBuilder(form) { + const pollBuilder = form.querySelector("[data-poll-builder]"); + const pollToggle = form.querySelector("[data-poll-toggle]"); + if (pollBuilder && pollToggle && !pollBuilder.hidden) { + pollToggle.click(); + } + } + + closeWhenPollOpens(pollToggle) { + const form = pollToggle.closest("form"); + const builder = form ? form.querySelector("[data-war-builder]") : null; + const toggle = form ? form.querySelector("[data-war-toggle]") : null; + if (!builder || !toggle || builder.hidden) { + return; + } + builder.hidden = true; + this.setWarEnabled(builder, false); + const label = toggle.querySelector("[data-war-toggle-label]"); + if (label) { + label.textContent = "Start Opinion War"; + } + } + + setWarEnabled(builder, enabled) { + builder.querySelectorAll("input[name='war_faction_a'], input[name='war_faction_b']").forEach((input) => { + input.disabled = !enabled; + if (!enabled) { + input.value = ""; + } + }); + const error = builder.querySelector("[data-war-error]"); + if (error) { + error.hidden = true; + error.textContent = ""; + } + } + + onSubmit(event) { + const form = event.target; + if (!form || typeof form.querySelector !== "function") { + return; + } + const builder = form.querySelector("[data-war-builder]"); + if (!builder || builder.hidden) { + return; + } + const factionA = form.querySelector("input[name='war_faction_a']"); + const factionB = form.querySelector("input[name='war_faction_b']"); + const nameA = factionA ? factionA.value.trim() : ""; + const nameB = factionB ? factionB.value.trim() : ""; + let problem = ""; + if (!nameA || !nameB) { + problem = "Name both factions, or remove the Opinion War."; + } else if (nameA.toLowerCase() === nameB.toLowerCase()) { + problem = "The two factions need different names."; + } + if (problem) { + event.preventDefault(); + event.stopImmediatePropagation(); + const error = builder.querySelector("[data-war-error]"); + if (error) { + error.textContent = problem; + error.hidden = false; + } + } + } +} diff --git a/devplacepy/static/js/components/AppOpinionWar.js b/devplacepy/static/js/components/AppOpinionWar.js new file mode 100644 index 00000000..439e6c6b --- /dev/null +++ b/devplacepy/static/js/components/AppOpinionWar.js @@ -0,0 +1,254 @@ +// retoor + +import { Component } from "./Component.js"; +import { Http } from "../Http.js"; +import { Poller } from "../Poller.js"; + +const POLL_INTERVAL_MS = 15000; +const COUNTDOWN_INTERVAL_MS = 30000; +const TICKER_CAP = 5; + +export class AppOpinionWar extends Component { + connectedCallback() { + this._uid = this.attr("uid"); + this._topic = this.attr("topic"); + this._lastSeq = this.intAttr("seq", 0); + this._endsAt = this.attr("ends-at"); + this._status = this.attr("status", "active"); + this._countdown = this.querySelector("[data-war-countdown]"); + this._ticker = this.querySelector("[data-war-ticker]"); + this._victory = this.querySelector("[data-war-victory]"); + this._victoryTitle = this.querySelector("[data-war-victory-title]"); + this._actions = this.querySelector("[data-war-actions]"); + this._field = this.querySelector("[data-war-field]"); + this._subscribed = false; + this._onSubmitBound = (event) => this._onSubmit(event); + this.addEventListener("submit", this._onSubmitBound); + if (this._status === "active") { + this._subscribe(); + this._poller = new Poller(() => this._poll(), POLL_INTERVAL_MS, { immediate: false, pauseHidden: true }); + this._timer = window.setInterval(() => this._tickCountdown(), COUNTDOWN_INTERVAL_MS); + this._tickCountdown(); + } + } + + disconnectedCallback() { + this._teardown(); + this.removeEventListener("submit", this._onSubmitBound); + } + + _teardown() { + if (this._poller) { + this._poller.stop(); + this._poller = null; + } + if (this._timer) { + window.clearInterval(this._timer); + this._timer = null; + } + if (this._subscribed && window.app && window.app.pubsub) { + window.app.pubsub.unsubscribe(this._topic, this._onFrame); + this._subscribed = false; + } + } + + _subscribe() { + const app = window.app; + if (!this._topic || !app || !app.pubsub || typeof app.pubsub.subscribe !== "function") return; + this._onFrame = (frame) => this._apply(frame); + app.pubsub.subscribe(this._topic, this._onFrame); + this._subscribed = true; + } + + async _poll() { + if (this._status !== "active") return; + let payload; + try { + payload = await Http.getJson(`/battles/${this._uid}/events?after=${this._lastSeq}`); + } catch (error) { + return; + } + (payload.events || []).forEach((event) => this._apply(event)); + if (payload.status === "resolved" && this._status === "active") { + this._refreshState(); + } + } + + _apply(event) { + if (!event || typeof event.seq !== "number") return; + if (event.seq > 0 && event.seq <= this._lastSeq) return; + if (event.seq > 0) this._lastSeq = event.seq; + if (typeof event.hp_a === "number" && typeof event.hp_b === "number") { + this._renderTotals(event.hp_a, event.hp_b); + } + this._prependEvent(event); + if (event.kind === "result") { + this._refreshState(); + } + } + + async _refreshState() { + let war; + try { + war = await Http.getJson(`/battles/${this._uid}`); + } catch (error) { + return; + } + this._renderWar(war); + } + + async _onSubmit(event) { + const form = event.target.closest("form[data-war-action]"); + if (!form || !this.contains(form)) return; + event.preventDefault(); + event.stopPropagation(); + const action = form.dataset.warAction; + const confirmText = form.dataset.warConfirm; + if (confirmText && window.app && window.app.dialog) { + const accepted = await window.app.dialog.confirm({ message: confirmText }); + if (!accepted) return; + } + const button = form.querySelector("button[type=submit]"); + if (button) button.disabled = true; + const params = {}; + new FormData(form).forEach((value, key) => { + params[key] = value; + }); + try { + const result = await Http.send(form.getAttribute("action"), params); + const war = result && result.data ? result.data.war : null; + if (action === "fight" && war) { + this._renderWar(war); + this._toast(`You dealt ${result.data.damage} HP!`); + } else { + window.location.reload(); + } + } catch (error) { + this._toast(String(error && error.message ? error.message : error)); + if (button) button.disabled = false; + } + } + + _toast(message) { + if (window.app && window.app.toast && typeof window.app.toast.show === "function") { + window.app.toast.show(message, { type: "info" }); + } + } + + _renderTotals(hpA, hpB) { + const total = Math.max(0, hpA) + Math.max(0, hpB); + const pctA = total ? Math.round((Math.max(0, hpA) * 100) / total) : 50; + const pctB = total ? 100 - pctA : 50; + this._setText("[data-war-hp-a]", hpA.toLocaleString()); + this._setText("[data-war-hp-b]", hpB.toLocaleString()); + this._setText("[data-war-pct-a]", `${pctA}%`); + this._setText("[data-war-pct-b]", `${pctB}%`); + const barA = this.querySelector("[data-war-bar-a]"); + const barB = this.querySelector("[data-war-bar-b]"); + if (barA) barA.style.setProperty("--war-pct", `${pctA}%`); + if (barB) barB.style.setProperty("--war-pct", `${pctB}%`); + if (this._field) { + this._field.classList.toggle("war-field-lead-a", hpA > hpB); + this._field.classList.toggle("war-field-lead-b", hpB > hpA); + } + } + + _setText(selector, value) { + const node = this.querySelector(selector); + if (node) node.textContent = value; + } + + _renderTicker(events) { + if (!this._ticker || !events.length) return; + this._ticker.textContent = ""; + events.slice(0, TICKER_CAP).forEach((event) => { + this._ticker.appendChild(this._buildEvent(event, "")); + }); + } + + _buildEvent(event, timeLabel) { + const item = document.createElement("li"); + item.className = `war-event war-event-${event.kind}`; + const dot = document.createElement("span"); + dot.className = `war-event-dot war-dot-${event.faction || "n"}`; + dot.setAttribute("aria-hidden", "true"); + const message = document.createElement("span"); + message.className = "war-event-message"; + message.textContent = event.message; + item.append(dot, message); + if (timeLabel) { + const time = document.createElement("span"); + time.className = "war-event-time"; + time.textContent = timeLabel; + item.appendChild(time); + } + return item; + } + + _prependEvent(event) { + if (!this._ticker || !event.message) return; + const empty = this._ticker.querySelector(".war-event-empty"); + if (empty) empty.remove(); + this._ticker.prepend(this._buildEvent(event, "just now")); + while (this._ticker.children.length > TICKER_CAP) { + this._ticker.removeChild(this._ticker.lastChild); + } + } + + _renderWar(war) { + if (!war || !war.uid) return; + this._renderTotals(war.hp_a, war.hp_b); + if (typeof war.last_seq === "number" && war.last_seq > this._lastSeq) { + this._lastSeq = war.last_seq; + this._renderTicker(war.recent_events || []); + } + if (war.viewer) { + this._setText("[data-war-mine-hp]", war.viewer.hp.toLocaleString()); + const fight = this.querySelector("[data-war-fight]"); + if (fight) { + fight.disabled = !war.viewer.can_fight || war.status !== "active"; + fight.textContent = war.viewer.can_fight + ? `Fight (${war.fight_cost} coins)` + : "On cooldown"; + } + } + if (war.status === "resolved" && this._status === "active") { + this._finishResolved(war); + } + if (war.ends_at) this._endsAt = war.ends_at; + } + + _finishResolved(war) { + this._status = "resolved"; + this._teardown(); + if (this._actions) this._actions.hidden = true; + if (this._countdown) this._countdown.textContent = "Battle ended"; + if (this._victoryTitle) { + this._victoryTitle.textContent = + war.winner === "draw" + ? `It's a draw at ${war.hp_a.toLocaleString()} HP each` + : `${war.winner_label} wins the war!`; + } + if (this._victory) this._victory.hidden = false; + } + + _tickCountdown() { + if (!this._countdown || this._status !== "active") return; + const ends = Date.parse(this._endsAt); + if (Number.isNaN(ends)) return; + const remaining = ends - Date.now(); + if (remaining <= 0) { + this._countdown.textContent = "Battle ended"; + this._refreshState(); + return; + } + const minutes = Math.floor(remaining / 60000); + const days = Math.floor(minutes / 1440); + const hours = Math.floor((minutes % 1440) / 60); + const mins = minutes % 60; + const label = days ? `${days}d ${hours}h ${mins}m` : hours ? `${hours}h ${mins}m` : `${Math.max(mins, 1)}m`; + this._countdown.textContent = `Battle ends in ${label}`; + } +} + +customElements.define("dp-opinion-war", AppOpinionWar); diff --git a/devplacepy/static/js/components/index.js b/devplacepy/static/js/components/index.js index c292254e..ccea1dd1 100644 --- a/devplacepy/static/js/components/index.js +++ b/devplacepy/static/js/components/index.js @@ -15,4 +15,5 @@ import "./AppIsslopRun.js"; import "./AppChat.js"; import "./AppQuizPlayer.js"; import "./AppQuizBuilder.js"; +import "./AppOpinionWar.js"; import "./ContainerTerminal.js"; diff --git a/devplacepy/templates/_opinion_war.html b/devplacepy/templates/_opinion_war.html new file mode 100644 index 00000000..f81ec3e7 --- /dev/null +++ b/devplacepy/templates/_opinion_war.html @@ -0,0 +1,95 @@ + +
+ Opinion War + {% if _war.status == 'active' %}Battle ends in {{ _war.ends_in }}{% else %}Battle ended{% endif %} +
+ +
+
+ {{ render_title(_war.faction_a) }} +
{{ _war.pct_a }}%
+ {{ "{:,}".format(_war.hp_a) }} HP +
+ +
+ {{ render_title(_war.faction_b) }} +
{{ _war.pct_b }}%
+ {{ "{:,}".format(_war.hp_b) }} HP +
+
+ + {% include "_opinion_war_field.html" %} + +
+ + {%- if _war.winner == 'draw' -%} + It's a draw at {{ "{:,}".format(_war.hp_a) }} HP each + {%- elif _war.winner_label -%} + {{ _war.winner_label }} wins the war! + {%- endif -%} + +
+ + {% if _war.viewer %} +
+ {{ render_title(_war.viewer.faction == 'a' and _war.faction_a or _war.faction_b) }} + Rank #{{ _war.viewer.rank }} · {{ "{:,}".format(_war.viewer.hp) }} HP dealt +
+ {% endif %} + + {% if _war.status == 'active' %} +
+ {% if not _war.viewer %} +
+ + +
+
+ + +
+ {% else %} +
+ +
+
+ + +
+ {% endif %} +
+ {% endif %} + + {% if _war.top_contributors %} +
+ Top contributors +
    + {% for fighter in _war.top_contributors %} +
  • + {% set _user = fighter %}{% set _size = 24 %}{% set _size_class = "sm" %}{% include "_avatar_link.html" %} + {% set _user = fighter %}{% include "_user_link.html" %} + {{ "{:,}".format(fighter.hp) }} HP +
    • + {% endfor %} +
+
+ {% endif %} + +
+ Live events +
    + {% for e in _war.recent_events %} +
  • {{ e.message }}{{ dt_ago(e.created_at) }}
    • + {% else %} +
  • No battle activity yet - be the first to fight!
    • + {% endfor %} +
+
+ +
+ View All Battles + {% set _type = "battle" %}{% set _uid = _war.uid %}{% set _owner = _war.author.uid %}{% set _owner_name = _war.author.username %}{% set _class = "war-foot-btn" %}{% include "_report_button.html" %} +
+ diff --git a/devplacepy/templates/_opinion_war_field.html b/devplacepy/templates/_opinion_war_field.html new file mode 100644 index 00000000..9ef255d8 --- /dev/null +++ b/devplacepy/templates/_opinion_war_field.html @@ -0,0 +1,14 @@ +{% set _strength_a = 1 + (_war.pct_a // 30) %} +{% set _strength_b = 1 + (_war.pct_b // 30) %} + diff --git a/devplacepy/templates/_post_card.html b/devplacepy/templates/_post_card.html index a419d55c..87cf9a26 100644 --- a/devplacepy/templates/_post_card.html +++ b/devplacepy/templates/_post_card.html @@ -34,6 +34,10 @@ {% set _poll = item.poll %}{% include "_poll.html" %} {% endif %} + {% if item.war %} + {% set _war = item.war %}{% include "_opinion_war.html" %} + {% endif %} +
{% set _uid = item.post['uid'] %}{% set _my_vote = item.my_vote %}{% set _count = item.post.get('stars', 0) %}{% include "_post_votes.html" %} diff --git a/devplacepy/templates/_post_composer_form.html b/devplacepy/templates/_post_composer_form.html index c29943ff..e4bb0338 100644 --- a/devplacepy/templates/_post_composer_form.html +++ b/devplacepy/templates/_post_composer_form.html @@ -41,6 +41,19 @@
+
+ +
+ +
diff --git a/devplacepy/templates/base.html b/devplacepy/templates/base.html index 4979604f..8ad265be 100644 --- a/devplacepy/templates/base.html +++ b/devplacepy/templates/base.html @@ -52,6 +52,7 @@ + {% block extra_head %}{% endblock %} {{ custom_css_tag(request) }} {{ extra_head_tag() }} @@ -74,6 +75,7 @@ 📄 Gists 🚀 Projects 🧩 Quizzes + ⚔︎ Battles {% if user %}🌱 Farm{% endif %}
@@ -144,6 +146,7 @@ 📄 Gists 🚀 Projects 🧩 Quizzes + ⚔︎ Battles 🏆 Leaderboard {% if user %}🌱 Farm{% endif %}
diff --git a/devplacepy/templates/battles.html b/devplacepy/templates/battles.html new file mode 100644 index 00000000..8cced3a0 --- /dev/null +++ b/devplacepy/templates/battles.html @@ -0,0 +1,53 @@ +{% extends "base.html" %} +{% block extra_head %} + + +{% endblock %} +{% block content %} +

Opinion Wars

+
+ + +
+
+ {% for battle in battles %} + + {% else %} +
No battles here yet. Start an Opinion War from the Create New Post form.
+ {% endfor %} +
+ + {% set pagination_query = "filter=" ~ current_filter ~ "&" ~ ("search=" ~ search ~ "&" if search else "") %} + {% include "_pagination.html" %} +
+
+{% endblock %} diff --git a/devplacepy/templates/docs/opinion-wars.html b/devplacepy/templates/docs/opinion-wars.html new file mode 100644 index 00000000..1198604b --- /dev/null +++ b/devplacepy/templates/docs/opinion-wars.html @@ -0,0 +1,51 @@ +
+# Opinion Wars + +An Opinion War is a week-long battle between two factions, attached to a post. It is the +place to settle the eternal debates - tabs versus spaces, Python versus Rust - by showing +up every day and fighting for your side. + +## Starting a war + +Open **Create New Post** on the feed and press **Start Opinion War** (next to **Add +poll**). Name the two factions, write your post, and publish. The battle starts +immediately and runs for exactly **7 days**. A post carries at most one war, and it can +only be started when the post is created. + +## Joining and fighting + +Any signed-in member picks a side with the **Join** buttons on the battle card. Once +joined, the **Fight** button becomes yours: + +- A fight costs **25 Code Farm coins** - earn them by playing [Code Farm]({{ base }}/game). +- Each fight deals damage for your faction: a base of 100 HP plus 10 HP per site level, + capped at level 20. A brand new member deals 110 HP; a veteran caps out at 300 HP. + There is no randomness - showing up daily beats everything else. +- You can fight **once every 24 hours** per battle. A notification tells you when your + next fight is ready. + +You may switch factions at any time, but damage you already dealt stays with the faction +it was dealt to - defecting does not move your HP. + +## Winning + +When the week is over, the faction with more HP wins. Every fighter who fought at least +once earns XP, the winning side earns a bonus, and the single top damage dealer earns an +extra bonus. Equal totals are a draw with participation XP only. The card freezes into a +victory banner with the final totals and top contributors. + +The battle card shows everything live: the HP bars, the countdown, your faction and rank, +the top contributors, and a ticker of joins, defections, fights and lead changes. + +## The battle listing + +Every battle - active and ended - is listed at [{{ base }}/battles]({{ base }}/battles), +searchable by faction name or creator, with an **Active**, **Ended** and **Mine** filter. + +## The API + +The full REST surface is documented in the [Opinion Wars API group]({{ base }}/docs/battles.html): +list battles, read one battle's state and event log, join a faction, and fight. Devii can +do all of it for you conversationally - it will ask for confirmation before joining or +spending your coins. +
diff --git a/devplacepy/templates/post.html b/devplacepy/templates/post.html index 034a0dbd..1ddb8551 100644 --- a/devplacepy/templates/post.html +++ b/devplacepy/templates/post.html @@ -44,6 +44,10 @@ {% set _poll = poll %}{% include "_poll.html" %} {% endif %} + {% if war %} + {% set _war = war %}{% include "_opinion_war.html" %} + {% endif %} +
{% set _uid = post['uid'] %}{% set _my_vote = my_vote %}{% set _count = post.get('stars', 0) %}{% include "_post_votes.html" %} {% set _type = "post" %}{% set _uid = post['uid'] %}{% set _reactions = reactions %}{% include "_reaction_bar.html" %} diff --git a/devplacepy/utils/CLAUDE.md b/devplacepy/utils/CLAUDE.md index c4db2977..2afc289d 100644 --- a/devplacepy/utils/CLAUDE.md +++ b/devplacepy/utils/CLAUDE.md @@ -21,6 +21,7 @@ The top-nav bell and Messages link carry `data-counter="notifications"` / `data- | `level` | Reach a new level | `utils.py` `award_xp` | `new_level > current_level` | | `badge` | Earn any badge | `utils.py` `notify_badge` | First grant only (`award_badge` returns `True`) | | `issue` | Issue filed/replied/status | `issues.py`, `services/gitea`, `services/jobs/issue_create_service.py` | Reporter or admins | +| `battle` | Opinion War lead change / result / fight-ready | `services/opinionwar/store.py` (lead change + result), `services/opinionwar/service.py` (cooldown sweep) | Fighters of that war; lead change excludes the actor | The `moderation` type carries both faces of the safety layer: the acknowledgement (with the published response window) sent to a reporter the moment they file, and the **statement of reasons** sent to a user whose content or account was actioned. Both are ordinary `create_notification` calls through the single funnel, so a user can turn the channel off per preference like any other type - what they cannot turn off is the decision itself. diff --git a/devplacepy/utils/__init__.py b/devplacepy/utils/__init__.py index 3310caa7..b4ef279f 100644 --- a/devplacepy/utils/__init__.py +++ b/devplacepy/utils/__init__.py @@ -117,6 +117,9 @@ from devplacepy.utils.rewards import ( XP_QUIZ, XP_QUIZ_PUBLISH, XP_QUIZ_COMPLETE, + XP_BATTLE_PART, + XP_BATTLE_WIN, + XP_BATTLE_TOP, level_for_xp, award_xp, _COUNT_MILESTONES, diff --git a/devplacepy/utils/badges.py b/devplacepy/utils/badges.py index 776532a5..db7657f0 100644 --- a/devplacepy/utils/badges.py +++ b/devplacepy/utils/badges.py @@ -55,6 +55,10 @@ BADGE_CATALOG = { "Researcher": {"icon": "🔬", "description": "Ran a DeepSearch investigation", "group": "Explorer"}, "Deep Diver": {"icon": "🌊", "description": "Ran 10 DeepSearch investigations", "group": "Explorer"}, "Container Captain": {"icon": "📦", "description": "Created a container instance", "group": "Explorer"}, + "Instigator": {"icon": "🎺", "description": "Started an Opinion War", "group": "Engagement"}, + "First Blood": {"icon": "⚔", "description": "Fought in an Opinion War", "group": "Engagement"}, + "War Veteran": {"icon": "🛡", "description": "Fought 50 Opinion War battles", "group": "Engagement"}, + "Champion": {"icon": "🏅", "description": "Won an Opinion War", "group": "Engagement"}, "Messenger": {"icon": "✉", "description": "Sent your first direct message", "group": "Community"}, "Chatterbox": {"icon": "📨", "description": "Sent 100 direct messages", "group": "Community"}, "Bookmarker": {"icon": "🔖", "description": "Bookmarked your first item", "group": "Engagement"}, diff --git a/devplacepy/utils/rewards.py b/devplacepy/utils/rewards.py index 34f06bb2..5d765a88 100644 --- a/devplacepy/utils/rewards.py +++ b/devplacepy/utils/rewards.py @@ -22,6 +22,9 @@ XP_FOLLOW = 5 XP_QUIZ = 8 XP_QUIZ_PUBLISH = 12 XP_QUIZ_COMPLETE = 4 +XP_BATTLE_PART = 5 +XP_BATTLE_WIN = 15 +XP_BATTLE_TOP = 10 def level_for_xp(xp: int) -> int: @@ -175,6 +178,9 @@ ACHIEVEMENTS = { "docs.read": [(1, "Curious"), (5, "Studious"), (15, "Scholar")], "devii": [(1, "AI Curious"), (25, "AI Whisperer")], "fork": [(1, "First Fork"), (5, "Forker")], + "battle_create": [(1, "Instigator")], + "battle_fight": [(1, "First Blood"), (50, "War Veteran")], + "battle_win": [(1, "Champion")], "zip": [(1, "Archivist")], "seo": [(1, "SEO Auditor")], "isslop": [(1, "Slop Hunter")], diff --git a/events.md b/events.md index c57f2616..89dc5488 100644 --- a/events.md +++ b/events.md @@ -328,6 +328,11 @@ Every state-changing action in DevPlace records one append-only row through `dev | `poll.vote.cast` | `routers/polls.py` | | `poll.vote.change` | `routers/polls.py` | | `poll.vote.clear` | `routers/polls.py` | +| `battle.create` | `services/opinionwar/store.py` | +| `battle.join` | `services/opinionwar/store.py` | +| `battle.switch` | `services/opinionwar/store.py` | +| `battle.fight` | `services/opinionwar/store.py` | +| `battle.resolve` | `services/opinionwar/store.py` | | `reaction.add` | `routers/reactions.py` | | `reaction.remove` | `routers/reactions.py` | | `vote.comment.clear` | `content.py` | diff --git a/tests/api/battles/__init__.py b/tests/api/battles/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/api/battles/_helpers.py b/tests/api/battles/_helpers.py new file mode 100644 index 00000000..b4c1d956 --- /dev/null +++ b/tests/api/battles/_helpers.py @@ -0,0 +1,78 @@ +# retoor + +import time + +import requests + +from devplacepy.database import get_table, refresh_snapshot +from tests.conftest import BASE_URL + +JSON = {"Accept": "application/json"} +_counter_battles = [0] + + +def _session_battles(): + _counter_battles[0] += 1 + name = f"war{int(time.time() * 1000)}{_counter_battles[0]}" + s = requests.Session() + s.post( + f"{BASE_URL}/auth/signup", + data={ + "username": name, + "email": f"{name}@t.dev", + "password": "secret123", + "confirm_password": "secret123", + "birth_date": "1990-01-01", + "accept_terms": "1", + }, + allow_redirects=True, + ) + return s, name + + +def _create_war_post(session, title, faction_a="Tabs", faction_b="Spaces"): + r = session.post( + f"{BASE_URL}/posts/create", + data={ + "content": "Opinion War host post content for tests.", + "title": title, + "topic": "question", + "war_faction_a": faction_a, + "war_faction_b": faction_b, + }, + allow_redirects=False, + ) + slug = r.headers["location"].split("/posts/")[-1] + refresh_snapshot() + post = get_table("posts").find_one(slug=slug) + war = get_table("opinion_wars").find_one(post_uid=post["uid"]) + return post, war + + +def _war_row(war_uid): + refresh_snapshot() + return get_table("opinion_wars").find_one(uid=war_uid) + + +def _fighter_row(war_uid, user_uid): + refresh_snapshot() + return get_table("opinion_war_fighters").find_one( + war_uid=war_uid, user_uid=user_uid + ) + + +def _user_row(username): + refresh_snapshot() + return get_table("users").find_one(username=username) + + +def _join(session, war_uid, faction): + return session.post( + f"{BASE_URL}/battles/{war_uid}/join", + data={"faction": faction}, + headers=JSON, + ) + + +def _fight(session, war_uid): + return session.post(f"{BASE_URL}/battles/{war_uid}/fight", headers=JSON) diff --git a/tests/api/battles/actions.py b/tests/api/battles/actions.py new file mode 100644 index 00000000..067159b9 --- /dev/null +++ b/tests/api/battles/actions.py @@ -0,0 +1,165 @@ +# retoor + +import time +from datetime import datetime, timedelta, timezone + +import requests + +from devplacepy.database import get_table, refresh_snapshot +from devplacepy.services.opinionwar import rules +from tests.api.battles._helpers import ( + JSON, + _create_war_post, + _fight, + _fighter_row, + _join, + _session_battles, + _user_row, + _war_row, +) +from tests.conftest import BASE_URL + + +def _warp_cooldown(war_uid, user_uid): + fighter = _fighter_row(war_uid, user_uid) + warped = (datetime.now(timezone.utc) - timedelta(hours=25)).isoformat() + get_table("opinion_war_fighters").update( + {"uid": fighter["uid"], "last_fight_at": warped}, ["uid"] + ) + + +def test_join_and_switch(app_server): + s, name = _session_battles() + _, war = _create_war_post(s, f"join-{int(time.time() * 1000)}") + r = _join(s, war["uid"], "a") + assert r.status_code == 200 + payload = r.json() + assert payload["ok"] is True + assert payload["data"]["war"]["viewer"]["faction"] == "a" + fighter = _fighter_row(war["uid"], _user_row(name)["uid"]) + assert fighter["faction"] == "a" + r = _join(s, war["uid"], "b") + assert r.json()["data"]["war"]["viewer"]["faction"] == "b" + fighter = _fighter_row(war["uid"], _user_row(name)["uid"]) + assert fighter["faction"] == "b" + + +def test_join_invalid_faction_422(app_server): + s, _ = _session_battles() + _, war = _create_war_post(s, f"badfaction-{int(time.time() * 1000)}") + r = s.post( + f"{BASE_URL}/battles/{war['uid']}/join", + data={"faction": "c"}, + headers=JSON, + ) + assert r.status_code in (400, 422) + + +def test_join_requires_login(app_server): + s, _ = _session_battles() + _, war = _create_war_post(s, f"anon-{int(time.time() * 1000)}") + r = requests.post( + f"{BASE_URL}/battles/{war['uid']}/join", + data={"faction": "a"}, + allow_redirects=False, + ) + assert r.status_code in (303, 401) + + +def test_fight_spends_coins_and_deals_level_damage(app_server): + s, name = _session_battles() + _, war = _create_war_post(s, f"fight-{int(time.time() * 1000)}") + _join(s, war["uid"], "a") + r = _fight(s, war["uid"]) + assert r.status_code == 200 + payload = r.json() + user = _user_row(name) + expected = rules.damage_for(user.get("level")) + assert payload["data"]["damage"] == expected + assert payload["data"]["war"]["hp_a"] == expected + war_row = _war_row(war["uid"]) + assert int(war_row["hp_a"]) == expected + refresh_snapshot() + farm = get_table("game_farms").find_one(user_uid=user["uid"]) + from devplacepy.services.game import economy + + assert int(farm["coins"]) == economy.STARTING_COINS - rules.FIGHT_COST_COINS + + +def test_fight_cooldown_refused(app_server): + s, _ = _session_battles() + _, war = _create_war_post(s, f"cooldown-{int(time.time() * 1000)}") + _join(s, war["uid"], "a") + assert _fight(s, war["uid"]).status_code == 200 + r = _fight(s, war["uid"]) + assert r.status_code == 400 + assert "24 hours" in r.json()["error"]["message"] + + +def test_fight_after_warped_cooldown_lands(app_server): + s, name = _session_battles() + _, war = _create_war_post(s, f"warp-{int(time.time() * 1000)}") + _join(s, war["uid"], "b") + assert _fight(s, war["uid"]).status_code == 200 + _warp_cooldown(war["uid"], _user_row(name)["uid"]) + r = _fight(s, war["uid"]) + assert r.status_code == 200 + fighter = _fighter_row(war["uid"], _user_row(name)["uid"]) + assert int(fighter["fight_count"]) == 2 + + +def test_fight_without_coins_refused_and_cooldown_kept(app_server): + s, name = _session_battles() + _, war = _create_war_post(s, f"broke-{int(time.time() * 1000)}") + _join(s, war["uid"], "a") + assert _fight(s, war["uid"]).status_code == 200 + user = _user_row(name) + _warp_cooldown(war["uid"], user["uid"]) + refresh_snapshot() + farm = get_table("game_farms").find_one(user_uid=user["uid"]) + get_table("game_farms").update({"uid": farm["uid"], "coins": 0}, ["uid"]) + r = _fight(s, war["uid"]) + assert r.status_code == 400 + assert "coins" in r.json()["error"]["message"] + fighter = _fighter_row(war["uid"], user["uid"]) + assert int(fighter["fight_count"]) == 1 + r = _fight(s, war["uid"]) + assert r.status_code == 400 + + +def test_fight_before_join_refused(app_server): + s, _ = _session_battles() + other, _ = _session_battles() + _, war = _create_war_post(s, f"nojoin-{int(time.time() * 1000)}") + r = _fight(other, war["uid"]) + assert r.status_code == 400 + assert "Join" in r.json()["error"]["message"] + + +def test_switch_keeps_dealt_damage(app_server): + s, name = _session_battles() + _, war = _create_war_post(s, f"defect-{int(time.time() * 1000)}") + _join(s, war["uid"], "a") + assert _fight(s, war["uid"]).status_code == 200 + r = _join(s, war["uid"], "b") + war_state = r.json()["data"]["war"] + user = _user_row(name) + expected = rules.damage_for(user.get("level")) + assert war_state["hp_a"] == expected + assert war_state["hp_b"] == 0 + fighter = _fighter_row(war["uid"], user["uid"]) + assert fighter["faction"] == "b" + assert int(fighter["hp_a"]) == expected + + +def test_actions_on_resolved_war_refused(app_server): + s, _ = _session_battles() + other, _ = _session_battles() + _, war = _create_war_post(s, f"over-{int(time.time() * 1000)}") + _join(s, war["uid"], "a") + past = (datetime.now(timezone.utc) - timedelta(minutes=1)).isoformat() + get_table("opinion_wars").update({"uid": war["uid"], "ends_at": past}, ["uid"]) + r = _fight(s, war["uid"]) + assert r.status_code == 400 + r = _join(other, war["uid"], "b") + assert r.status_code == 400 diff --git a/tests/api/battles/events.py b/tests/api/battles/events.py new file mode 100644 index 00000000..ecfc4121 --- /dev/null +++ b/tests/api/battles/events.py @@ -0,0 +1,43 @@ +# retoor + +import time + +import requests + +from tests.api.battles._helpers import _create_war_post, _fight, _join, _session_battles +from tests.conftest import BASE_URL + + +def test_events_ordered_and_incremental(app_server): + s, _ = _session_battles() + other, _ = _session_battles() + _, war = _create_war_post(s, f"events-{int(time.time() * 1000)}") + _join(s, war["uid"], "a") + _join(other, war["uid"], "b") + _fight(s, war["uid"]) + + r = requests.get(f"{BASE_URL}/battles/{war['uid']}/events") + assert r.status_code == 200 + payload = r.json() + assert payload["status"] == "active" + seqs = [event["seq"] for event in payload["events"]] + assert seqs == sorted(seqs) + kinds = [event["kind"] for event in payload["events"]] + assert kinds[:3] == ["join", "join", "fight"] + assert "lead_change" in kinds + + fight_event = next(e for e in payload["events"] if e["kind"] == "fight") + assert fight_event["faction"] == "a" + assert fight_event["hp_a"] > 0 + + after = seqs[1] + r = requests.get( + f"{BASE_URL}/battles/{war['uid']}/events", params={"after": after} + ) + replay = [event["seq"] for event in r.json()["events"]] + assert replay == [seq for seq in seqs if seq > after] + + +def test_events_unknown_battle_404(app_server): + r = requests.get(f"{BASE_URL}/battles/nope/events") + assert r.status_code == 404 diff --git a/tests/api/battles/index.py b/tests/api/battles/index.py new file mode 100644 index 00000000..221f646c --- /dev/null +++ b/tests/api/battles/index.py @@ -0,0 +1,73 @@ +# retoor + +import time + +import requests + +from tests.api.battles._helpers import JSON, _create_war_post, _session_battles +from tests.conftest import BASE_URL + + +def test_listing_renders_battle_card(app_server): + s, _ = _session_battles() + _create_war_post(s, f"listing-{int(time.time() * 1000)}", "Vim", "Emacs") + r = s.get(f"{BASE_URL}/battles") + assert r.status_code == 200 + assert "dp-opinion-war" in r.text + assert "Vim" in r.text + + +def test_listing_json_shape(app_server): + s, _ = _session_battles() + _, war = _create_war_post(s, f"json-{int(time.time() * 1000)}") + r = s.get(f"{BASE_URL}/battles", headers=JSON) + assert r.status_code == 200 + data = r.json() + assert data["current_filter"] == "active" + assert set(data["counts"]) == {"active", "ended", "mine"} + uids = [battle["uid"] for battle in data["battles"]] + assert war["uid"] in uids + battle = next(b for b in data["battles"] if b["uid"] == war["uid"]) + assert battle["faction_a"] == "Tabs" + assert battle["pct_a"] + battle["pct_b"] == 100 + assert battle["fight_cost"] > 0 + + +def test_listing_guest_access(app_server): + s, _ = _session_battles() + _create_war_post(s, f"guest-{int(time.time() * 1000)}") + r = requests.get(f"{BASE_URL}/battles") + assert r.status_code == 200 + assert "dp-opinion-war" in r.text + + +def test_listing_search_matches_faction(app_server): + s, _ = _session_battles() + marker = f"Zx{int(time.time() * 1000) % 100000}" + _, war = _create_war_post(s, f"search-{marker}", marker, "Others") + r = s.get(f"{BASE_URL}/battles", params={"search": marker}, headers=JSON) + uids = [battle["uid"] for battle in r.json()["battles"]] + assert uids == [war["uid"]] + + +def test_listing_invalid_filter_falls_back(app_server): + s, _ = _session_battles() + r = s.get(f"{BASE_URL}/battles", params={"filter": "bogus"}, headers=JSON) + assert r.json()["current_filter"] == "active" + + +def test_battle_state_json(app_server): + s, _ = _session_battles() + _, war = _create_war_post(s, f"state-{int(time.time() * 1000)}") + r = requests.get(f"{BASE_URL}/battles/{war['uid']}") + assert r.status_code == 200 + data = r.json() + assert data["uid"] == war["uid"] + assert data["status"] == "active" + assert data["viewer"] is None + assert data["ends_in"] + + +def test_battle_state_unknown_uid_404(app_server): + r = requests.get(f"{BASE_URL}/battles/does-not-exist", headers=JSON) + assert r.status_code == 404 diff --git a/tests/api/battles/resolve.py b/tests/api/battles/resolve.py new file mode 100644 index 00000000..87bba63f --- /dev/null +++ b/tests/api/battles/resolve.py @@ -0,0 +1,94 @@ +# retoor + +import time +from datetime import datetime, timedelta, timezone + +import requests + +from devplacepy.database import get_table, refresh_snapshot +from devplacepy.utils.rewards import XP_BATTLE_PART, XP_BATTLE_TOP, XP_BATTLE_WIN +from tests.api.battles._helpers import ( + _create_war_post, + _fight, + _join, + _session_battles, + _user_row, + _war_row, +) +from tests.conftest import BASE_URL + + +def _warp_ended(war_uid): + past = (datetime.now(timezone.utc) - timedelta(minutes=1)).isoformat() + get_table("opinion_wars").update({"uid": war_uid, "ends_at": past}, ["uid"]) + + +def test_resolution_awards_xp_exactly_once(app_server): + s, winner_name = _session_battles() + other, loser_name = _session_battles() + _, war = _create_war_post(s, f"resolve-{int(time.time() * 1000)}") + _join(s, war["uid"], "a") + _join(other, war["uid"], "b") + assert _fight(s, war["uid"]).status_code == 200 + winner_before = int(_user_row(winner_name)["xp"] or 0) + loser_before = int(_user_row(loser_name)["xp"] or 0) + + _warp_ended(war["uid"]) + r = requests.get(f"{BASE_URL}/battles/{war['uid']}") + assert r.status_code == 200 + state = r.json() + assert state["status"] == "resolved" + assert state["winner"] == "a" + assert state["winner_label"] == "Tabs" + + row = _war_row(war["uid"]) + assert row["status"] == "resolved" + assert row["resolved_at"] + + winner_after = int(_user_row(winner_name)["xp"] or 0) + loser_after = int(_user_row(loser_name)["xp"] or 0) + assert winner_after == winner_before + XP_BATTLE_PART + XP_BATTLE_WIN + XP_BATTLE_TOP + assert loser_after == loser_before + + events = requests.get(f"{BASE_URL}/battles/{war['uid']}/events").json()["events"] + results = [event for event in events if event["kind"] == "result"] + assert len(results) == 1 + + refresh_snapshot() + notes = list( + get_table("notifications").find( + type="battle", user_uid=_user_row(loser_name)["uid"] + ) + ) + assert any("Battle over" in (n.get("message") or "") for n in notes) + + r = requests.get(f"{BASE_URL}/battles/{war['uid']}") + assert r.json()["status"] == "resolved" + assert int(_user_row(winner_name)["xp"] or 0) == winner_after + events = requests.get(f"{BASE_URL}/battles/{war['uid']}/events").json()["events"] + assert len([e for e in events if e["kind"] == "result"]) == 1 + + +def test_draw_awards_participation_only(app_server): + s, name = _session_battles() + _, war = _create_war_post(s, f"draw-{int(time.time() * 1000)}") + _join(s, war["uid"], "a") + before = int(_user_row(name)["xp"] or 0) + _warp_ended(war["uid"]) + state = requests.get(f"{BASE_URL}/battles/{war['uid']}").json() + assert state["winner"] == "draw" + assert int(_user_row(name)["xp"] or 0) == before + + +def test_post_page_resolves_due_war(app_server): + s, _ = _session_battles() + post, war = _create_war_post(s, f"lazy-{int(time.time() * 1000)}") + _join(s, war["uid"], "b") + assert _fight(s, war["uid"]).status_code == 200 + _warp_ended(war["uid"]) + slug = post.get("slug") or post["uid"] + r = s.get(f"{BASE_URL}/posts/{slug}") + assert r.status_code == 200 + assert "wins the war" in r.text + assert _war_row(war["uid"])["status"] == "resolved" + assert _war_row(war["uid"])["winner"] == "b" diff --git a/tests/api/posts/create.py b/tests/api/posts/create.py index 464437bc..751b551b 100644 --- a/tests/api/posts/create.py +++ b/tests/api/posts/create.py @@ -795,3 +795,109 @@ def test_feed_includes_project_when_linked(app_server): assert "/projects/" in item["project_link"]["url"] break assert found, "feed must include project info for linked posts" + + +def test_create_post_with_war_creates_battle(app_server): + from devplacepy.services.opinionwar import rules + + s, _ = _member() + r = s.post( + f"{BASE_URL}/posts/create", + headers=JSON_audit_log, + data={ + "title": _unique("auwar"), + "content": "this post carries an opinion war between two factions", + "topic": "question", + "war_faction_a": "Tabs", + "war_faction_b": "Spaces", + }, + ) + post_uid = r.json()["data"]["uid"] + refresh_snapshot() + war = get_table("opinion_wars").find_one(post_uid=post_uid) + assert war is not None + assert war["faction_a"] == "Tabs" + assert war["faction_b"] == "Spaces" + assert war["status"] == "active" + created = datetime.fromisoformat(war["created_at"]) + ends = datetime.fromisoformat(war["ends_at"]) + assert abs((ends - created).total_seconds() - rules.WAR_DURATION_DAYS * 86400) < 5 + + +def test_create_post_with_one_faction_creates_no_war(app_server): + s, _ = _member() + r = s.post( + f"{BASE_URL}/posts/create", + headers=JSON_audit_log, + data={ + "title": _unique("auwarhalf"), + "content": "one faction alone starts no war on this post", + "topic": "question", + "war_faction_a": "Loners", + }, + ) + post_uid = r.json()["data"]["uid"] + refresh_snapshot() + assert get_table("opinion_wars").find_one(post_uid=post_uid) is None + + +def test_create_post_with_equal_factions_creates_no_war(app_server): + s, _ = _member() + r = s.post( + f"{BASE_URL}/posts/create", + headers=JSON_audit_log, + data={ + "title": _unique("auwareq"), + "content": "two identical faction names start no war here", + "topic": "question", + "war_faction_a": "Same", + "war_faction_b": "same", + }, + ) + post_uid = r.json()["data"]["uid"] + refresh_snapshot() + assert get_table("opinion_wars").find_one(post_uid=post_uid) is None + + +def test_create_post_with_poll_and_war_attaches_both(app_server): + s, _ = _member() + r = s.post( + f"{BASE_URL}/posts/create", + headers=JSON_audit_log, + data=[ + ("title", _unique("auwarpoll")), + ("content", "this post carries a poll and an opinion war together"), + ("topic", "question"), + ("poll_question", "Which side?"), + ("poll_options", "Tabs"), + ("poll_options", "Spaces"), + ("war_faction_a", "Tabs"), + ("war_faction_b", "Spaces"), + ], + ) + post_uid = r.json()["data"]["uid"] + refresh_snapshot() + assert get_table("polls").find_one(post_uid=post_uid) is not None + assert get_table("opinion_wars").find_one(post_uid=post_uid) is not None + + +def test_feed_serializes_war_on_post(app_server): + s, _ = _member() + marker = _unique("auwarfeed") + r = s.post( + f"{BASE_URL}/posts/create", + headers=JSON_audit_log, + data={ + "title": marker, + "content": "the feed must carry the serialized war for this post", + "topic": "question", + "war_faction_a": "Cats", + "war_faction_b": "Dogs", + }, + ) + post_uid = r.json()["data"]["uid"] + feed = s.get(f"{BASE_URL}/feed", headers=JSON_audit_log).json() + item = next(i for i in feed["posts"] if i["post"]["uid"] == post_uid) + assert item["war"] is not None + assert item["war"]["faction_a"] == "Cats" + assert item["war"]["pct_a"] == 50 diff --git a/tests/e2e/battles/__init__.py b/tests/e2e/battles/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/e2e/battles/index.py b/tests/e2e/battles/index.py new file mode 100644 index 00000000..6a998d4b --- /dev/null +++ b/tests/e2e/battles/index.py @@ -0,0 +1,157 @@ +# retoor + +import time + +import requests +from playwright.sync_api import expect + +from tests.conftest import BASE_URL + +_counter_wars = [0] + + +def _seed_war(faction_a="Tabs", faction_b="Spaces"): + _counter_wars[0] += 1 + name = f"ewar{int(time.time() * 1000)}{_counter_wars[0]}" + s = requests.Session() + s.post( + f"{BASE_URL}/auth/signup", + data={ + "username": name, + "email": f"{name}@t.dev", + "password": "secret123", + "confirm_password": "secret123", + "birth_date": "1990-01-01", + "accept_terms": "1", + }, + allow_redirects=True, + ) + r = s.post( + f"{BASE_URL}/posts/create", + data={ + "content": "Seeded battle post for browser tests.", + "title": f"battle-{name}", + "topic": "question", + "war_faction_a": faction_a, + "war_faction_b": faction_b, + }, + allow_redirects=False, + ) + return r.headers["location"].split("/posts/")[-1] + + +def _open_composer(page): + page.goto(f"{BASE_URL}/feed", wait_until="domcontentloaded") + page.locator(".feed-fab").first.wait_for(state="visible") + page.locator(".feed-fab").first.click() + page.locator("#create-post-modal.visible").wait_for(state="visible") + + +def test_battles_page_lists_cards(alice): + page, _ = alice + _seed_war("Vikings", "Knights") + page.goto(f"{BASE_URL}/battles", wait_until="domcontentloaded") + page.locator("dp-opinion-war").first.wait_for(state="visible") + expect(page.locator(".topnav-link.active:has-text('Battles')")).to_be_visible() + expect(page.locator("dp-opinion-war .war-vs").first).to_have_text("VS") + + +def test_battle_card_on_post_page(alice): + page, _ = alice + slug = _seed_war("Ninjas", "Pirates") + page.goto(f"{BASE_URL}/posts/{slug}", wait_until="domcontentloaded") + card = page.locator("dp-opinion-war") + card.wait_for(state="visible") + expect(card.locator(".war-side-a .war-side-name")).to_have_text("Ninjas") + expect(card.locator(".war-field")).to_be_visible() + expect(card.locator(".war-all-link")).to_have_attribute("href", "/battles") + + +def test_composer_war_toggle_and_poll_exclusivity(alice): + page, _ = alice + _open_composer(page) + modal = page.locator("#create-post-modal") + expect(modal.locator("[data-war-builder]")).to_be_hidden() + modal.locator("[data-war-toggle]").click() + expect(modal.locator("[data-war-builder]")).to_be_visible() + expect(modal.locator("input[name='war_faction_a']")).to_be_enabled() + modal.locator("[data-poll-toggle]").click() + expect(modal.locator("[data-poll-builder]")).to_be_visible() + expect(modal.locator("[data-war-builder]")).to_be_hidden() + modal.locator("[data-war-toggle]").click() + expect(modal.locator("[data-war-builder]")).to_be_visible() + expect(modal.locator("[data-poll-builder]")).to_be_hidden() + + +def test_composer_war_validation_blocks_submit(alice): + page, _ = alice + _open_composer(page) + modal = page.locator("#create-post-modal") + page.fill("#post-content", "A war with only one named faction must not submit.") + modal.locator("[data-war-toggle]").click() + modal.locator("input[name='war_faction_a']").fill("Solo") + modal.locator("button.btn-primary:has-text('Post')").click() + expect(modal.locator("[data-war-error]")).to_be_visible() + assert "/feed" in page.url + + +def test_create_join_and_fight_flow(alice): + page, _ = alice + from devplacepy.database import get_table, refresh_snapshot + from devplacepy.services.game.store import ensure_farm + + refresh_snapshot() + row = get_table("users").find_one(username="alice_test") + farm = ensure_farm(row["uid"]) + get_table("game_farms").update({"uid": farm["uid"], "coins": 1000}, ["uid"]) + + _open_composer(page) + modal = page.locator("#create-post-modal") + page.fill("#post-content", "Full battle flow: create, join and fight in browser.") + modal.locator("[data-war-toggle]").click() + modal.locator("input[name='war_faction_a']").fill("Coffee") + modal.locator("input[name='war_faction_b']").fill("Tea") + modal.locator("button.btn-primary:has-text('Post')").click() + page.wait_for_url(f"{BASE_URL}/posts/*", wait_until="domcontentloaded") + + card = page.locator("dp-opinion-war") + card.wait_for(state="visible") + card.locator(".war-join-a").click() + card.locator("[data-war-mine]").wait_for(state="visible") + + hp_before = card.locator("[data-war-hp-a]").text_content() + card.locator("[data-war-fight]").click() + page.wait_for_function( + "before => document.querySelector('[data-war-hp-a]').textContent !== before", + arg=hp_before, + ) + expect(card.locator("[data-war-fight]")).to_be_disabled() + ticker_first = card.locator("[data-war-ticker] .war-event").first + expect(ticker_first).to_contain_text("dealt") + + +def test_switch_faction_shows_confirm(alice): + page, _ = alice + slug = _seed_war("Left", "Right") + page.goto(f"{BASE_URL}/posts/{slug}", wait_until="domcontentloaded") + card = page.locator("dp-opinion-war") + card.wait_for(state="visible") + card.locator(".war-join-b").click() + page.wait_for_url(f"{BASE_URL}/posts/*", wait_until="domcontentloaded") + card = page.locator("dp-opinion-war") + card.locator(".war-switch-btn").wait_for(state="visible") + card.locator(".war-switch-btn").click() + page.locator(".dialog-overlay.visible .dialog-confirm").wait_for(state="visible") + page.locator(".dialog-overlay.visible .dialog-confirm").click() + page.wait_for_url(f"{BASE_URL}/posts/*", wait_until="domcontentloaded") + card = page.locator("dp-opinion-war") + expect(card.locator(".war-mine-faction")).to_have_text("Left") + + +def test_guest_sees_disabled_actions(page, app_server): + slug = _seed_war("Sun", "Moon") + page.goto(f"{BASE_URL}/posts/{slug}", wait_until="domcontentloaded") + card = page.locator("dp-opinion-war") + card.wait_for(state="visible") + expect(card.locator(".war-join-a")).to_be_disabled() + expect(card.locator(".war-join-b")).to_be_disabled() diff --git a/tests/unit/services/opinionwar/__init__.py b/tests/unit/services/opinionwar/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/unit/services/opinionwar/rules.py b/tests/unit/services/opinionwar/rules.py new file mode 100644 index 00000000..ea02842f --- /dev/null +++ b/tests/unit/services/opinionwar/rules.py @@ -0,0 +1,94 @@ +# retoor + +from datetime import datetime, timedelta, timezone + +from devplacepy.services.opinionwar import rules + + +def test_damage_bounds_and_monotonicity(): + previous = None + for level in range(1, 200): + damage = rules.damage_for(level) + assert isinstance(damage, int) + assert rules.BASE_DAMAGE + rules.LEVEL_DAMAGE_STEP <= damage <= 300 + if previous is not None: + assert damage >= previous + previous = damage + + +def test_damage_caps_at_level_cap(): + capped = rules.damage_for(rules.LEVEL_DAMAGE_CAP) + assert rules.damage_for(rules.LEVEL_DAMAGE_CAP + 1) == capped + assert rules.damage_for(1000) == capped + assert capped == rules.BASE_DAMAGE + rules.LEVEL_DAMAGE_STEP * rules.LEVEL_DAMAGE_CAP + + +def test_damage_tolerates_junk_levels(): + floor = rules.damage_for(1) + assert rules.damage_for(None) == floor + assert rules.damage_for(0) == floor + assert rules.damage_for(-3) == floor + assert rules.damage_for("junk") == floor + assert rules.damage_for("7") == rules.damage_for(7) + + +def test_leader_and_winner_agree(): + for hp_a in range(0, 40, 3): + for hp_b in range(0, 40, 5): + leader = rules.leader_of(hp_a, hp_b) + winner = rules.winner_of(hp_a, hp_b) + if hp_a == hp_b: + assert leader == "" + assert winner == "draw" + else: + assert leader in ("a", "b") + assert winner == leader + + +def test_pct_split_sums_to_hundred(): + for hp_a in range(0, 50, 7): + for hp_b in range(0, 50, 9): + pct_a, pct_b = rules.pct_split(hp_a, hp_b) + assert pct_a + pct_b == 100 + assert rules.pct_split(0, 0) == (50, 50) + assert rules.pct_split(10, 0) == (100, 0) + assert rules.pct_split(0, 10) == (0, 100) + + +def test_ends_at_round_trip(): + now = datetime.now(timezone.utc) + ends = rules.ends_at_for(now.isoformat()) + assert not rules.is_ended(ends, now) + assert not rules.is_ended(ends, now + timedelta(days=6, hours=23)) + assert rules.is_ended(ends, now + timedelta(days=7, seconds=1)) + assert rules.is_ended("", now) is False + assert rules.is_ended("garbage", now) is False + + +def test_cooldown_math(): + now = datetime.now(timezone.utc) + stamp = now.isoformat() + assert rules.can_fight_at("", now) + assert not rules.can_fight_at(stamp, now + timedelta(hours=23, minutes=59)) + assert rules.can_fight_at(stamp, now + timedelta(hours=24, seconds=1)) + ready = rules.cooldown_ready_at(stamp) + assert ready > stamp + assert rules.cooldown_ready_at("") == "" + + +def test_ends_in_label_shapes(): + now = datetime.now(timezone.utc) + long_label = rules.ends_in_label( + (now + timedelta(days=2, hours=14, minutes=32, seconds=30)).isoformat(), now + ) + assert long_label == "2d 14h 32m" + hours_label = rules.ends_in_label( + (now + timedelta(hours=3, minutes=5, seconds=30)).isoformat(), now + ) + assert hours_label == "3h 5m" + minutes_label = rules.ends_in_label( + (now + timedelta(minutes=9, seconds=30)).isoformat(), now + ) + assert minutes_label == "9m" + assert rules.ends_in_label((now - timedelta(minutes=1)).isoformat(), now) == "" + assert rules.ends_in_label("", now) == ""