diff --git a/client/game.html b/client/game.html index baae5f8..2d825f7 100644 --- a/client/game.html +++ b/client/game.html @@ -18,11 +18,11 @@
THE GATHERING7d 00h
Until the Harbinger
- + diff --git a/client/src/control.ts b/client/src/control.ts index 27af360..35e4d4f 100644 --- a/client/src/control.ts +++ b/client/src/control.ts @@ -1,4 +1,5 @@ import './portal.css'; +import { permanentTitles, progressionSummary } from './progression'; import { $, api, APIError, badge, cell, date, el, gameURL, icons, icon, table, type Command, type RecordCharacter, type World } from './portal-shared'; type Data = { worlds: World[]; characters: RecordCharacter[]; commands: Command[]; provisioningEnabled: boolean; characterLimit: number; auditLimit: number }; @@ -43,6 +44,7 @@ function detail(r: RecordCharacter) { const list = el('dl', '', 'details'); const v = r.character.view; const pairs: [string, string][] = [['Character ID', r.id], ['Account ID', r.account], ['World', r.worldId], ['State', r.state], ['Health', `${v.entity.hp} / ${v.entity.maxHp}`], ['Position', `${Math.round(v.entity.position.x)}, ${Math.round(v.entity.position.y)}, ${Math.round(v.entity.position.z)}`], ['Played today', `${Math.floor(r.character.dailySeconds / 60)} min`], ['Born', date(r.character.bornAt)], ['Died', r.character.diedAt ? date(r.character.diedAt) : '-'], ['Cause', r.character.deathReason || '-']]; for (const [key,value] of pairs) list.append(el('dt', key), el('dd', value)); parent.append(list); + parent.append(el('h3', 'Progression'), progressionSummary(v), el('h3', 'Permanent titles'), permanentTitles(v.titles)); for (const [heading, items] of [['Inventory', v.inventory], ['Skills', v.skills]] as const) { parent.append(el('h3', heading)); const section = el('div', '', 'item-list'); for (const [key,value] of Object.entries(items)) { const item = el('span', key.replaceAll('_', ' ')); item.append(el('b', String(value))); section.append(item); } if (!section.children.length) section.append(el('span', 'None', 'muted')); parent.append(section); } $('character-dialog').showModal(); } diff --git a/client/src/generated.ts b/client/src/generated.ts index e6175e4..030b3c4 100644 --- a/client/src/generated.ts +++ b/client/src/generated.ts @@ -53,14 +53,34 @@ export interface Vec3 { } export interface Character { - ack: number; - entity: Entity; - hasKeystone: boolean; - inventory: { [key: string]: number }; - kills: number; - playedSeconds: number; - remainingSeconds: number; - skills: { [key: string]: number }; + ack: number; + entity: Entity; + experience: number; + experienceToNextLevel: number; + hasKeystone: boolean; + inventory: { [key: string]: number }; + kills: number; + level: number; + playedSeconds: number; + remainingSeconds: number; + skills: { [key: string]: number }; + statPoints: number; + titles: TitleAward[]; +} + +export interface TitleAward { + description: string; + earnedAt: string; + effects: TitleEffects; + id: string; + name: string; + scope: string; + worldId: string; +} + +export interface TitleEffects { + damage: number; + moveSpeed: number; } export interface WorldInfo { diff --git a/client/src/main.ts b/client/src/main.ts index d560eb7..5859085 100644 --- a/client/src/main.ts +++ b/client/src/main.ts @@ -2,6 +2,7 @@ import './style.css'; import { createIcons, Crosshair, Settings2, X, Flame, LogOut, Hourglass, Swords, Pickaxe, HeartPulse, Gem, Backpack, ChevronUp, ChevronDown, ChevronLeft, ChevronRight, ArrowRight, RefreshCw } from 'lucide'; import { WorldView } from './world-view'; import type { Character, Chunk, Entity, Intent, Snapshot } from './generated'; +import { experienceText, permanentTitles, statPointsText, updateExperienceMeter } from './progression'; type Recipe = { Inputs: Record; Outputs: Record }; type Config = { worldId: string; development: boolean; worlds: { id: string; url: string }[]; recipes: Record; playerSpeed: number; gatherRange: number; attackRange: number }; @@ -114,6 +115,8 @@ function showEnding(title: string, detail: string, survivor: boolean) { $('ending').show(); } function inventory(c: Character) { + $('saved-stat-points').textContent = statPointsText(c); + $('earned-titles').replaceChildren(permanentTitles(c.titles)); const parent = $('inventory-items'); parent.replaceChildren(); for (const [item, count] of Object.entries(c.inventory).filter(([, n]) => n > 0)) { const div = document.createElement('div'); div.className = 'item'; @@ -148,6 +151,12 @@ function updateHUD(s: Snapshot) { const c = s.self, w = s.world; visible('game-controls', true); visible('movement', c.entity.state === 'alive' && $('inventory').hidden && $('settings').hidden); $('character-name').textContent = c.entity.name; + $('character-level').textContent = `Level ${c.level || 1}`; + $('character-experience').textContent = experienceText(c); + updateExperienceMeter($('experience-meter'), c); + $('stat-point-bank').textContent = statPointsText(c); + const titleCount = c.titles?.length ?? 0; + $('title-count').textContent = `${titleCount} title${titleCount === 1 ? '' : 's'}`; $('health-number').textContent = `${Math.max(0, Math.ceil(c.entity.hp))} / ${Math.ceil(c.entity.maxHp)}`; $('health-fill').style.width = `${Math.max(0, c.entity.hp / c.entity.maxHp * 100)}%`; $('play-time').textContent = `${time(c.remainingSeconds)} left today`; diff --git a/client/src/portal.css b/client/src/portal.css index 928577b..58631bf 100644 --- a/client/src/portal.css +++ b/client/src/portal.css @@ -8,3 +8,4 @@ dialog { width: min(510px, calc(100vw - 32px)); max-height: calc(100dvh - 40px); @media(max-width:720px) { .site-header { padding: 16px 5%; flex-wrap: wrap; gap: 18px; } .site-header nav { gap: 17px; width: 100%; justify-content: space-between; } .site-header nav > a { font-size: 12px; } .wordmark { font-size: 17px; } .world-hero { min-height: 300px; max-height: none; height: 350px; } .hero-copy { bottom: 45px; right: 6%; } .hero-copy h1 { font-size: 47px; } .hero-copy > p:not(.eyebrow) { font-size: 14px; max-width: 260px; } .hero-caption { font-size: 8px; } .site-section { padding-top: 30px; padding-bottom: 30px; } .section-heading h2 { font-size: 23px; } .world-row { grid-template-columns: 42px minmax(0,1fr) auto; gap: 17px 12px; } .world-emblem { width: 38px; height: 42px; } .world-name h3 { font-size: 16px; } .world-row .world-stat:nth-child(4) { grid-column: 2; } .world-row > .button { grid-column: 3; font-size: 11px; padding: 9px; } .world-stat strong { font-size: 12px; } .world-stat span { margin-bottom: 4px; } .active-life { align-items: flex-start; flex-wrap: wrap; } .site-footer { flex-wrap: wrap; } .site-footer > span:nth-child(2) { order: 3; width: 100%; } .control-site { display: block; } .control-sidebar { padding: 18px; border-right: 0; border-bottom: 1px solid var(--line); } .control-sidebar .wordmark { margin-bottom: 18px; padding: 0; } .control-sidebar nav { grid-template-columns: repeat(3,minmax(0,1fr)); gap: 3px; } .nav-item { justify-content: center; padding: 11px 4px; gap: 6px; font-size: 12px; } .sidebar-bottom { display: none; } .control-main { padding: 22px 16px; } .control-header { margin-bottom: 20px; gap: 12px; } .control-header h1 { font-size: 24px; } .control-header .heading-tools { gap: 6px; } #admin-signout { display: none; } #create-world { padding: 10px; font-size: 12px; } .metrics { grid-template-columns: repeat(2,minmax(0,1fr)); gap: 20px 0; padding: 20px 0; margin-bottom: 20px; } .metrics > div { padding: 0 16px; } .metrics > div:nth-child(3) { padding-left: 0; } .metrics > div:nth-child(2) { border-right: 0; } .metrics strong { font-size: 24px; } .metrics span { font-size: 11px; } .table-tools { gap: 12px; } .search-field { flex-basis: 100%; max-width: none; } .table-tools > .muted { font-size: 11px; } .table-tools label { font-size: 11px; } .table-tools select { max-width: 135px; font-size: 12px; } th,td { padding: 12px 10px; } .access-state { padding: 65px 5px; } dialog { padding: 21px; } } .button.secondary:hover:not(:disabled):not(.disabled), .button.light:hover:not(:disabled):not(.disabled) { background: #edf3ef; color: #253c31; } @media(prefers-reduced-motion:reduce) { * { scroll-behavior: auto !important; } } +.active-life-summary{flex:1;min-width:0}.active-titles{padding-bottom:28px}.active-titles>h3{font-size:14px;margin-bottom:12px}.active-titles .title-list{grid-template-columns:repeat(auto-fit,minmax(min(250px,100%),1fr))}.active-life .progression-note{margin-top:4px}td .character-progression{min-width:155px;margin-top:0}dialog .earned-title p{margin-bottom:0} diff --git a/client/src/progression.css b/client/src/progression.css new file mode 100644 index 0000000..1d386b8 --- /dev/null +++ b/client/src/progression.css @@ -0,0 +1,19 @@ +.character-progression { width: 100%; max-width: 360px; margin-top: 15px; } +.progression-line { display: flex; justify-content: space-between; align-items: baseline; flex-wrap: wrap; gap: 5px 12px; font-size: 12px; } +.progression-line strong { font-size: inherit; font-weight: 600; } +.experience-meter { display: block; width: 100%; height: 4px; margin: 8px 0; border: 0; border-radius: 2px; overflow: hidden; appearance: none; background: var(--progression-track, #d9e4dd); color: var(--progression-fill, #477d62); } +.experience-meter::-webkit-progress-bar { background: var(--progression-track, #d9e4dd); } +.experience-meter::-webkit-progress-value { background: var(--progression-fill, #477d62); } +.experience-meter::-moz-progress-bar { background: var(--progression-fill, #477d62); } +.progression-note { color: var(--progression-muted, #66736d); font-size: 12px; line-height: 1.5; } +.title-list { display: grid; gap: 10px; min-width: 0; } +.earned-title { min-width: 0; padding: 13px; border: 1px solid var(--progression-border, #cfdad3); border-radius: 4px; overflow-wrap: anywhere; } +.earned-title > strong { display: block; font-size: 13px; font-weight: 600; } +.title-description { margin: 7px 0 0; font-size: 12px; line-height: 1.6; } +.title-origin { margin: 7px 0 0; color: var(--progression-muted, #66736d); font-size: 11px; line-height: 1.5; } +.title-effects { display: flex; flex-wrap: wrap; gap: 6px 12px; margin-top: 9px; font-size: 12px; } +.effect-positive { color: var(--progression-positive, #28714c); } +.effect-negative { color: var(--progression-negative, #a24554); } +.title-history { min-width: 190px; } +.title-history summary { cursor: pointer; color: var(--progression-muted, #66736d); } +.title-history[open] summary { margin-bottom: 10px; } diff --git a/client/src/progression.ts b/client/src/progression.ts new file mode 100644 index 0000000..406a973 --- /dev/null +++ b/client/src/progression.ts @@ -0,0 +1,45 @@ +import './progression.css'; +import type { Character, TitleAward } from './generated'; + +function element(tag: K, text = '', className = '') { + const node = document.createElement(tag); node.textContent = text; node.className = className; return node; +} +export function experienceText(character: Character) { + if (!Number.isFinite(character.experienceToNextLevel)) return 'XP unavailable'; + return character.experienceToNextLevel > 0 ? `${character.experience} / ${character.experienceToNextLevel} XP` : 'Level cap'; +} +export function statPointsText(character: Character) { + const points = character.statPoints ?? 0; + return `${points} stat point${points === 1 ? '' : 's'} saved`; +} +export function updateExperienceMeter(meter: HTMLProgressElement, character: Character) { + meter.max = character.experienceToNextLevel || 1; + meter.value = character.experienceToNextLevel > 0 ? character.experience : character.experienceToNextLevel === 0 ? 1 : 0; + meter.setAttribute('aria-valuetext', `Level ${character.level || 1}: ${experienceText(character)}`); +} +export function progressionSummary(character: Character) { + const parent = element('div', '', 'character-progression'); + const line = element('div', '', 'progression-line'); + line.append(element('strong', `Level ${character.level || 1}`), element('span', experienceText(character))); + const meter = element('progress', '', 'experience-meter'); meter.setAttribute('aria-label', 'Level experience'); updateExperienceMeter(meter, character); + parent.append(line, meter, element('p', statPointsText(character), 'progression-note'), element('p', 'Stat allocation is coming later.', 'progression-note')); + return parent; +} +export function permanentTitles(titles: TitleAward[] = []) { + const parent = element('div', '', 'title-list'); + if (!titles?.length) { parent.append(element('p', 'No titles earned yet.', 'progression-note')); return parent; } + const scopes: Record = { personal: 'Personal', world: 'World first', global: 'First ever' }; + for (const title of titles) { + const card = element('article', '', 'earned-title'); + card.append(element('strong', title.name), element('p', title.description, 'title-description')); + const earned = new Date(title.earnedAt).toLocaleDateString([], { year: 'numeric', month: 'short', day: 'numeric' }); + card.append(element('p', `${scopes[title.scope] || title.scope} / ${title.worldId} / ${earned}`, 'title-origin')); + const effects = element('div', '', 'title-effects'); + for (const [value, label] of [[title.effects.damage, 'damage'], [title.effects.moveSpeed, 'movement speed']] as const) { + if (value) effects.append(element('span', `${value > 0 ? '+' : ''}${value} ${label}`, value > 0 ? 'effect-positive' : 'effect-negative')); + } + if (!effects.children.length) effects.append(element('span', 'No attribute effects.', 'progression-note')); + card.append(effects); parent.append(card); + } + return parent; +} diff --git a/client/src/site.ts b/client/src/site.ts index 21f64e2..de705fc 100644 --- a/client/src/site.ts +++ b/client/src/site.ts @@ -1,4 +1,5 @@ import './portal.css'; +import { permanentTitles, progressionSummary } from './progression'; import { $, api, APIError, badge, cell, date, el, gameURL, icons, icon, table, type RecordCharacter, type World } from './portal-shared'; type Account = { active: RecordCharacter | null; characters: RecordCharacter[]; admin: boolean }; @@ -30,12 +31,21 @@ function renderAccount() { $('control-link').hidden = !account?.admin; $('account-button').replaceChildren(icon(account ? 'log-out' : 'log-in'), el('span', account ? 'Sign out' : 'Sign in')); if (!account) { history.append(el('p', 'Sign in to see your characters.', 'empty')); return; } - if (account.active) { const r = account.active; const summary = el('div', '', 'active-life'); const title = el('div'); title.append(el('h3', r.name), el('p', `${r.worldId} / ${r.state === 'eligible' ? 'Passage earned' : `${Math.ceil(r.character.view.entity.hp)} health`}`, 'muted')); const link = el('a', 'Continue journey', 'button'); link.href = gameURL(r.worldId); link.append(icon('arrow-right')); summary.append(title, link); parent.append(summary); } + if (account.active) { + const r = account.active; const summary = el('div', '', 'active-life'); const title = el('div', '', 'active-life-summary'); + title.append(el('h3', r.name), el('p', `${r.worldId} / ${r.state === 'eligible' ? 'Passage earned' : `${Math.ceil(r.character.view.entity.hp)} health`}`, 'muted'), progressionSummary(r.character.view)); + const link = el('a', 'Continue journey', 'button'); link.href = gameURL(r.worldId); link.append(icon('arrow-right')); summary.append(title, link); + const titles = el('section', '', 'active-titles'); titles.append(el('h3', 'Permanent titles'), permanentTitles(r.character.view.titles)); parent.append(summary, titles); + } else parent.append(el('p', 'Your next life is waiting in an open world.', 'empty')); if (!account.characters.length) return; - const { node, body } = table(['Character', 'World', 'State', 'Journey ended', 'Cause']); + const { node, body } = table(['Character', 'World', 'State', 'Progression', 'Permanent titles', 'Journey ended', 'Cause']); for (const r of [...account.characters].sort((a,b) => (b.character.diedAt || b.character.bornAt).localeCompare(a.character.diedAt || a.character.bornAt))) { - const row = body.insertRow(); cell(row, r.name); cell(row, r.worldId); cell(row, badge(r.state)); cell(row, r.character.diedAt ? date(r.character.diedAt) : '-'); cell(row, r.character.deathReason || '-'); + const row = body.insertRow(); cell(row, r.name); cell(row, r.worldId); cell(row, badge(r.state)); cell(row, progressionSummary(r.character.view)); + const titles = r.character.view.titles ?? []; + if (titles.length) { const details = el('details', '', 'title-history'); details.append(el('summary', `${titles.length} permanent title${titles.length === 1 ? '' : 's'}`), permanentTitles(titles)); cell(row, details); } + else cell(row, 'None earned'); + cell(row, r.character.diedAt ? date(r.character.diedAt) : '-'); cell(row, r.character.deathReason || '-'); } const wrapper = el('div', '', 'table-wrap'); wrapper.append(node); history.append(wrapper); } diff --git a/client/src/style.css b/client/src/style.css index baf3868..dc37853 100644 --- a/client/src/style.css +++ b/client/src/style.css @@ -4,3 +4,8 @@ .boss-bar>button{background:transparent;border:0;padding:0;min-height:28px;font:18px Georgia,serif;color:#ffe3d5;text-shadow:0 2px 5px #000} @media(max-width:800px){.inventory{bottom:190px;max-height:calc(100dvh - 285px)}} @media(max-height:520px){.season{top:85px}.bottom{bottom:10px;flex-wrap:nowrap}.location{display:none}.movement:not([hidden]){display:grid;position:absolute;grid-template-columns:repeat(4,38px);gap:3px;bottom:110px;left:18px}.movement button{padding:6px}.boss-bar{top:80px}.inventory,.settings{top:70px;bottom:auto;max-height:calc(100dvh - 90px)}dialog{max-height:calc(100dvh - 24px);overflow:auto;padding:20px}.notice{bottom:90px}} +:root{--progression-track:#ffffff20;--progression-fill:#d0bb83;--progression-muted:#b8c9b2;--progression-border:#87927950;--progression-positive:#b3ce82;--progression-negative:#efa79b} +.vitals .progression-line{margin-top:13px;font-size:11px}.progression-bank{display:flex;justify-content:space-between;flex-wrap:wrap;gap:5px 10px;font-size:10px;color:#cbd7c2}.inventory .progression-note{margin-top:5px}.inventory .earned-title .progression-note{margin:0}.inventory .earned-title{padding:11px} +@media(min-height:521px){.inventory{bottom:195px}} +@media(max-width:800px) and (min-height:521px){.movement:not([hidden]){bottom:255px}.inventory{bottom:258px;max-height:calc(100dvh - 350px)}.notice{bottom:375px}} +@media(max-height:520px){.movement:not([hidden]){bottom:178px}} diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 3a38791..eec5a46 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -89,6 +89,33 @@ simulation lock and are deliberately a simple first implementation. Before publi permadeath or large worlds, replace this with a durable event log, asynchronous checkpoints, versioned migrations, and crash/latency fault injection. +## Progression and permanent titles + +The Go simulation awards character XP for successful gathering, crafting, mob +kills, and the boss killing blow. Each crossed level threshold banks stat points; +there is no allocation intent until the stat design is defined. Levels, XP, +points, and the character's original level curve survive restart and survivor +passage. Replacement characters start at level 1. Existing snapshots receive +level 1 and the initial progression defaults once, without retroactive XP or +points, while preserving deaths and daily usage. + +Title requirements are evaluated in Go and produce ordered award candidates. +The shared database resolves first-world and first-ever claims in the same +transaction as the owner/revision-checked world snapshot, character registry, +and survivor passages. A conflicting first claim is an ordinary lost race. +Only committed awards appear in the character view or affect combat/movement. +The immutable account ledger preserves title ownership after death and across +worlds; death records retain their titles and new lives inherit account awards. +This account inheritance is the initial interpretation of player-bound titles. +Awarded names, descriptions, effects, and provenance are copied at grant time; +later content changes do not remove or alter an earned title. + +All earned title effects are active and additive, once per title ID. The initial +effect hooks are damage and movement speed; both accept positive and negative +values, with effective damage/speed floored at zero. They cannot alter death, +the daily play budget, or passage eligibility. The broader stat and effect +catalog remains open. See [progression configuration](PROGRESSION.md). + ## Security scope - Production login: OIDC verification (issuer, audience, signature, expiry), PKCE, diff --git a/docs/DEPLOYMENT.md b/docs/DEPLOYMENT.md index 1474784..8ee6a59 100644 --- a/docs/DEPLOYMENT.md +++ b/docs/DEPLOYMENT.md @@ -43,6 +43,33 @@ Configure `deploy/chart/values.yaml` (prefer an external GitOps values file): 4. Render and inspect with `helm lint` and `helm template`; validate against the target cluster version using your normal dry-run pipeline. +## Keycloak administrator access + +Create the exact realm role **`aeternalis-admin`** and assign it to your user. +The configured override is `OIDC_ADMIN_ROLE` (`control.adminRole` in Helm values); +the SRS deployment already uses `aeternalis-admin`. + +The app checks the verified **ID token** for either +`realm_access.roles` or `resource_access[OIDC_CLIENT_ID].roles`. An access-token-only +role or a role belonging to a different client does not grant access. + +For the realm-role approach, configure a User Realm Role mapper on the client's +dedicated scope with token claim `realm_access.roles`, no role prefix, type +String, Multivalued enabled, and **Add to ID token** enabled. If client role scope +is restricted, include `aeternalis-admin` in that scope. The SRS client is +`aeternalis-web`. Use Keycloak's token evaluation to check the ID token contains: + +```json +{"realm_access":{"roles":["aeternalis-admin"]}} +``` + +Sign out of the game and sign back in at `/control` after assigning the role. +Existing game sessions do not gain admin privileges automatically. The admin +grant lasts ten minutes; sign in again from Control to renew it. Production +continues to require verified OIDC; `DEV_ADMIN` is restricted to loopback development. + +See [Keycloak role token mappings](https://www.keycloak.org/docs/latest/server_admin/#_oidc_token_role_mappings). + ## Gitea setup Enable Actions in the repository. Use a runner with the `ubuntu-latest` label, diff --git a/docs/PROGRESSION.md b/docs/PROGRESSION.md new file mode 100644 index 0000000..99d99f9 --- /dev/null +++ b/docs/PROGRESSION.md @@ -0,0 +1,92 @@ +# Levels and permanent titles + +Levels belong to a character. Titles belong to an account in this first pass, +so a new life inherits titles while starting at level 1 with no XP or stat +points. A dead character remains dead and keeps its historical progression. +Survivor passage preserves levels, XP, points, titles, and the daily time budget. + +## Provisional level tuning + +Edit `server/content/balance.yaml`. New characters start at level 1. Reaching +level 2 takes 100 XP; each following threshold costs 50 XP more. Every level +awards 5 banked stat points. The current safety cap is level 1000. All of these +values are configuration, not a settled stat or balance design. + +Successful gathering gives 10 XP, crafting 20 XP, a sentinel kill 50 XP, and +the boss killing blow 500 XP. Nonlethal hits, failed actions, duplicate requests, +and actions after death give no XP. XP beyond a threshold carries into the next +level, including multiple level-ups from one reward. XP stops at the cap. + +There is no stat allocation or client XP-grant API. Points remain banked until +the full stat system is designed. Character level curves and point grants are +stored with the character, so moving into differently tuned worlds cannot reset +or reprice earned progress. Activity XP rewards use the destination world's tuning. + +## Title definitions + +The YAML `titles` list is the initial authoring interface. Each entry needs a +stable `id`, `name`, `description`, `scope`, one or more `requirements`, and +`effects`. Requirements are ANDed and use positive integer `atLeast` thresholds. + +| Requirement metric | Meaning | +| --- | --- | +| `level` | Current character level | +| `kills` | Lifetime sentinel kills for this character | +| `worldKills` | Sentinel kills since arriving in this world; resets on passage | +| `bossKills` | Boss killing blows for this character | +| `worldsSurvived` | Worlds survived when their boss dies, including offline survivors | +| `gathering`, `crafting`, `combat` | Existing character skill XP counters | +| `deaths` | 1 when this character dies, otherwise 0 | + +| Scope | Award policy | +| --- | --- | +| `personal` | Any qualifying account can earn the title once | +| `world` | First qualifying account to commit the title claim in a world | +| `global` | First qualifying account to commit the title claim across the shared database | + +“First ever” is determined by the first committed eligible transaction, starting +when the title is introduced. It cannot reconstruct an achievement predating +the title system. All production worlds must share the PostgreSQL database. +Within a world, candidates follow simulation event order. Simultaneous survivor +milestones break ties by character ID. An account already owning a title does +not earn it again or stack its effects by visiting another world. + +The shipped starter examples are Wayfarer (level 2, +1 damage), First Hunter of +the World (first sentinel kill in a world, +2 damage), and The First Hunter +(first sentinel kill globally, +3 damage and -0.5 movement speed). + +Effects are additive `damage` and `moveSpeed` values using existing game units. +Negative values are supported. Every owned title is active; effective damage +and movement speed cannot go below zero. There is no equip, remove, trade, or +revoke action. Future stat/effect hooks can extend this catalog without deciding +the final player stat list now. + +```yaml +- id: burdened_survivor + name: Burdened Survivor + description: Survive a world after defeating at least ten sentinels. + scope: personal + requirements: + - { metric: worldsSurvived, atLeast: 1 } + - { metric: kills, atLeast: 10 } + effects: { damage: 4, moveSpeed: -1 } +``` + +Worlds persist their balance and title catalogs. YAML edits apply to new world +IDs; they do not hot-edit existing worlds or already-earned titles. Existing +worlds without progression are upgraded once with the starter defaults on +restore, with no retroactive XP or automatic historical first claims. New +definitions can match existing counters on the next qualifying gameplay event. +Treat published title IDs as permanent identities. Use a new ID for a distinct +award rather than repurposing an existing one. + +## Verification and limits + +Game tests cover successful-action XP, multi-level grants, caps, migration, +signed effects, death, daily limits, and survivor progress. Store tests cover +durable title claims, first-award races, retries/rollback, inheritance, and stale +source worlds. PostgreSQL integration tests require `TEST_DATABASE_URL`. + +The tested world capacity is unchanged. This remains the existing checkpoint +persistence model: unacknowledged actions can be lost on a crash, and storage +failures freeze the owner before it can publish speculative progression. diff --git a/planning/VISION.md b/planning/VISION.md index 446123c..b26262f 100644 --- a/planning/VISION.md +++ b/planning/VISION.md @@ -64,6 +64,20 @@ Tracked across: - Bad karma accrues from starting player-kills / being the aggressor. - Good karma source — **unspecified, open question**. +## Player Progression and Titles +- Characters gain levels; every level-up awards stat points. +- The full stat list and allocation rules are still undecided. The first + implementation banks points without spending them. +- Titles have configurable requirements, a name, and positive or negative effects. +- Award scopes include personal achievements, first in a world, and first ever. +- Earned titles cannot be lost or transferred to another player. +- Initial implementation interprets player-bound titles as account-bound: they + carry to a replacement character after permanent death. Levels, XP, and banked + stat points belong to the individual character and survive survivor passage. + Account inheritance is an implementation assumption awaiting player-design confirmation. +- XP rewards, level curve, points per level, starter titles, and effect numbers + are provisional tuning in `server/content/balance.yaml`. + ## Open Questions - Good karma: what actions/behaviors generate it? — **undecided**. - Mob scaling mechanics: does it reset on world regen? Is scaling per-node, per-server, or world-wide? — **undecided**. diff --git a/schemas/protocol.json b/schemas/protocol.json index d0b3f9b..73c444c 100644 --- a/schemas/protocol.json +++ b/schemas/protocol.json @@ -38,11 +38,28 @@ "entity": {"$ref": "#/definitions/Entity"}, "inventory": {"type": "object", "additionalProperties": {"type": "integer"}}, "skills": {"type": "object", "additionalProperties": {"type": "integer"}}, + "level": {"type": "integer"}, "experience": {"type": "integer"}, + "experienceToNextLevel": {"type": "integer"}, "statPoints": {"type": "integer"}, + "titles": {"type": "array", "items": {"$ref": "#/definitions/TitleAward"}}, "playedSeconds": {"type": "number"}, "remainingSeconds": {"type": "number"}, "kills": {"type": "integer"}, "ack": {"type": "integer"}, "hasKeystone": {"type": "boolean"} }, - "required": ["entity", "inventory", "skills", "playedSeconds", "remainingSeconds", "kills", "ack", "hasKeystone"] + "required": ["entity", "inventory", "skills", "level", "experience", "experienceToNextLevel", "statPoints", "titles", "playedSeconds", "remainingSeconds", "kills", "ack", "hasKeystone"] + }, + "TitleEffects": { + "type": "object", "additionalProperties": false, + "properties": {"damage": {"type": "number"}, "moveSpeed": {"type": "number"}}, + "required": ["damage", "moveSpeed"] + }, + "TitleAward": { + "type": "object", "additionalProperties": false, + "properties": { + "id": {"type": "string"}, "name": {"type": "string"}, "description": {"type": "string"}, + "scope": {"type": "string"}, "worldId": {"type": "string"}, "earnedAt": {"type": "string"}, + "effects": {"$ref": "#/definitions/TitleEffects"} + }, + "required": ["id", "name", "description", "scope", "worldId", "earnedAt", "effects"] }, "Chunk": { "type": "object", "additionalProperties": false, diff --git a/server/content/balance.yaml b/server/content/balance.yaml index 17dca40..d8e90e8 100644 --- a/server/content/balance.yaml +++ b/server/content/balance.yaml @@ -46,3 +46,33 @@ recipes: inputs: { herb: 2 } outputs: { bandage: 1 } bandageHealing: 35 +# Provisional progression tuning; stat allocation waits for the full stat design. +progression: + baseXp: 100 + xpPerLevel: 50 + statPointsPerLevel: 5 + maxLevel: 1000 + gatherXp: 10 + craftXp: 20 + mobKillXp: 50 + bossKillXp: 500 +# Starter definitions. Requirements are ANDed; awarded definitions are immutable. +titles: + - id: wayfarer + name: Wayfarer + description: Reach level 2 in one life. + scope: personal + requirements: [{ metric: level, atLeast: 2 }] + effects: { damage: 1, moveSpeed: 0 } + - id: world_first_hunter + name: First Hunter of the World + description: Be the first to defeat a sentinel in this world. + scope: world + requirements: [{ metric: worldKills, atLeast: 1 }] + effects: { damage: 2, moveSpeed: 0 } + - id: first_hunter + name: The First Hunter + description: Be the first ever to defeat a sentinel. Power comes with a heavier step. + scope: global + requirements: [{ metric: worldKills, atLeast: 1 }] + effects: { damage: 3, moveSpeed: -0.5 } diff --git a/server/content/content.go b/server/content/content.go index 1a7e915..352d0bc 100644 --- a/server/content/content.go +++ b/server/content/content.go @@ -57,6 +57,8 @@ type Balance struct { StartingKit map[string]int64 `yaml:"startingKit"` Recipes map[string]Recipe `yaml:"recipes"` BandageHealing float64 `yaml:"bandageHealing"` + Progression *Progression `yaml:"progression"` + Titles []Title `yaml:"titles"` } func Load() (Balance, error) { return Parse(balance) } @@ -70,6 +72,9 @@ func Parse(data []byte) (Balance, error) { return b, b.Validate() } func (b Balance) Validate() error { + if err := b.validateProgression(); err != nil { + return err + } v := reflect.ValueOf(b) for i := 0; i < v.NumField(); i++ { f := v.Field(i) diff --git a/server/content/progression.go b/server/content/progression.go new file mode 100644 index 0000000..c2858a8 --- /dev/null +++ b/server/content/progression.go @@ -0,0 +1,88 @@ +package content + +import ( + "fmt" + "math" + "regexp" +) + +type Progression struct { + BaseXP int64 `yaml:"baseXp"` + XPPerLevel int64 `yaml:"xpPerLevel"` + StatPointsPerLevel int64 `yaml:"statPointsPerLevel"` + MaxLevel int64 `yaml:"maxLevel"` + GatherXP int64 `yaml:"gatherXp"` + CraftXP int64 `yaml:"craftXp"` + MobKillXP int64 `yaml:"mobKillXp"` + BossKillXP int64 `yaml:"bossKillXp"` +} + +type TitleRequirement struct { + Metric string `yaml:"metric"` + AtLeast int64 `yaml:"atLeast"` +} + +type TitleEffects struct { + Damage float64 `yaml:"damage"` + MoveSpeed float64 `yaml:"moveSpeed"` +} + +type Title struct { + ID string `yaml:"id"` + Name string `yaml:"name"` + Description string `yaml:"description"` + Scope string `yaml:"scope"` + Requirements []TitleRequirement `yaml:"requirements"` + Effects TitleEffects `yaml:"effects"` +} + +var titleID = regexp.MustCompile(`^[a-z][a-z0-9_-]{0,63}$`) + +func (b Balance) validateProgression() error { + if b.Progression == nil { + return fmt.Errorf("progression configuration is required") + } + if err := b.Progression.Validate(); err != nil { + return err + } + if len(b.Titles) > 256 { + return fmt.Errorf("too many title definitions") + } + seen := map[string]bool{} + metrics := map[string]bool{"level": true, "kills": true, "worldKills": true, "bossKills": true, "worldsSurvived": true, "gathering": true, "crafting": true, "combat": true, "deaths": true} + for _, title := range b.Titles { + if !titleID.MatchString(title.ID) || seen[title.ID] || len(title.Name) < 1 || len(title.Name) > 80 || len(title.Description) > 500 { + return fmt.Errorf("invalid or duplicate title %q", title.ID) + } + seen[title.ID] = true + if title.Scope != "personal" && title.Scope != "world" && title.Scope != "global" { + return fmt.Errorf("invalid title scope %q", title.Scope) + } + if len(title.Requirements) < 1 || len(title.Requirements) > 8 { + return fmt.Errorf("title %q needs bounded requirements", title.ID) + } + for _, r := range title.Requirements { + if !metrics[r.Metric] || r.AtLeast < 1 || r.AtLeast > 1000000000 { + return fmt.Errorf("invalid title requirement for %q", title.ID) + } + } + for _, effect := range []float64{title.Effects.Damage, title.Effects.MoveSpeed} { + if math.IsNaN(effect) || math.IsInf(effect, 0) || math.Abs(effect) > 1000 { + return fmt.Errorf("invalid title effect for %q", title.ID) + } + } + } + return nil +} + +func (p Progression) Validate() error { + if p.BaseXP < 1 || p.BaseXP > 1000000000 || p.XPPerLevel < 0 || p.XPPerLevel > 1000000000 || p.StatPointsPerLevel < 1 || p.StatPointsPerLevel > 1000 || p.MaxLevel < 2 || p.MaxLevel > 10000 { + return fmt.Errorf("invalid progression curve or stat point grant") + } + for _, xp := range []int64{p.GatherXP, p.CraftXP, p.MobKillXP, p.BossKillXP} { + if xp < 0 || xp > 1000000000 { + return fmt.Errorf("invalid progression XP reward") + } + } + return nil +} diff --git a/server/content/progression_test.go b/server/content/progression_test.go new file mode 100644 index 0000000..e6e4309 --- /dev/null +++ b/server/content/progression_test.go @@ -0,0 +1,43 @@ +package content + +import ( + "math" + "testing" +) + +func TestProgressionAndTitleValidation(t *testing.T) { + for name, mutate := range map[string]func(*Balance){ + "missing progression": func(b *Balance) { b.Progression = nil }, + "zero threshold": func(b *Balance) { b.Progression.BaseXP = 0 }, + "negative growth": func(b *Balance) { b.Progression.XPPerLevel = -1 }, + "point grant": func(b *Balance) { b.Progression.StatPointsPerLevel = 0 }, + "overflow curve": func(b *Balance) { b.Progression.BaseXP = math.MaxInt64 }, + "unbounded cap": func(b *Balance) { b.Progression.MaxLevel = math.MaxInt64 }, + "negative reward": func(b *Balance) { b.Progression.GatherXP = -1 }, + "duplicate title": func(b *Balance) { b.Titles = append(b.Titles, b.Titles[0]) }, + "bad scope": func(b *Balance) { b.Titles[0].Scope = "client" }, + "no requirements": func(b *Balance) { b.Titles[0].Requirements = nil }, + "unknown metric": func(b *Balance) { b.Titles[0].Requirements[0].Metric = "clientXp" }, + "invalid threshold": func(b *Balance) { b.Titles[0].Requirements[0].AtLeast = 0 }, + "infinite effect": func(b *Balance) { b.Titles[0].Effects.Damage = math.Inf(1) }, + "nan effect": func(b *Balance) { b.Titles[0].Effects.MoveSpeed = math.NaN() }, + } { + t.Run(name, func(t *testing.T) { + b, err := Load() + if err != nil { + t.Fatal(err) + } + mutate(&b) + if b.Validate() == nil { + t.Fatal("invalid content accepted") + } + }) + } + b, _ := Load() + b.Titles[0].Effects.Damage = -5 + b.Titles[0].Effects.MoveSpeed = -1 + b.Progression.GatherXP = 0 + if err := b.Validate(); err != nil { + t.Fatalf("valid penalty or disabled reward rejected: %v", err) + } +} diff --git a/server/internal/game/progression.go b/server/internal/game/progression.go new file mode 100644 index 0000000..1d4a9dc --- /dev/null +++ b/server/internal/game/progression.go @@ -0,0 +1,162 @@ +package game + +import ( + "errors" + "fmt" + "math" + "sort" + "time" + + p "aeternalis/server/internal/protocol" +) + +// Candidates are produced in simulation event order. Only a successful store +// transaction may turn them into permanent awards and enable their effects. +type TitleCandidate struct { + CharacterID string + Award p.TitleAward +} + +func (w *World) orderedCharacters() []*Character { + ids := make([]string, 0, len(w.Characters)) + for id := range w.Characters { + ids = append(ids, id) + } + sort.Strings(ids) + characters := make([]*Character, 0, len(ids)) + for _, id := range ids { + characters = append(characters, w.Characters[id]) + } + return characters +} + +func (w *World) restoreProgression(c *Character) error { + if c.Progression == nil { + rules := *w.Balance.Progression + c.Progression = &rules + } + if err := c.Progression.Validate(); err != nil { + return err + } + if c.View.Level == 0 { + c.View.Level = 1 + } + if c.View.Level < 1 || c.View.Level > c.Progression.MaxLevel || c.View.Experience < 0 || c.View.StatPoints < 0 { + return errors.New("invalid persisted character progression") + } + c.View.ExperienceToNextLevel = c.nextLevelXP() + if (c.View.ExperienceToNextLevel == 0 && c.View.Experience != 0) || (c.View.ExperienceToNextLevel > 0 && c.View.Experience >= c.View.ExperienceToNextLevel) { + return errors.New("invalid persisted level XP") + } + if c.View.Titles == nil { + c.View.Titles = []p.TitleAward{} + } + return nil +} + +func (c *Character) nextLevelXP() int64 { + if c.View.Level >= c.Progression.MaxLevel { + return 0 + } + return c.Progression.BaseXP + (c.View.Level-1)*c.Progression.XPPerLevel +} + +func (w *World) grantXP(c *Character, amount int64) { + if amount <= 0 || c.View.Entity.State != "alive" || c.View.Level >= c.Progression.MaxLevel { + return + } + c.View.Experience += amount + before := c.View.Level + for c.View.Level < c.Progression.MaxLevel && c.View.Experience >= c.nextLevelXP() { + c.View.Experience -= c.nextLevelXP() + c.View.Level++ + c.View.StatPoints += c.Progression.StatPointsPerLevel + } + c.View.ExperienceToNextLevel = c.nextLevelXP() + if c.View.ExperienceToNextLevel == 0 { + c.View.Experience = 0 + } + if c.View.Level > before { + c.Message = fmt.Sprintf("Level %d reached. %d stat points banked.", c.View.Level, c.View.StatPoints) + } + w.dirty = true +} + +func (w *World) evaluateTitles(c *Character) { + metric := func(name string) int64 { + switch name { + case "level": + return c.View.Level + case "kills": + return c.View.Kills + case "worldKills": + return c.WorldKills + case "bossKills": + return c.BossKills + case "worldsSurvived": + return c.WorldsSurvived + case "deaths": + if c.View.Entity.State == "dead" { + return 1 + } + return 0 + default: + return c.View.Skills[name] + } + } + for _, title := range w.Balance.Titles { + owned := false + for _, award := range c.View.Titles { + if award.ID == title.ID { + owned = true + break + } + } + if owned { + continue + } + for _, pending := range w.PendingTitles { + if pending.CharacterID == c.View.Entity.ID && pending.Award.ID == title.ID { + owned = true + break + } + } + if owned { + continue + } + eligible := true + for _, requirement := range title.Requirements { + if metric(requirement.Metric) < requirement.AtLeast { + eligible = false + break + } + } + if !eligible { + continue + } + w.PendingTitles = append(w.PendingTitles, TitleCandidate{CharacterID: c.View.Entity.ID, Award: p.TitleAward{ + ID: title.ID, Name: title.Name, Description: title.Description, Scope: title.Scope, WorldID: w.ID, + EarnedAt: w.now.UTC().Format(time.RFC3339Nano), Effects: p.TitleEffects{Damage: title.Effects.Damage, MoveSpeed: title.Effects.MoveSpeed}, + }}) + w.dirty = true + } +} + +func (c *Character) titleEffects() p.TitleEffects { + var effects p.TitleEffects + // One effect per permanent title ID, even if legacy data contains duplicates. + seen := map[string]bool{} + for _, title := range c.View.Titles { + if seen[title.ID] { + continue + } + seen[title.ID] = true + effects.Damage += title.Effects.Damage + effects.MoveSpeed += title.Effects.MoveSpeed + } + return effects +} + +func (w *World) playerSpeed(c *Character) float64 { + return math.Max(0, w.Balance.PlayerSpeed+c.titleEffects().MoveSpeed) +} diff --git a/server/internal/game/progression_test.go b/server/internal/game/progression_test.go new file mode 100644 index 0000000..103004f --- /dev/null +++ b/server/internal/game/progression_test.go @@ -0,0 +1,286 @@ +package game + +import ( + "encoding/json" + "math" + "reflect" + "sort" + "testing" + "time" + + "aeternalis/server/content" + p "aeternalis/server/internal/protocol" +) + +func TestLevelUpsBankPointsAndCap(t *testing.T) { + w, c := fixture(t) + if c.View.Level != 1 || c.View.StatPoints != 0 || c.View.ExperienceToNextLevel != 100 { + t.Fatal("incorrect new life progression") + } + w.grantXP(c, 99) + if c.View.Level != 1 || c.View.Experience != 99 { + t.Fatal("premature level") + } + w.grantXP(c, 151) + if c.View.Level != 3 || c.View.Experience != 0 || c.View.StatPoints != 10 || c.View.ExperienceToNextLevel != 200 { + t.Fatalf("multi-level award lost points or XP: %+v", c.View) + } + c.Progression.MaxLevel = 4 + w.grantXP(c, 1000000) + if c.View.Level != 4 || c.View.StatPoints != 15 || c.View.Experience != 0 || c.View.ExperienceToNextLevel != 0 { + t.Fatal("level cap failed") + } + w.grantXP(c, 1000000) + if c.View.StatPoints != 15 { + t.Fatal("cap farming granted extra points") + } +} + +func TestOnlySuccessfulActionsGrantXP(t *testing.T) { + w, c := fixture(t) + id := c.View.Entity.ID + w.now = w.now.Add(2 * time.Second) + for seq, op := range []string{"grant-xp", "level-up", "spend-stat", "grant-title", "remove-title", "gather", "craft", "attack"} { + if w.Intent(id, p.Intent{Op: op, Seq: int64(seq + 1), Target: "invalid"}) == nil { + t.Fatalf("invalid %s accepted", op) + } + } + if c.View.Experience != 0 || c.View.StatPoints != 0 || len(w.PendingTitles) != 0 { + t.Fatal("failed intent awarded progression") + } + c.View.Entity.Position = w.terrain.Position(17, 12) + if err := w.Intent(id, p.Intent{Op: "gather", Seq: 9, Target: "arrival:ore"}); err != nil { + t.Fatal(err) + } + if c.View.Experience != w.Balance.Progression.GatherXP { + t.Fatal("missing gather XP") + } + if w.Intent(id, p.Intent{Op: "gather", Seq: 10, Target: "arrival:ore"}) == nil { + t.Fatal("duplicate gather") + } + if c.View.Experience != w.Balance.Progression.GatherXP { + t.Fatal("failed gather gained XP") + } + c.View.Inventory["herb"] = 2 + if err := w.Intent(id, p.Intent{Op: "craft", Seq: 11, Target: "bandage"}); err != nil { + t.Fatal(err) + } + before := c.View.Experience + if before != w.Balance.Progression.GatherXP+w.Balance.Progression.CraftXP { + t.Fatal("missing craft XP") + } + w.Mobs["test"] = &Mob{Entity: p.Entity{ID: "test", HP: w.Balance.PlayerDamage + 1, Position: c.View.Entity.Position}} + if err := w.Intent(id, p.Intent{Op: "attack", Seq: 12, Target: "test"}); err != nil { + t.Fatal(err) + } + if c.View.Experience != before { + t.Fatal("nonlethal hit granted kill XP") + } + w.now = w.now.Add(time.Second) + if err := w.Intent(id, p.Intent{Op: "attack", Seq: 13, Target: "test"}); err != nil { + t.Fatal(err) + } + if c.View.Experience != before+w.Balance.Progression.MobKillXP || c.WorldKills != 1 { + t.Fatal("missing kill XP") + } + w.now = w.now.Add(time.Second) + if w.Intent(id, p.Intent{Op: "attack", Seq: 14, Target: "test"}) == nil { + t.Fatal("dead mob killed twice") + } + if c.View.Kills != 1 || c.View.Experience != before+w.Balance.Progression.MobKillXP { + t.Fatal("duplicate kill progression") + } +} + +func TestProgressionSurvivesRestartDeathAndTransfer(t *testing.T) { + w, c := fixture(t) + w.grantXP(c, 275) + c.View.Titles = []p.TitleAward{{ID: "bound", Name: "Bound", Scope: "personal", Effects: p.TitleEffects{Damage: 2}}} + c.DailySeconds = 123 + c.WorldKills = 7 + raw, err := json.Marshal(w) + if err != nil { + t.Fatal(err) + } + var restored World + if err = json.Unmarshal(raw, &restored); err != nil { + t.Fatal(err) + } + if err = restored.Restore(w.now); err != nil { + t.Fatal(err) + } + loaded := restored.Characters[c.View.Entity.ID] + if loaded.View.Level != 3 || loaded.View.Experience != 25 || loaded.View.StatPoints != 10 || !reflect.DeepEqual(loaded.View.Titles, c.View.Titles) { + t.Fatal("restart reset progression") + } + loaded.View.Entity.State = "eligible" + changed := w.Balance + rules := *changed.Progression + rules.BaseXP = 1 + rules.StatPointsPerLevel = 100 + changed.Progression = &rules + destination := New("destination", 999, w.now, changed) + if err = destination.Import(loaded); err != nil { + t.Fatal(err) + } + if loaded.View.ExperienceToNextLevel != 200 || loaded.Progression.StatPointsPerLevel != 5 || loaded.DailySeconds != 123 || loaded.WorldKills != 0 || loaded.View.StatPoints != 10 || len(loaded.View.Titles) != 1 { + t.Fatal("transfer altered progression, titles, or daily budget") + } + destination.kill(loaded, "test death") + destination.grantXP(loaded, 1000) + if loaded.View.StatPoints != 10 || loaded.View.Experience != 25 || len(loaded.View.Titles) != 1 { + t.Fatal("death erased progression or allowed postmortem XP") + } + replacement, err := destination.Join(loaded.Account, "Replacement") + if err != nil { + t.Fatal(err) + } + if replacement.View.Level != 1 || replacement.View.StatPoints != 0 || replacement.View.Entity.ID == loaded.View.Entity.ID { + t.Fatal("replacement inherited character levels") + } + if destination.Connect(loaded.View.Entity.ID) == nil { + t.Fatal("progression resurrected dead character") + } +} + +func TestLegacySnapshotProgressionMigrationIsIdempotent(t *testing.T) { + w, c := fixture(t) + w.Balance.Progression = nil + w.Balance.Titles = nil + c.Progression = nil + c.View.Level = 0 + c.View.ExperienceToNextLevel = 0 + c.View.Titles = nil + c.View.Kills = 42 + c.View.Skills["gathering"] = 99 + c.DailySeconds = 456 + c.View.Entity.State = "dead" + if err := w.Restore(w.now); err != nil { + t.Fatal(err) + } + if c.View.Level != 1 || c.View.Experience != 0 || c.View.StatPoints != 0 || c.View.Titles == nil || c.DailySeconds != 456 || c.View.Entity.State != "dead" { + t.Fatal("legacy migration changed life/budget or backfilled XP") + } + if err := w.Restore(w.now); err != nil { + t.Fatal(err) + } + if c.View.StatPoints != 0 || len(w.PendingTitles) != 0 { + t.Fatal("migration minted grants") + } +} + +func TestTitleRequirementsAndPendingAwardsHaveNoEffects(t *testing.T) { + w, c := fixture(t) + w.Balance.Titles = []content.Title{{ID: "trial", Name: "Trial", Scope: "world", Requirements: []content.TitleRequirement{{Metric: "level", AtLeast: 2}, {Metric: "worldKills", AtLeast: 1}}, Effects: content.TitleEffects{Damage: 3, MoveSpeed: -2}}} + w.grantXP(c, 100) + w.evaluateTitles(c) + if len(w.PendingTitles) != 0 { + t.Fatal("requirements were not ANDed") + } + c.WorldKills = 1 + w.evaluateTitles(c) + w.evaluateTitles(c) + if len(w.PendingTitles) != 1 || len(c.View.Titles) != 0 || w.playerSpeed(c) != w.Balance.PlayerSpeed { + t.Fatal("candidate duplicated or applied before durable award") + } + award := w.PendingTitles[0].Award + if award.WorldID != w.ID || award.Scope != "world" || award.Effects.MoveSpeed != -2 || award.EarnedAt == "" { + t.Fatal("candidate lost provenance or negative effect") + } + c.View.Titles = append(c.View.Titles, award) + w.PendingTitles = nil + w.Balance.Titles[0].Effects.MoveSpeed = 99 + c.WorldKills = 0 + w.evaluateTitles(c) + if len(w.PendingTitles) != 0 || w.playerSpeed(c) != w.Balance.PlayerSpeed-2 { + t.Fatal("lost requirement or edited catalog changed earned award") + } +} + +func TestSignedTitleEffectsAreServerAuthoritative(t *testing.T) { + w, c := fixture(t) + c.View.Titles = []p.TitleAward{{ID: "blessing", Effects: p.TitleEffects{Damage: 5, MoveSpeed: 2}}, {ID: "curse", Effects: p.TitleEffects{Damage: -2, MoveSpeed: -1}}} + w.now = w.now.Add(2 * time.Second) + if err := w.Intent(c.View.Entity.ID, p.Intent{Op: "move", Seq: 1, X: 1}); err != nil { + t.Fatal(err) + } + before := c.View.Entity.Position + w.Advance(w.now.Add(50*time.Millisecond), .05) + if math.Abs(distance(before, c.View.Entity.Position)-(w.Balance.PlayerSpeed+1)*.05) > 1e-8 { + t.Fatal("title movement effect not applied") + } + w.Mobs["target"] = &Mob{Entity: p.Entity{ID: "target", HP: 100, Position: c.View.Entity.Position}} + if err := w.Intent(c.View.Entity.ID, p.Intent{Op: "attack", Seq: 2, Target: "target"}); err != nil { + t.Fatal(err) + } + if w.Mobs["target"].Entity.HP != 100-w.Balance.PlayerDamage-3 { + t.Fatal("signed damage effects not applied") + } + c.View.Titles = append(c.View.Titles, p.TitleAward{ID: "heavy", Effects: p.TitleEffects{Damage: -1000, MoveSpeed: -1000}}) + if w.playerSpeed(c) != 0 { + t.Fatal("negative speed reversed movement") + } + w.now = w.now.Add(time.Second) + hp := w.Mobs["target"].Entity.HP + if err := w.Intent(c.View.Entity.ID, p.Intent{Op: "attack", Seq: 3, Target: "target"}); err != nil { + t.Fatal(err) + } + if w.Mobs["target"].Entity.HP != hp { + t.Fatal("negative damage healed target") + } + w.Balance.DailyPlaySeconds = 1 + c.View.Entity.HP = 20 + w.Advance(w.now.Add(2*time.Second), 2) + if c.Online || c.View.RemainingSeconds != 0 || c.View.Entity.HP != 50 { + t.Fatal("title effects weakened daily cap") + } +} + +func TestBossXPAndSurvivalMilestoneGrantedOnce(t *testing.T) { + w, c := fixture(t) + offline, _ := w.Join("offline", "Offline") + dead, _ := w.Join("dead", "Dead") + w.kill(dead, "test") + w.now = w.now.Add(time.Second) + if err := w.TriggerBoss(); err != nil { + t.Fatal(err) + } + w.BossHP = 1 + if err := w.Intent(c.View.Entity.ID, p.Intent{Op: "attack", Seq: 1, Target: "boss"}); err != nil { + t.Fatal(err) + } + if c.BossKills != 1 || c.WorldsSurvived != 1 || offline.WorldsSurvived != 1 || dead.WorldsSurvived != 0 || c.View.Level != 4 || c.View.Experience != 50 || c.View.StatPoints != 15 { + t.Fatal("incorrect boss progression") + } + if w.Intent(c.View.Entity.ID, p.Intent{Op: "attack", Seq: 2, Target: "boss"}) == nil { + t.Fatal("repeat boss kill") + } + if c.BossKills != 1 || c.View.StatPoints != 15 { + t.Fatal("duplicate boss rewards") + } +} + +func TestCollapseTitleMilestonesKeepDeterministicOrderAndDeath(t *testing.T) { + w, c := fixture(t) + w.Balance.Titles = []content.Title{{ID: "worlds_fallen", Name: "World's Fallen", Scope: "world", Requirements: []content.TitleRequirement{{Metric: "deaths", AtLeast: 1}}, Effects: content.TitleEffects{Damage: -1}}} + other, err := w.Join("other", "Other") + if err != nil { + t.Fatal(err) + } + c.Online = false + ids := []string{c.View.Entity.ID, other.View.Entity.ID} + sort.Strings(ids) + w.Advance(w.CreatedAt.Add(time.Duration(w.Balance.SeasonSeconds+w.Balance.CollapseSeconds+1)*time.Second), .05) + if w.Phase != "lost" || len(w.PendingTitles) != 2 { + t.Fatal("collapse did not queue death milestones") + } + for i, id := range ids { + if w.PendingTitles[i].CharacterID != id || w.Characters[id].View.Entity.State != "dead" || len(w.Characters[id].View.Titles) != 0 { + t.Fatal("simultaneous deaths changed award order, life state, or prematurely granted title") + } + w.kill(w.Characters[id], "duplicate") + } + if len(w.PendingTitles) != 2 { + t.Fatal("duplicate death milestone") + } +} diff --git a/server/internal/game/world.go b/server/internal/game/world.go index b035f01..d4abce7 100644 --- a/server/internal/game/world.go +++ b/server/internal/game/world.go @@ -14,22 +14,26 @@ import ( ) type Character struct { - View p.Character `json:"view"` - Account string `json:"account"` - Day string `json:"day"` - DailySeconds float64 `json:"dailySeconds"` - ReturnPosition *p.Vec3 `json:"returnPosition,omitempty"` - Sheltered bool `json:"sheltered"` - LastAttack float64 `json:"lastAttack"` - LastGather float64 `json:"lastGather"` - Online bool `json:"-"` - MoveX float64 `json:"-"` - MoveZ float64 `json:"-"` - LastMove time.Time `json:"-"` - Message string `json:"-"` - BornAt time.Time `json:"bornAt"` - DiedAt *time.Time `json:"diedAt,omitempty"` - DeathReason string `json:"deathReason,omitempty"` + View p.Character `json:"view"` + Account string `json:"account"` + Day string `json:"day"` + DailySeconds float64 `json:"dailySeconds"` + ReturnPosition *p.Vec3 `json:"returnPosition,omitempty"` + Sheltered bool `json:"sheltered"` + LastAttack float64 `json:"lastAttack"` + LastGather float64 `json:"lastGather"` + Online bool `json:"-"` + MoveX float64 `json:"-"` + MoveZ float64 `json:"-"` + LastMove time.Time `json:"-"` + Message string `json:"-"` + BornAt time.Time `json:"bornAt"` + DiedAt *time.Time `json:"diedAt,omitempty"` + DeathReason string `json:"deathReason,omitempty"` + Progression *content.Progression `json:"progression,omitempty"` + WorldKills int64 `json:"worldKills"` + BossKills int64 `json:"bossKills"` + WorldsSurvived int64 `json:"worldsSurvived"` } type Corpse struct { Entity p.Entity `json:"entity"` @@ -58,6 +62,7 @@ type World struct { Depleted map[string]float64 `json:"depleted"` Mobs map[string]*Mob `json:"mobs"` Balance content.Balance `json:"balance"` + PendingTitles []TitleCandidate `json:"-"` terrain *Terrain chunks map[string]p.Chunk now time.Time @@ -80,6 +85,19 @@ func (w *World) Restore(now time.Time) error { if w.Version != GeneratorVersion { return errors.New("unsupported persisted generator version") } + // Snapshots predating progression receive the YAML defaults once. Existing + // world tuning and character lives remain intact; old actions grant no backfill XP. + if w.Balance.Progression == nil { + defaults, err := content.Load() + if err != nil { + return err + } + w.Balance.Progression = defaults.Progression + if w.Balance.Titles == nil { + w.Balance.Titles = defaults.Titles + } + w.dirty = true + } if err := w.Balance.Validate(); err != nil { return err } @@ -89,7 +107,11 @@ func (w *World) Restore(now time.Time) error { w.terrain = NewTerrain(w.Seed, w.Balance) w.chunks = map[string]p.Chunk{} w.now = now + w.PendingTitles = nil for _, c := range w.Characters { + if err := w.restoreProgression(c); err != nil { + return err + } c.Online = false c.MoveX = 0 c.MoveZ = 0 @@ -177,11 +199,15 @@ func (w *World) Join(account, name string) (*Character, error) { return nil, err } c := &Character{Account: account, Day: w.now.UTC().Format(time.DateOnly), View: p.Character{Entity: p.Entity{ID: ID(), Kind: "player", Name: name, Position: pos, HP: w.Balance.PlayerHp, MaxHP: w.Balance.PlayerHp, State: "alive"}, Inventory: map[string]int64{}, Skills: map[string]int64{}, RemainingSeconds: w.Balance.DailyPlaySeconds}} + if err := w.restoreProgression(c); err != nil { + return nil, err + } for k, v := range w.Balance.StartingKit { c.View.Inventory[k] = v } w.Characters[c.View.Entity.ID] = c c.BornAt = w.now + w.evaluateTitles(c) w.dirty = true return c, nil } @@ -192,6 +218,9 @@ func (w *World) Import(c *Character) error { if c.View.Entity.State != "eligible" || c.View.Entity.HP <= 0 { return errors.New("character is not a living survivor") } + if err := w.restoreProgression(c); err != nil { + return err + } pos, err := w.spawn("") if err != nil { return err @@ -207,6 +236,7 @@ func (w *World) Import(c *Character) error { c.ReturnPosition = nil c.Sheltered = false c.View.HasKeystone = false + c.WorldKills = 0 w.resetDay(c) w.Characters[c.View.Entity.ID] = c w.dirty = true @@ -356,6 +386,8 @@ func (w *World) gather(c *Character, target string) error { w.Depleted[target] = w.Age() + w.Balance.ResourceRespawnSeconds w.dirty = true c.Message = "Gathered " + item + w.grantXP(c, w.Balance.Progression.GatherXP) + w.evaluateTitles(c) return nil } } @@ -379,6 +411,8 @@ func (w *World) craft(c *Character, name string) error { } c.View.Skills["crafting"] += w.Balance.SkillXpPerAction c.Message = "Crafted " + name + w.grantXP(c, w.Balance.Progression.CraftXP) + w.evaluateTitles(c) w.dirty = true return nil } @@ -390,17 +424,24 @@ func (w *World) attack(c *Character, target string) error { if c.View.Inventory["spear"] > 0 { damage = w.Balance.SpearDamage } + damage = math.Max(0, damage+c.titleEffects().Damage) if target == "boss" { if w.Phase != "cataclysm" || distance(c.View.Entity.Position, w.terrain.Position(0, 0)) > w.Balance.AttackRange+4 { return errors.New("boss out of reach") } w.BossHP = math.Max(0, w.BossHP-damage) if w.BossHP == 0 { + c.BossKills++ + w.grantXP(c, w.Balance.Progression.BossKillXP) + w.evaluateTitles(c) w.Phase = "won" ended := w.now w.EndedAt = &ended - for _, survivor := range w.Characters { + // Stable order for simultaneous survivor milestone candidates. + for _, survivor := range w.orderedCharacters() { if survivor.View.Entity.State == "alive" { + survivor.WorldsSurvived++ + w.evaluateTitles(survivor) survivor.View.Entity.State = "eligible" survivor.MoveX = 0 survivor.MoveZ = 0 @@ -418,11 +459,14 @@ func (w *World) attack(c *Character, target string) error { m.Entity.State = "dead" m.RespawnAt = w.Age() + w.Balance.MobRespawnSeconds c.View.Kills++ + c.WorldKills++ c.View.Inventory["herb"]++ + w.grantXP(c, w.Balance.Progression.MobKillXP) } } c.LastAttack = w.Age() c.View.Skills["combat"] += w.Balance.SkillXpPerAction + w.evaluateTitles(c) w.dirty = true return nil } @@ -447,6 +491,7 @@ func (w *World) kill(c *Character, reason string) { died := w.now c.DiedAt = &died c.DeathReason = reason + w.evaluateTitles(c) w.dirty = true } @@ -464,7 +509,7 @@ func (w *World) Control(op, target, value, reason string) error { if w.Phase == "won" || w.Phase == "lost" { return errors.New("world has already ended") } - for _, c := range w.Characters { + for _, c := range w.orderedCharacters() { w.kill(c, "World ended by an operator: "+reason) } w.Phase = "lost" @@ -508,7 +553,8 @@ func (w *World) Advance(now time.Time, dt float64) { w.dirty = true } active := map[string]bool{} - for _, c := range w.Characters { + characters := w.orderedCharacters() + for _, c := range characters { if c.View.Entity.State != "alive" { continue } @@ -541,7 +587,8 @@ func (w *World) Advance(now time.Time, dt float64) { c.MoveZ = 0 } pos := c.View.Entity.Position - nx, nz := pos.X+c.MoveX*w.Balance.PlayerSpeed*dt, pos.Z+c.MoveZ*w.Balance.PlayerSpeed*dt + speed := w.playerSpeed(c) + nx, nz := pos.X+c.MoveX*speed*dt, pos.Z+c.MoveZ*speed*dt if math.Hypot(nx, nz) < w.Balance.WorldRadius { c.View.Entity.Position = w.terrain.Position(nx, nz) } @@ -561,7 +608,7 @@ func (w *World) Advance(now time.Time, dt float64) { w.updateMobs(active, dt) if w.Phase == "cataclysm" { if w.Age()-w.BossLastAttack >= w.Balance.BossCooldown { - for _, c := range w.Characters { + for _, c := range characters { if c.Online && !c.Sheltered && c.View.Entity.State == "alive" && distance(c.View.Entity.Position, w.terrain.Position(0, 0)) <= w.Balance.BossRange { c.View.Entity.HP -= w.Balance.BossDamage w.dirty = true @@ -579,7 +626,7 @@ func (w *World) Advance(now time.Time, dt float64) { } } if w.SafeRadius() <= 0 || (len(w.Characters) > 0 && alive == 0) { - for _, c := range w.Characters { + for _, c := range characters { w.kill(c, "The world has been destroyed.") } w.Phase = "lost" @@ -613,7 +660,14 @@ func (w *World) ensureMob(ch p.Chunk) { w.Mobs[id] = &Mob{Entity: p.Entity{ID: id, Kind: "sentinel", Name: "Ash sentinel", Position: w.terrain.Position(x, z), HP: hp, MaxHP: hp, State: "alive"}, HomeX: int(ch.X), HomeZ: int(ch.Z)} } func (w *World) updateMobs(active map[string]bool, dt float64) { - for id, m := range w.Mobs { + mobIDs := make([]string, 0, len(w.Mobs)) + for id := range w.Mobs { + mobIDs = append(mobIDs, id) + } + sort.Strings(mobIDs) + characters := w.orderedCharacters() + for _, id := range mobIDs { + m := w.Mobs[id] key := Key(m.HomeX, m.HomeZ) if !active[key] { if m.Entity.HP == m.Entity.MaxHP || (m.Entity.HP <= 0 && w.Age() >= m.RespawnAt) { @@ -631,7 +685,7 @@ func (w *World) updateMobs(active map[string]bool, dt float64) { } var target *Character nearest := w.Balance.MobAggroRange - for _, c := range w.Characters { + for _, c := range characters { if !c.Online || c.View.Entity.State != "alive" || c.Sheltered { continue } diff --git a/server/internal/protocol/generated.go b/server/internal/protocol/generated.go index a4ae431..efd396e 100644 --- a/server/internal/protocol/generated.go +++ b/server/internal/protocol/generated.go @@ -55,14 +55,34 @@ type Vec3 struct { } type Character struct { - ACK int64 `json:"ack"` - Entity Entity `json:"entity"` - HasKeystone bool `json:"hasKeystone"` - Inventory map[string]int64 `json:"inventory"` - Kills int64 `json:"kills"` - PlayedSeconds float64 `json:"playedSeconds"` - RemainingSeconds float64 `json:"remainingSeconds"` - Skills map[string]int64 `json:"skills"` + ACK int64 `json:"ack"` + Entity Entity `json:"entity"` + Experience int64 `json:"experience"` + ExperienceToNextLevel int64 `json:"experienceToNextLevel"` + HasKeystone bool `json:"hasKeystone"` + Inventory map[string]int64 `json:"inventory"` + Kills int64 `json:"kills"` + Level int64 `json:"level"` + PlayedSeconds float64 `json:"playedSeconds"` + RemainingSeconds float64 `json:"remainingSeconds"` + Skills map[string]int64 `json:"skills"` + StatPoints int64 `json:"statPoints"` + Titles []TitleAward `json:"titles"` +} + +type TitleAward struct { + Description string `json:"description"` + EarnedAt string `json:"earnedAt"` + Effects TitleEffects `json:"effects"` + ID string `json:"id"` + Name string `json:"name"` + Scope string `json:"scope"` + WorldID string `json:"worldId"` +} + +type TitleEffects struct { + Damage float64 `json:"damage"` + MoveSpeed float64 `json:"moveSpeed"` } type WorldInfo struct { diff --git a/server/internal/store/portal.go b/server/internal/store/portal.go index d85df4c..21a2d5b 100644 --- a/server/internal/store/portal.go +++ b/server/internal/store/portal.go @@ -64,6 +64,7 @@ func (d *DB) migrate(ctx context.Context) error { } for _, stmt := range []string{ `CREATE TABLE IF NOT EXISTS schema_migrations(version INTEGER PRIMARY KEY)`, + `CREATE TABLE IF NOT EXISTS title_awards(account_id TEXT NOT NULL, title_id TEXT NOT NULL, scope TEXT NOT NULL, scope_key TEXT NOT NULL, character_id TEXT NOT NULL, award TEXT NOT NULL, PRIMARY KEY(account_id,title_id), UNIQUE(scope,scope_key,title_id))`, `CREATE TABLE IF NOT EXISTS character_records(character_id TEXT PRIMARY KEY, account_id TEXT NOT NULL, world_id TEXT NOT NULL, name TEXT NOT NULL, state TEXT NOT NULL, character TEXT NOT NULL)`, `CREATE UNIQUE INDEX IF NOT EXISTS one_living_character ON character_records(account_id) WHERE state IN ('alive','eligible')`, `CREATE INDEX IF NOT EXISTS characters_world ON character_records(world_id)`, diff --git a/server/internal/store/store.go b/server/internal/store/store.go index 571abea..73e7476 100644 --- a/server/internal/store/store.go +++ b/server/internal/store/store.go @@ -135,6 +135,8 @@ func (l *Lease) Save(ctx context.Context, w *game.World, claimID string) error { return l.SaveCommand(ctx, w, claimID, nil, "") } func (l *Lease) SaveCommand(ctx context.Context, w *game.World, claimID string, command *Command, outcome string) error { + live := w + w = stageTitleWorld(w) data, err := json.Marshal(w) if err != nil { return err @@ -167,20 +169,26 @@ func (l *Lease) SaveCommand(ctx context.Context, w *game.World, claimID string, return errors.New("passage already redeemed or unavailable") } } - if w.Phase == "won" { - for _, c := range w.Characters { - if c.View.Entity.State != "eligible" { - continue - } - encoded, err := json.Marshal(c) - if err != nil { - return err - } - _, err = tx.ExecContext(ctx, d.q(`INSERT INTO passages(character_id,account_id,source_world,character) VALUES(?,?,?,?) ON CONFLICT(character_id) DO UPDATE SET source_world=excluded.source_world,character=excluded.character,claimed_world=NULL WHERE passages.claimed_world=excluded.source_world`), c.View.Entity.ID, c.Account, w.ID, string(encoded)) - if err != nil { - return err - } - } + if err = d.syncPassages(ctx, tx, w); err != nil { + return err + } + if err = d.syncCharacters(ctx, tx, w, claimID); err != nil { + return err + } + if err = d.syncTitles(ctx, tx, w); err != nil { + return err + } + // Rewrite the final payloads after the immutable award claims have resolved. + // The transaction already holds the owner, passage and character row locks. + data, err = json.Marshal(w) + if err != nil { + return err + } + if _, err = tx.ExecContext(ctx, d.q(`UPDATE worlds SET snapshot=? WHERE id=? AND owner=?`), string(data), l.WorldID, l.Owner); err != nil { + return err + } + if err = d.syncPassages(ctx, tx, w); err != nil { + return err } if err = d.syncCharacters(ctx, tx, w, claimID); err != nil { return err @@ -208,7 +216,11 @@ func (l *Lease) SaveCommand(ctx context.Context, w *game.World, claimID string, return err } l.Revision++ - w.Saved() + for id, c := range w.Characters { + live.Characters[id].View.Titles = c.View.Titles + } + live.PendingTitles = nil + live.Saved() return nil } func (l *Lease) Release(ctx context.Context) error { diff --git a/server/internal/store/titles.go b/server/internal/store/titles.go new file mode 100644 index 0000000..e3a02f5 --- /dev/null +++ b/server/internal/store/titles.go @@ -0,0 +1,167 @@ +package store + +import ( + "context" + "database/sql" + "encoding/json" + "errors" + "sort" + + "aeternalis/server/internal/game" + p "aeternalis/server/internal/protocol" +) + +// Only title slices change in this staged view. The live simulation is untouched +// until its snapshot, claim ledger, character records and passages all commit. +func stageTitleWorld(w *game.World) *game.World { + staged := *w + staged.Characters = make(map[string]*game.Character, len(w.Characters)) + for id, c := range w.Characters { + copy := *c + copy.View.Titles = append([]p.TitleAward{}, c.View.Titles...) + staged.Characters[id] = © + } + return &staged +} + +func (d *DB) syncTitles(ctx context.Context, tx *sql.Tx, w *game.World) error { + // syncCharacters has already locked these rows. A stale source world may + // checkpoint itself, but it cannot grant titles for a transferred character. + owned := make(map[string]bool, len(w.Characters)) + for id, c := range w.Characters { + var account, world string + err := tx.QueryRowContext(ctx, d.q(`SELECT account_id,world_id FROM character_records WHERE character_id=?`), id).Scan(&account, &world) + if err != nil { + return err + } + owned[id] = account == c.Account && world == w.ID + } + candidates := append([]game.TitleCandidate{}, w.PendingTitles...) + // All owners lock title IDs in the same order, even with different catalogs. + // Stable ordering preserves simulation event order for contenders for one ID. + sort.SliceStable(candidates, func(i, j int) bool { return candidates[i].Award.ID < candidates[j].Award.ID }) + granted := map[string]map[string]bool{} + for _, candidate := range candidates { + c := w.Characters[candidate.CharacterID] + if c == nil || !owned[candidate.CharacterID] { + continue + } + award := candidate.Award + if award.ID == "" || award.WorldID != w.ID { + return errors.New("invalid title candidate identity") + } + key := "" + switch award.Scope { + case "personal": + key = c.Account + case "world": + key = w.ID + case "global": + key = "global" + default: + return errors.New("invalid title candidate scope") + } + raw, err := json.Marshal(award) + if err != nil { + return err + } + result, err := tx.ExecContext(ctx, d.q(`INSERT INTO title_awards(account_id,title_id,scope,scope_key,character_id,award) VALUES(?,?,?,?,?,?) ON CONFLICT DO NOTHING`), c.Account, award.ID, award.Scope, key, candidate.CharacterID, string(raw)) + if err != nil { + return err + } + count, err := result.RowsAffected() + if err != nil { + return err + } + if count == 1 { + if granted[candidate.CharacterID] == nil { + granted[candidate.CharacterID] = map[string]bool{} + } + granted[candidate.CharacterID][award.ID] = true + } + } + byAccount := map[string][]p.TitleAward{} + for id, c := range w.Characters { + if !owned[id] { + continue + } + awards, loaded := byAccount[c.Account] + if !loaded { + var err error + awards, err = d.accountTitles(ctx, tx, c.Account) + if err != nil { + return err + } + byAccount[c.Account] = awards + } + if c.View.Entity.State != "dead" { + c.View.Titles = append([]p.TitleAward{}, awards...) + continue + } + // A historical dead life keeps its own record. Only awards from its death + // transaction are appended; titles from later lives do not rewrite history. + keep := map[string]bool{} + for _, award := range c.View.Titles { + keep[award.ID] = true + } + for title := range granted[id] { + keep[title] = true + } + c.View.Titles = []p.TitleAward{} + for _, award := range awards { + if keep[award.ID] { + c.View.Titles = append(c.View.Titles, award) + } + } + } + return nil +} + +func (d *DB) accountTitles(ctx context.Context, tx *sql.Tx, account string) ([]p.TitleAward, error) { + rows, err := tx.QueryContext(ctx, d.q(`SELECT award FROM title_awards WHERE account_id=? ORDER BY title_id`), account) + if err != nil { + return nil, err + } + defer rows.Close() + awards := []p.TitleAward{} + for rows.Next() { + var raw string + var award p.TitleAward + if err = rows.Scan(&raw); err != nil { + return nil, err + } + if err = json.Unmarshal([]byte(raw), &award); err != nil { + return nil, err + } + awards = append(awards, award) + } + return awards, rows.Err() +} + +func (d *DB) syncPassages(ctx context.Context, tx *sql.Tx, w *game.World) error { + if w.Phase != "won" { + return nil + } + // Stable row order also prevents competing owners from acquiring survivor + // passage locks in opposite map iteration order. + ids := make([]string, 0, len(w.Characters)) + for id := range w.Characters { + ids = append(ids, id) + } + sort.Strings(ids) + for _, id := range ids { + c := w.Characters[id] + if c.View.Entity.State != "eligible" { + continue + } + encoded, err := json.Marshal(c) + if err != nil { + return err + } + _, err = tx.ExecContext(ctx, d.q(`INSERT INTO passages(character_id,account_id,source_world,character) VALUES(?,?,?,?) ON CONFLICT(character_id) DO UPDATE SET source_world=excluded.source_world,character=excluded.character,claimed_world=NULL WHERE passages.claimed_world=excluded.source_world OR (passages.source_world=excluded.source_world AND passages.claimed_world IS NULL)`), c.View.Entity.ID, c.Account, w.ID, string(encoded)) + if err != nil { + return err + } + } + return nil +} diff --git a/server/internal/store/titles_test.go b/server/internal/store/titles_test.go new file mode 100644 index 0000000..d072aec --- /dev/null +++ b/server/internal/store/titles_test.go @@ -0,0 +1,292 @@ +package store + +import ( + "context" + "encoding/json" + "os" + "path/filepath" + "reflect" + "sync" + "testing" + "time" + + "aeternalis/server/content" + "aeternalis/server/internal/game" + p "aeternalis/server/internal/protocol" +) + +func titleCandidate(w *game.World, c *game.Character, id, scope string) game.TitleCandidate { + return game.TitleCandidate{CharacterID: c.View.Entity.ID, Award: p.TitleAward{ID: id, Name: id, Description: "A permanent test title", Scope: scope, WorldID: w.ID, EarnedAt: time.Now().UTC().Format(time.RFC3339Nano), Effects: p.TitleEffects{Damage: 2, MoveSpeed: -.5}}} +} + +func TestTitlePersistence(t *testing.T) { + runTitleTests(t, "file:"+filepath.ToSlash(filepath.Join(t.TempDir(), "titles.db"))) +} +func TestPostgresTitlePersistence(t *testing.T) { + dsn := os.Getenv("TEST_DATABASE_URL") + if dsn == "" { + t.Skip("TEST_DATABASE_URL not configured") + } + runTitleTests(t, dsn) +} +func runTitleTests(t *testing.T, dsn string) { + ctx := context.Background() + db, err := Open(ctx, dsn) + if err != nil { + t.Fatal(err) + } + defer db.Close() + b, err := content.Load() + if err != nil { + t.Fatal(err) + } + prefix := game.ID() + makeWorld := func(suffix string) (*game.World, *Lease, *game.Character) { + t.Helper() + w := game.New(prefix+suffix, 1, time.Now().UTC(), b) + l, _, err := db.Acquire(ctx, w) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = l.Release(ctx) }) + c, err := w.Join(prefix+suffix, "Traveler") + if err != nil { + t.Fatal(err) + } + return w, l, c + } + count := func(id string) int { + t.Helper() + var n int + if err := db.sql.QueryRowContext(ctx, db.q(`SELECT count(*) FROM title_awards WHERE title_id=?`), id).Scan(&n); err != nil { + t.Fatal(err) + } + return n + } + has := func(c *game.Character, id string) bool { + for _, a := range c.View.Titles { + if a.ID == id { + return true + } + } + return false + } + + t.Run("permanent inheritance and immutable history", func(t *testing.T) { + w, l, c := makeWorld("-life") + id := prefix + "-personal" + w.PendingTitles = []game.TitleCandidate{titleCandidate(w, c, id, "personal")} + if err := l.Save(ctx, w, ""); err != nil { + t.Fatal(err) + } + original := c.View.Titles[0] + if count(id) != 1 || len(w.PendingTitles) != 0 { + t.Fatal("award not committed") + } + c.View.Titles[0].Name = "Changed" + c.View.Titles[0].Effects.Damage = 999 + w.PendingTitles = []game.TitleCandidate{titleCandidate(w, c, id, "personal")} + if err := l.Save(ctx, w, ""); err != nil { + t.Fatal(err) + } + if count(id) != 1 || !reflect.DeepEqual(c.View.Titles, []p.TitleAward{original}) { + t.Fatal("retry changed immutable title") + } + if err := w.Control("retire", c.View.Entity.ID, "", "test"); err != nil { + t.Fatal(err) + } + if err := l.Save(ctx, w, ""); err != nil { + t.Fatal(err) + } + next, err := w.Join(c.Account, "Replacement") + if err != nil { + t.Fatal(err) + } + if err := l.Save(ctx, w, ""); err != nil { + t.Fatal(err) + } + if !has(next, id) || !has(c, id) || next.View.Level != 1 || c.View.Entity.State != "dead" { + t.Fatal("death lost title or resurrected life") + } + later := prefix + "-later" + w.PendingTitles = []game.TitleCandidate{titleCandidate(w, next, later, "personal")} + if err := l.Save(ctx, w, ""); err != nil { + t.Fatal(err) + } + if has(c, later) || !has(next, later) { + t.Fatal("later life rewrote dead history") + } + if err := l.Release(ctx); err != nil { + t.Fatal(err) + } + restoredLease, raw, err := db.Acquire(ctx, w) + if err != nil { + t.Fatal(err) + } + defer restoredLease.Release(ctx) + var restored game.World + if err = json.Unmarshal(raw, &restored); err != nil { + t.Fatal(err) + } + if err = restored.Restore(time.Now()); err != nil { + t.Fatal(err) + } + if !has(restored.Characters[next.View.Entity.ID], id) || restored.Characters[c.View.Entity.ID].View.Entity.State != "dead" { + t.Fatal("restart lost titles or death") + } + }) + + t.Run("global race and independent world firsts", func(t *testing.T) { + a, la, ca := makeWorld("-race-a") + z, lz, cz := makeWorld("-race-z") + global, world := prefix+"-global", prefix+"-world" + a.PendingTitles = []game.TitleCandidate{titleCandidate(a, ca, world, "world"), titleCandidate(a, ca, global, "global")} + z.PendingTitles = []game.TitleCandidate{titleCandidate(z, cz, global, "global"), titleCandidate(z, cz, world, "world")} + var wg sync.WaitGroup + results := make(chan error, 2) + for _, pair := range []struct { + w *game.World + l *Lease + }{{a, la}, {z, lz}} { + wg.Add(1) + go func(w *game.World, l *Lease) { defer wg.Done(); results <- l.Save(ctx, w, "") }(pair.w, pair.l) + } + wg.Wait() + close(results) + for err := range results { + if err != nil { + t.Fatal(err) + } + } + winners := 0 + for _, c := range []*game.Character{ca, cz} { + if has(c, global) { + winners++ + } + if !has(c, world) { + t.Fatal("first in own world denied") + } + } + if winners != 1 || count(global) != 1 || count(world) != 2 { + t.Fatal("global first duplicated or world scopes shared") + } + other, err := a.Join(prefix+"-contender", "Contender") + if err != nil { + t.Fatal(err) + } + a.PendingTitles = []game.TitleCandidate{titleCandidate(a, other, world, "world"), titleCandidate(a, other, global, "global")} + if err = la.Save(ctx, a, ""); err != nil { + t.Fatal(err) + } + if has(other, global) || has(other, world) { + t.Fatal("late contender stole first") + } + }) + + t.Run("event order beats character map order", func(t *testing.T) { + w, l, c := makeWorld("-order") + other, err := w.Join(prefix+"-order-other", "Other") + if err != nil { + t.Fatal(err) + } + id := prefix + "-order-title" + w.PendingTitles = []game.TitleCandidate{titleCandidate(w, other, id, "world"), titleCandidate(w, c, id, "world")} + if err = l.Save(ctx, w, ""); err != nil { + t.Fatal(err) + } + if !has(other, id) || has(c, id) { + t.Fatal("first simulation candidate lost") + } + }) + + t.Run("late transaction failure rolls back claims and view", func(t *testing.T) { + w, l, c := makeWorld("-rollback") + id := prefix + "-rollback-title" + w.PendingTitles = []game.TitleCandidate{titleCandidate(w, c, id, "global")} + before := l.Revision + if err := l.SaveCommand(ctx, w, "", &Command{ID: "missing-command"}, ""); err == nil { + t.Fatal("missing command committed") + } + if count(id) != 0 || len(c.View.Titles) != 0 || len(w.PendingTitles) != 1 || l.Revision != before { + t.Fatal("failed save leaked title state") + } + if err := l.Save(ctx, w, ""); err != nil { + t.Fatal(err) + } + if count(id) != 1 || !has(c, id) { + t.Fatal("retry failed after rollback") + } + if err := l.Release(ctx); err != nil { + t.Fatal(err) + } + replacement, _, err := db.Acquire(ctx, w) + if err != nil { + t.Fatal(err) + } + defer replacement.Release(ctx) + stale := prefix + "-stale-title" + w.PendingTitles = []game.TitleCandidate{titleCandidate(w, c, stale, "global")} + if err = l.Save(ctx, w, ""); err == nil { + t.Fatal("stale owner saved") + } + if count(stale) != 0 || has(c, stale) { + t.Fatal("stale owner claimed title") + } + }) + + t.Run("victory transfer and stale source", func(t *testing.T) { + source, ls, c := makeWorld("-source") + id := prefix + "-survivor" + source.PendingTitles = []game.TitleCandidate{titleCandidate(source, c, id, "global")} + c.View.Level = 2 + c.View.Experience = 20 + c.View.ExperienceToNextLevel = 150 + c.View.StatPoints = 5 + c.DailySeconds = 123 + c.View.Entity.State = "eligible" + source.Phase = "won" + if err := ls.Save(ctx, source, ""); err != nil { + t.Fatal(err) + } + survivor, err := db.ReadPassage(ctx, c.View.Entity.ID, c.Account) + if err != nil { + t.Fatal(err) + } + if !has(survivor, id) { + t.Fatal("victory passage missed same-transaction title") + } + target := game.New(prefix+"-destination", 2, time.Now().UTC(), b) + lt, _, err := db.Acquire(ctx, target) + if err != nil { + t.Fatal(err) + } + defer lt.Release(ctx) + if err = target.Import(survivor); err != nil { + t.Fatal(err) + } + if err = lt.Save(ctx, target, c.View.Entity.ID); err != nil { + t.Fatal(err) + } + if !has(survivor, id) || survivor.View.StatPoints != 5 || survivor.View.Experience != 20 || survivor.DailySeconds != 123 { + t.Fatal("passage lost progression") + } + forbidden := prefix + "-source-forbidden" + source.PendingTitles = []game.TitleCandidate{titleCandidate(source, c, forbidden, "global")} + if err = ls.Save(ctx, source, ""); err != nil { + t.Fatal(err) + } + if count(forbidden) != 0 || has(c, forbidden) { + t.Fatal("old source granted new title") + } + active, err := db.ActiveCharacter(ctx, c.Account) + if err != nil { + t.Fatal(err) + } + if active.WorldID != target.ID || !has(active.Character, id) { + t.Fatal("source overwrote destination") + } + if _, err = db.ReadPassage(ctx, c.View.Entity.ID, c.Account); err == nil { + t.Fatal("source reopened spent passage") + } + }) +} diff --git a/server/internal/transport/control.go b/server/internal/transport/control.go index 9e2351d..9d01b3b 100644 --- a/server/internal/transport/control.go +++ b/server/internal/transport/control.go @@ -22,7 +22,7 @@ func (h *HTTP) admin(w http.ResponseWriter, r *http.Request) (string, bool) { return "", false } if !h.auth.isAdmin(r) { - fail(w, 403, "Administrator access required. Sign in again with the configured Keycloak role.") + fail(w, 403, "Administrator access required. Your Keycloak ID token must include the role \""+h.auth.AdminRole+"\". Sign in again after assigning it.") return "", false } return account, true diff --git a/server/internal/transport/control_test.go b/server/internal/transport/control_test.go index 810c762..3932d13 100644 --- a/server/internal/transport/control_test.go +++ b/server/internal/transport/control_test.go @@ -115,3 +115,28 @@ func TestKeycloakRolesAndReturnURL(t *testing.T) { t.Fatal("game return lost or untrusted query retained") } } + +func TestAdminRoleClaimsMatchExactlyAndOnlyOwnClient(t *testing.T) { + for _, tc := range []struct { + name, raw string + want bool + }{ + {"realm role", `{"realm_access":{"roles":["aeternalis-admin"]}}`, true}, + {"client role", `{"resource_access":{"game":{"roles":["aeternalis-admin"]}}}`, true}, + {"other client", `{"resource_access":{"other":{"roles":["aeternalis-admin"]}}}`, false}, + {"player", `{"realm_access":{"roles":["player"]}}`, false}, + {"case mismatch", `{"realm_access":{"roles":["Aeternalis-admin"]}}`, false}, + {"substring", `{"realm_access":{"roles":["not-aeternalis-admin"]}}`, false}, + {"missing", `{}`, false}, + } { + t.Run(tc.name, func(t *testing.T) { + var claims roleClaims + if err := json.Unmarshal([]byte(tc.raw), &claims); err != nil { + t.Fatal(err) + } + if claims.admin("aeternalis-admin", "game") != tc.want { + t.Fatal("incorrect role access") + } + }) + } +} diff --git a/server/internal/transport/service.go b/server/internal/transport/service.go index 8b07ed6..4ae9070 100644 --- a/server/internal/transport/service.go +++ b/server/internal/transport/service.go @@ -177,6 +177,7 @@ func (s *Service) join(ctx context.Context, account, name, claim string) (p.Char view := c.View view.Inventory = maps.Clone(view.Inventory) view.Skills = maps.Clone(view.Skills) + view.Titles = append([]p.TitleAward{}, view.Titles...) return view, nil } diff --git a/tests/progression.spec.ts b/tests/progression.spec.ts new file mode 100644 index 0000000..da2b238 --- /dev/null +++ b/tests/progression.spec.ts @@ -0,0 +1,58 @@ +import { test, expect } from '@playwright/test'; +import type { Character, Snapshot } from '../client/src/generated'; + +test('progression and signed permanent titles render in game, account, and admin views', async ({ page, request }) => { + const errors: string[] = []; page.on('pageerror', error => errors.push(error.message)); + const character: Character = { + entity: { id: 'progression-fixture', kind: 'player', name: 'Title bearer', state: 'alive', hp: 100, maxHp: 100, position: { x: 0, y: 0, z: 0 } }, + inventory: { knife: 1 }, skills: { combat: 2 }, kills: 2, ack: 0, hasKeystone: false, + playedSeconds: 120, remainingSeconds: 7080, level: 2, experience: 40, experienceToNextLevel: 150, statPoints: 5, + titles: [{ id: 'first-hunter-fixture', name: 'The First Hunter', description: 'Power comes with a heavier step.', scope: 'global', worldId: 'e2e', earnedAt: '2026-09-06T12:00:00Z', effects: { damage: 3, moveSpeed: -0.5 } }], + }; + const record = { id: character.entity.id, account: 'fixture-account', worldId: 'e2e', name: character.entity.name, state: 'alive', character: { view: character, bornAt: '2026-09-06T11:00:00Z', dailySeconds: 120 } }; + const worlds = await (await request.get('/api/worlds')).json(); + const chunks = await (await request.get('/worlds/e2e/api/preview')).json(); + await page.route('**/api/me', route => route.fulfill({ json: { character } })); + await page.route('**/api/account', route => route.fulfill({ json: { active: record, characters: [record], admin: true } })); + await page.route('**/api/control?*', route => route.fulfill({ json: { worlds, characters: [record], commands: [], provisioningEnabled: false, characterLimit: 500, auditLimit: 100 } })); + let sendSnapshot: () => void = () => {}; + await page.routeWebSocket('**/ws', socket => { + sendSnapshot = () => { + const snapshot: Snapshot = { type: 'snapshot', version: 1, tick: 1, self: character, chunks, chunkKeys: chunks.map(c => c.key), entities: [], unavailableResources: [], message: '', + world: { id: 'e2e', seed: 1, phase: 'gathering', ageSeconds: 120, bossInSeconds: 3600, collapseInSeconds: 5400, safeRadius: 1024, radius: 1024, online: 1, capacity: 100, bossHp: 1200, bossMaxHp: 1200 } }; + socket.send(JSON.stringify(snapshot)); + }; + sendSnapshot(); + }); + await page.setViewportSize({ width: 1440, height: 900 }); + await page.goto('/game?world=e2e'); + await expect(page.locator('#character-level')).toHaveText('Level 2'); + await expect(page.locator('#character-experience')).toHaveText('40 / 150 XP'); + await expect(page.locator('#stat-point-bank')).toHaveText('5 stat points saved'); + await page.getByRole('button', { name: 'Inventory and crafting' }).click(); + await expect(page.locator('#earned-titles')).toContainText('+3 damage'); + await expect(page.locator('#earned-titles')).toContainText('-0.5 movement speed'); + await expect(page.locator('#earned-titles')).toContainText('First ever'); + await page.screenshot({ path: 'test-results/progression-desktop.png' }); + await page.setViewportSize({ width: 390, height: 844 }); + expect(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth)).toBe(true); + await expect(page.locator('#earned-titles .earned-title')).toBeVisible(); + await page.screenshot({ path: 'test-results/progression-mobile.png' }); + character.level = 1000; character.experience = 0; character.experienceToNextLevel = 0; character.statPoints = 4995; + sendSnapshot(); + await expect(page.locator('#character-experience')).toHaveText('Level cap'); + await expect(page.locator('#experience-meter')).toHaveAttribute('aria-valuetext', 'Level 1000: Level cap'); + await page.goto('/'); + await expect(page.locator('#active-character')).toContainText('4995 stat points saved'); + await expect(page.locator('#active-character')).toContainText('-0.5 movement speed'); + expect(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth)).toBe(true); + await page.setViewportSize({ width: 1440, height: 1000 }); + await page.goto('/control'); + await page.getByRole('button', { name: 'Characters', exact: true }).click(); + await page.getByRole('button', { name: 'Title bearer', exact: true }).click(); + await expect(page.locator('#character-detail')).toContainText('Level 1000'); + await expect(page.locator('#character-detail')).toContainText('+3 damage'); + await expect(page.locator('#character-detail')).toContainText('-0.5 movement speed'); + await page.screenshot({ path: 'test-results/progression-control.png' }); + expect(errors).toEqual([]); +});