blindxfishandClaude Fable 5
80956ce0f4
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 <noreply@anthropic.com>
95 lines
3.2 KiB
Python
95 lines
3.2 KiB
Python
# retoor <retoor@molodetz.nl>
|
|
|
|
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) == ""
|