diff --git a/docs/API.md b/docs/API.md index f367292..3cae790 100644 --- a/docs/API.md +++ b/docs/API.md @@ -118,3 +118,56 @@ firewall, loot, siege, takeover/loyalty), `scan` (attacker; intel when it succee if the defender's scanners won), `incumbent`, `settle`, `reinforce`, `movement_failed`. Later stages append their routes here and to the route table. + +## Trade, end game, shared reports (stage 5 rest, stage 7 start) + +**Internet exchange trade.** Offers "give X of A for Y of B within Z tiles". Amounts are whole numbers, each side 1..500 (one transport +link), the two amounts differ by at most 1:2, the resources differ; `maxDistance` 1..300. Lists are newest first, `after` = id of the last +offer you have (older ones follow). `status`: `open`, `accepted`, `completed`, `cancelled`, `expired`, `void`. + +| Route | Purpose | +| ----- | ------- | +| `POST /trade/offers {townId, giveRes, giveAmount, wantRes, wantAmount, maxDistance}` | post (201). The offered amount leaves the POP (escrow) and one transport link is held in reserve. `trade_ratio`, `capacity_exceeded`, `no_transport_link` (no exchange, or all links busy/reserved), `not_enough_resources` | +| `GET /trade/offers?worldId&townId&give&want&after&limit` | open offers of others that one of your POPs (or `townId`) can take: within `min(maxDistance, 10 x exchange level)`. Each carries `acceptableFrom: [{townId, distance}]`; `exchangeLevels` lists your exchanges and their reach | +| `GET /trade/offers/mine?worldId&status&after&limit` | offers you posted or accepted, any status, with `role` | +| `GET /trade/offers/:id` | one offer: open ones to every operator of the world, closed ones to the two parties (`not_found` otherwise) | +| `DELETE /trade/offers/:id` | cancel your open offer; the escrow returns to the POP (`offer_closed` when it is not open) | +| `POST /trade/offers/:id/accept {townId}` | take it with one of your POPs (201): two transports leave at once (your payment, their goods); `own_offer`, `offer_closed`, `trade_out_of_range`, `no_transport_link`, `not_enough_resources`; all or nothing | + +Notifications: `trade_accepted` (poster), `trade_completed` (both, when both transports arrived), `trade_expired`, `trade_void` (the POP +was taken over). Delivery notifications are the existing `transport_arrived` / `transport_delivered`. Direct transports (own POPs, any +player) stay `POST /movements` with `type: "transport"`. + +**World status and the end game.** The backbone sites open at world day 100 (real days x speed). + +| Route | Purpose | +| ----- | ------- | +| `GET /worlds/:id/status` | `phase` (`running`, `backbone_open`, `ended`), `ageDays`, `opensAt`, the 7 `sites` (empty before opening: `id` (null until first touched), `index`, `x`, `y`, `holder` `{allianceId, tag, name}` or null = incumbent, `takenBy`, `level`/`maxLevel`/`progress`, `pool` (stockpile), `build` `{toLevel, startedAt, dueAt}`, `next` `{toLevel, cost, durationMs}`), `winner`, `endsAt` (set once somebody won), `endedAt` | +| `GET /worlds/:id/results` | the final snapshot once ended (`available: false` before): `winner`, `results.{operators, alliances, attackers, defenders, sites, totals}` (top 100 each, ranked) | +| `GET /backbone/:id` | one site; holders also get `contributions` (who shipped what) and `you` `{holder, canBuild, canShip, canAttack}` | +| `POST /backbone/:id/ship {fromTownId, cargo}` | send resources to a site your alliance holds (201, a transport: same links and capacity); arrives into the stockpile, or rides home if the site changed hands | +| `POST /backbone/:id/build` | start the next node level (201), paid from the stockpile at once, one level at a time, any holder with `backboneBuild`; `max_level`, `already_queued`, `not_enough_resources`, `forbidden` (not a holder), `backbone_closed` | + +Taking a site is `POST /movements` with `type: "scan"` or `"attack"` and the site's `x, y` (no `toTownId`): needs an alliance, not against +the own alliance or a NAP/confederation partner (`invalid_target`, `details.reason`: `no_alliance`, `own_site`, `pact`, +`landing_scan_or_attack_only`); before opening `backbone_closed`. Settling a landing tile is `invalid_target` (`backbone_site`), also before +it opens. Defence is static: `incumbentDefence x 12 x (1 + 0.03 x node level)`; a scan report shows it. Reports: scans as `scan` (with +`site.type: "backbone"`), attacks as the new type `landing` (outcome, attack/defence, `taken`; recipients: the attacker and every member of the +previous holder). `GET /map` lists open sites in `specials` as `type: "backbone"` with `site: {id, index, holder, level, maxLevel}`; +`GET /map/tile` returns `type: "backbone"` and `backbone: {siteId, holder, level, pool, build, mine, canAttack}`. + +Notifications: `backbone_open` (first touch), `backbone_taken` / `backbone_lost` (alliance members), `backbone_level` (every 10th level and the +last, holder members), `backbone_delivered` / `backbone_ship_bounced` (sender), `backbone_won` (everybody), `world_ended` (everybody). + +**An ended world** answers every game command with `409 world_ended` (build, send, train, trade, alliances, diplomacy, backbone, report +sharing, ...). Still allowed: `GET` everything (map, reports, rankings, towns, status, results), `POST /reports/read-all`, `POST +/reports/:id/read`, messages (send, read, delete, block). + +**Shared report folder.** `POST /reports/:id/share` puts one of YOUR reports into your alliance's folder (needs `shareReport`; the report +is kept 14 days from the share), `DELETE /reports/:id/share` takes it out (the sharer, or `unshareReport`: leader, officer), `GET +/alliances/:id/reports?after&limit` lists the folder newest first (cursor: id of the last report seen), `GET /alliances/:id/reports/:reportId` +reads one with its full data. Members with `viewSharedReports` only; `GET /alliances/mine` permissions list the new keys. + +**Allied incoming.** `GET /movements` has a new `alliedIncoming` list: movements heading for POPs of your alliance mates and of +confederated alliances, same shape as `incoming` (type `unknown`, origin and ETA only) plus `ally: true` and `toOperator`. Friendly traffic +(from partners of the target) is left out. diff --git a/docs/DECISIONS.md b/docs/DECISIONS.md index a8aebb2..180df56 100644 --- a/docs/DECISIONS.md +++ b/docs/DECISIONS.md @@ -128,3 +128,85 @@ nothing is spent. New POPs start with every field at level 0, no infrastructure, ## S3-9 — Moving units between your own POPs `reinforce` to an own POP puts the units into `town_units` of the target (they live there now). Only units of OTHER operators are `stationed` rows. + +## S6-1 — Push hints leave only after the commit, through an outbox +`scheduler.notify` runs inside the transaction of the event or command, so pushing there would announce changes that may still roll +back. `notify` queues into `scheduler.outbox` (only when a listener is set); `process()` and `commands.run` flush it after COMMIT +(`db.depth === 0`) and truncate it to their mark on rollback. `town` hints use the existing `scheduler.onEvent` (post-commit already) +and a new `commands.hooks.onCommand`. `push.js` itself knows no game rules (it gets `townOwner` / `tokenValid` injected), the routing +lives in `pushHooks.js`. No new dependency (`ws` was already listed). + +## S6-2 — Revocation is polled, not pushed +Tokens are revoked by plain SQL in routes and the admin tool. Instead of hooking each place, the ping tick (30 s) re-checks +`tokens.revoked_at` and `users.banned` for every authenticated socket and closes with 4401. Worst case 30 s of hints after logout on +another device; hints carry no data, so nothing leaks. If that is ever not good enough, call a `push.disconnectToken(id)` from the routes. + +## S6-3 — Hints are merged per tick, `town` is not sent to the target at launch +Identical JSON hints produced in one tick (a catch-up) are deduplicated per socket via `setImmediate`. A launched movement tells the +target's owner `incoming` (town + ETA) and no plain `town` hint, so the type and origin of a launch cannot be inferred from extra traffic. + + +## E1 — A landing site is a row of its own, not a POP +`landing_sites(world_id, idx, x, y, holder_alliance_id, holder_operator_id, level, stockpile, build_*)` (migration 004), positions from +`rules.backboneSites(seed, radius)`. A town row of kind `landing` owned by the leader was considered and rejected: a "POP" that nobody plays +would have to be excluded from footprint rankings, the last-POP / capital / footprint-gate counts, `homeTownFor`, `/me`, spawn spacing and +the Rack hall cap (shipped resources would be thrown away at 250), and a leader change would have to re-own it. The holder is the +alliance (`holder_alliance_id`, FK `ON DELETE SET NULL`, the disband hook also clears it), `holder_operator_id` only records who took it. +Consequence, on purpose and to be revisited after the first world: **no units can stand at a site**, so there is no garrison and no +reinforcement. A site is defended by the static value `incumbentDefence x 12 x (1 + 0.03 x level)` only, i.e. exactly the "incumbent +with a backbone multiplier" of DESIGN.md; holders defend by growing the node (higher level = harder to take), attackers can scan the exact +number. Hooks into the military code are small: `combat.arriveSite` hands `backbone` tiles to `military/landing.js`, +`arrivals.arriveTransport` hands shipments (`extra.siteId`) to `endgame.deliverShipment`, `sendMovement` calls `endgame.checkLandingTarget`. + +## E2 — Site rows are created lazily, there is no timer event +`ensureSites` creates the 7 rows when something first touches a site (an attack/scan sent or arriving, a shipment, a build) once the world is +at day 100 / speed; that first call also writes a `backbone_open` notification for every operator. Reads (`/worlds/:id/status`, `/map`, tile +info) never write: untouched sites are shown as the incumbent's, level 0, `id: null`. A `backboneOpen` event at world creation was +dropped: a pending event 100 days ahead sits in every quiet world and breaks tooling that counts pending events (the admin CLI test). +Cost: nobody is pushed the moment the sites appear unless a first touch happens; clients see `phase: backbone_open` when they poll status. + +## E3 — The winner is fixed at level 100; the world is frozen when it ends +The holder of a node whose level completes at 100 wins (`worlds.winner_*`, once per world) and `worldEnd` is scheduled +`graceDays x 24 h / speed` later. Losing the node meanwhile does not change the winner (the race is over; the grace days are for the ranking +and the post-game). If a level-100 node is taken while nobody holds it (the holder disbanded mid-build) the new holder wins. `worldEnd` +writes the ranking snapshot, sets `status = 'ended'`, closes open trade offers (`expired`, escrow back in its POP: every unit stays accounted +for) and CANCELS every other pending event of the world: nothing arrives, trains, +expires or builds after the snapshot, so the stored ranking stays the truth. Movements still `out` and queued builds stay as they were. +A running build of a site continues for whoever holds the site when it lands (the level belongs to the site; the cost was paid from the +stockpile at the start); the stockpile and the ledger stay with the site when it is taken. + +## E4 — `world_ended` is one gate in `commands.run`, found by probing the arguments +`ownedTown`, `operatorOf` and `requireRole` are shared with reads (rankings, map), so gating there would break "readable after the end". +`commands.run` calls `endgame.guard(db, name, args)`: the world is `args.worldId`, else the world of `townId/fromTownId/hostTownId`, +`allianceId`, `movementId`, `inviteId`, `proposalId`, `offerId`, `siteId`, `reportId`, else the caller's oldest operator (the default every +command already uses). Allowed after the end: `markReportRead`, `messageSend/Read/Delete`, `messageBlock/Unblock`. New commands are gated +automatically as long as they carry one of those arguments. + +## E5 — Backbone cost curve is not the building curve +`4000 x 1.28^99` is unreachable; the node has its own `ENDGAME.costGrowth = 1.045` and `timeGrowth = 1.025` (about 7.2 M of each resource and +about 36 world days of building in total, level 100 alone 312 k each and 23 h). Pure guesses until a bot run (stage 7) says how much an +alliance can ship; nothing here is balanced. + +## T1 — Trade: escrow, one link per side, reach by exchange level +- Offers are escrowed in `trade_offers` and hold one transport link of the poster's POP while open (`movements.activeLinks` counts open + offers), so accepting never fails for lack of a link on the poster's side and cannot exceed the exchange level. +- Each side of an offer must fit ONE transport (<= 500); larger deals are several offers. The ratio band is count-based 1:2. +- Escrow returns without the Rack hall cap (conservation beats the cap here); deliveries keep the existing cap rule (`cargoLost`). +- Reach: `10 tiles x exchange level` of the taker's POP, and the offer's own `maxDistance`; the poster's level only matters for the number of + offers they can hold open. +- A POP changing hands voids its open offers (`combat.transferTown` calls `trade.onTownTransferred`); the escrow stays in the POP. +- `transportArrived` hook: `server/trade.js` registers itself when required (both `commands/index.js` and `events/index.js` load it), so the + consumer exists in every test fixture that builds commands or events. +- Offer expiry: one `tradeExpire` event per offer, cancelled on accept/cancel/void, idempotent (acts only while `open`). + +## T2 — Shared reports extend the report's life +Sharing sets `expires_at = max(expires_at, now + 14 days)` on the single shared `reports` row, so the folder is not emptied by a report that +was nearly due; the cascade `report_shares.report_id ... ON DELETE CASCADE` removes the share when the report is cleaned up. + +## G1 — `buildDone` adds one level to what the building is NOW +Each build event adds exactly one level to the current level (never lowers, never above the queued `toLevel`), so an upgrade in flight +cannot undo exploit-kit damage; a building knocked to 0 comes back at 1. The notification reports the real level. + +## G2 — Allied incoming is a separate list +`GET /movements` keeps `incoming` as "heading for YOUR POPs" and adds `alliedIncoming` for partners' POPs (own alliance + confederations), +each entry with `ally: true` and `toOperator`. Mixing them would make clients count allies' attacks as their own. diff --git a/docs/DESIGN.md b/docs/DESIGN.md index ddeb1bf..c95e2b4 100644 --- a/docs/DESIGN.md +++ b/docs/DESIGN.md @@ -148,6 +148,12 @@ A new POP starts at level 0 everything and 1 h of resources. Takeover requires t - Diplomacy states between alliances: war, neutral, non-aggression pact, confederation (can reinforce each other, see each other's incoming). Pacts take 24 h to cancel. - Messages: player-to-player and alliance broadcast, plain text, 2000 chars, basic rate limit. +- **Shared report folder (server):** a member puts one of their own reports (any type) into the alliance's folder (`shareReport`); every + member reads it (`viewSharedReports`), the sharer or leader/officer (`unshareReport`) takes it out. Sharing pushes the report's expiry + out to 14 days from the share (it is one row for everybody) and it goes with the report or the alliance. +- **Seeing each other's incoming (server):** members of one alliance and of confederated alliances get `alliedIncoming` in `GET /movements`: + movements heading for a partner's POP, origin and ETA only (type, units and cargo hidden), except traffic from operators who are partners + of the target themselves (friendly). ## Trade @@ -155,6 +161,22 @@ The Internet exchange lists offers "give X of A for Y of B, max distance Z". Rat pump-feeding. Accepting an offer spawns two transport movements. Direct transports to own POPs or to any player (e.g. alliance support) use the same links. Transport links: level of the exchange, capacity 500 each. +**Clarified (what the server does).** +- An offer is "give `giveAmount` of `giveRes` for `wantAmount` of `wantRes`, within `maxDistance` tiles", posted from one POP that has + an Internet exchange. Each side must fit ONE transport link (1..500) and the two amounts differ by at most 1:2: + `give <= 2 x want` and `want <= 2 x give` (count-based, the resources are not weighted). The resources must differ. +- The offered amount is **escrowed**: it leaves the POP when the offer is posted. Cancelling or expiry (48 h / world speed) credits it back + to the POP without the Rack hall cap (an amount above the cap is kept, it only stops growing), so nothing is created or lost. +- **Reach:** a POP sees and takes offers of other operators within `min(offer.maxDistance, 10 x Internet exchange level)` tiles. The poster + cannot take their own offer. +- **Links:** an open offer holds one transport link of the poster's POP in reserve (open offers + running transports + returning carriers + <= links); accepting converts the reservation into the real transport. Direct transports see the reservation as a busy link. +- **Accepting** (one transaction): the acceptor's payment leaves their POP as a transport to the poster's POP (needs a free link and the + resources there), the escrow leaves the poster's POP as a transport to the acceptor's POP; both arrive after `distance / 12 tiles/h / + world speed`. The offer is `accepted`, then `completed` when both have been delivered. A delivery above the receiver's Rack hall cap + loses the overflow and says so (the existing transport rule). If the poster's POP is taken over while the offer is open, the offer + ends (`void`) and the escrow stays in the POP. + ## Incumbent (NPC) The legacy telco. Holds incumbent sites spread over the map with large static defences that scale with world age. @@ -169,6 +191,33 @@ far more than anything else and requiring resources shipped in from members (tra wins and the world ends two days later with a final ranking. Backbone nodes can be attacked and taken; the level stays with the site. Landing sites cannot be settled, only taken. +**Clarified (what the server does).** World age is in world days (real days x speed). All numbers below are first guesses, no bot run. +- **Sites:** `rules.backboneSites(seed, radius)`: 7 fixed positions, one per sector of the circle (jittered), on plain land between 35% and + 80% of the map radius, at least 6 tiles apart, never in the free centre. They exist from the start (spawning and settling refuse them), + the tile reads `backbone` from day 100 / speed (`rules.tileAt(seed, radius, x, y, ageDays)`; without the age argument terrain is unchanged). +- **A site is not a POP** (DECISIONS E1): it has a holder alliance, a Backbone node level, a stockpile of Fiber/Hardware/Capital and at most + one level in progress. No units can stand there, so a site is defended by a static value only: + `defence = incumbentDefence(seed, x, y, age) x 12 x (1 + 0.03 x node level)`. At day 100 that is about 40 000 with no node, 160 000 at + level 100 (a Script crew attacks with 40). +- **Taking:** `scan` and `attack` only (no raid: the stockpile would be lootable; no takeover, no reinforce, no settle). The attacker must be in + an alliance, and may not be in the holder's alliance or in a NAP / confederation with it (checked when sent and again on arrival, units come + home otherwise). A full attack with attack > defence wins: the attacker's alliance holds the site. No loot, the site loses nothing, the + survivors drive home. Level, stockpile and a running build stay with the site. A holder that disbands leaves the site to the incumbent + (level kept). +- **Feeding the node:** members of the holder alliance send resources by transport (`POST /backbone/:id/ship`, same links, 500 per link, 12 + tiles/h). On arrival they join the stockpile if the sender's alliance still holds the site, otherwise they ride home. A ledger records + who sent what. +- **Building:** level L (1..100) costs `4000 x 1.045^(L-1)` of each resource (level 100: 312 301; about 7.2 million of each in total) and + takes `2 h x 1.025^(L-1) / world speed` (level 100: 23 h; about 36 days of world time in total, one level at a time). The cost is paid from + the stockpile when the level starts; any holder with `backboneBuild` may start it. +- **Winning:** when a level completes and the node is at level 100, the holder at that moment wins (once per world) and the world ends two world + days later (`worlds.end_at`). The winner is final: losing the node during those two days does not change it. If a finished node is taken while + nobody held it, the new holder wins. +- **Ending:** the `worldEnd` event stores a ranking snapshot (operators by footprint, alliances by the sum, top attackers and defenders by + battle points, winner, the sites), sets the status `ended`, and cancels everything still pending in that world. An ended world refuses + every game command with `world_ended`; reading (map, reports, rankings, town views, status, results) and chatting (messages, marking reports + read) keep working. + Rankings throughout: operators by footprint, alliances by sum, attackers/defenders by points from battles. ## Fairness and anti-frustration diff --git a/docs/NEXT.md b/docs/NEXT.md index 2a90879..b592562 100644 --- a/docs/NEXT.md +++ b/docs/NEXT.md @@ -17,11 +17,10 @@ Tests: `test/social-*.test.js` (pure rules, alliances, diplomacy with the fake c response in them is checked against its declared schema (`createTestServer({ contract: true })` in `test/helpers.js`). Not done: -- Marketplace / Internet exchange and resource transport (waits for the movement system of stage 3). -- Shared report folder of the alliance (needs reports from stage 3), confederation effects (reinforce, see incoming) and the pact - effect "no attacks inside a NAP/confederation": the military stage must call `alliances.pactPartners` / `confederated`; nothing - enforces it yet. -- No web client, no WebSocket push (notifications rows are written; stage 6 pushes them). +- Marketplace / Internet exchange: DONE on the server, see "Trade, end game, gaps" below. +- Shared report folder and "see each other's incoming": DONE on the server (below). The pact effect "no attacks inside a NAP/confederation" + is enforced by the military stage (`pactBlocks`). +- No web client; WebSocket push (stage 6) now exists server-side, see "Stage 6" below. - Message retention/cleanup of old rows, alliance rename/description, mass-mail abuse reporting, sitter accounts. - Rankings are not cached; battle rankings stay empty until the military stage writes `operator_stats`. - Not run: Playwright, load, or any bot balance run; the social numbers in `SOCIAL` (limits, TTLs, role table) are first guesses. @@ -43,11 +42,9 @@ recall, research, reports/cursor/retention, API smoke over HTTP). Fake clock, in Not done / not claimed: - **Nothing is balanced.** All unit stats, costs, research curves, incumbent defence and the 50-unit-scale combat numbers are first guesses; there was no bot run (`tools/bot.js` does not exist yet). Do not cite any of them as tuned. -- Training cannot be cancelled; reports cannot be shared to the alliance yet (the shared report folder needs a table in the social stage); - confederates do not see each other's incoming movements (only reinforce is wired); no sitter, no night protection. -- A building damaged by exploit kits that has an upgrade in flight jumps to the queued level when that finishes (`buildDone` sets absolute levels). +- Training cannot be cancelled; no sitter, no night protection. (Report sharing and allied incoming: done, see below.) - Units in transit draw no power from anyone; an operator cannot choose a new capital POP (no command); a captured POP keeps its footprint. -- Backbone landing sites and the Backbone node (end game) are not part of this stage. +- Backbone landing sites and the Backbone node: see "Trade, end game, gaps" below. ## Client (stages 1-2 web client) Built: `public/` vanilla JS, no build step, strict-CSP friendly (no inline scripts or handlers, no external requests). @@ -66,5 +63,128 @@ Built: `public/` vanilla JS, no build step, strict-CSP friendly (no inline scrip Gaps: the unread badge is stored in localStorage (no "mark read" route); `/me` exposes the world seed which the client ignores; no push, no service worker, canvas has no inertia/fling, no light theme. +## Client: social (alliance, messages, rankings) +Built (all in the nav "More" group, `navGroup: 'more'`): `screens/alliance.js` (found with Peering office gate and translated server +errors; received invites accept/decline; overview with size, pinned notes add/remove, leave/disband; members with role, POPs, +footprint, last online, a member sheet for message / role / transfer / kick; invite by name, pending invites with cancel; diplomacy +with relations, proposals in/out, "new move" via directory search with only the moves `rules.diplomacyMove` allows, pact-cancel +and proposal countdowns, take-back), `screens/messages.js` (inbox with unread filter / mark all read, sent, alliance feed with +broadcast composer, per-operator thread with older-page cursor, compose by name, 2000 char counter, delete own copy, block list and +block/unblock, 429 shown as a countdown with the text kept, unread count on the nav via `App.setBadge`, polled every 60 s), +`screens/rankings.js` (operators, alliances, battles attack/defense/total, your row highlighted plus the server's `you` card, rank-offset +"load more"). Shared bits: `screens/social-ui.js` (`window.SocUI`: composer, confirm sheet, alliance profile sheet, error mapping), +`js/social.js` (pure logic: what to show per role via `rules.allianceCan/outranks`, diplomacy options, counters, cursor merges), +`js/strings/social.js` (en + nb), new sprite icons users / mail / trophy / back, `.soc-` CSS. All player text goes in with +`textContent` (a test fails on any `innerHTML` in these files). +Tests: `test/client-social.test.js` (pure logic, string coverage of every static key the screens use, error codes, no HTML sinks). +Looked at with headless Chromium (phone portrait/landscape, desktop) against the real server in-process, plus a scripted flow on +a phone profile (markup in a message stays text, counter/over-limit, 429 countdown, unknown recipient, leader vs member views, diplomacy +move sheet, name-taken error, nb). Not run: real devices, Safari, Playwright suite, a long-list scroll test (>100 ranks), accepting an +invite when the alliance is full, alliances at the size cap. +Gaps: alliance rename/description and note editing have no UI (server has edit-note); no operator profile page; blocking needs an existing +conversation or message (the API takes an operator id and there is no name lookup); no live refresh (push is not wired, screens refetch +on open and on manual refresh); the alliance screen does not auto-refresh countdowns' targets after they pass; `App.state.operator.alliance` +is refreshed from `/me` after alliance changes but is stale if you are kicked while away until the screen is opened. + +## Client: military, expansion, WebSocket +Built (`public/`, same rules as before: no innerHTML for player text, no inline handlers): +- **Nav overflow** (`main.js`): 5 slots; `registerScreen({ navGroup: 'main' | 'more' })`, with any `more` screen the 5th slot is a + "More" sheet; `App.setBadge(screenId, n, 'alert'|'info')` (More sums its screens, red if any is an alert). Bar now: POP, Map, Units, + Moves, More (Reports, Alerts, Settings, the social screens). `App.alertKinds[type]` lets a screen describe its own notification types in + the Alerts feed; `App.popSections` lets screens add cards to the POP screen (incoming banner, expansion card). +- **Shared state** (`milstate.js`): `App.mil.moves` (last `GET /movements`: outgoing, incoming, alliedIncoming) is the one source for the + nav badge, POP banner, movements screen and map lines; `App.refreshMovements/refreshReportsUnread/refreshTowns` (the last refetches `/me` + without the destructive `setSession`, used after a settle/takeover); `[data-cd]` countdown elements driven by one ticker; refetch when + anything on the wire is overdue. +- **Units** (`screens/units.js`): home units with research-adjusted stats, reinforcements here (send home) and your units elsewhere (call + back), training queue with countdowns + train sheet (`rules.trainPlan` preview, max-affordable, queue-full), research list + sheet + (`rules.researchPlan`, lab level / cost / time / reason), offline warning with the decommission countdown. +- **Movements** (`screens/movements.js`): incoming list on top in red (origin + ETA only, as the API gives it), your outgoing legs with + progress and a Recall button for the first 90 s, allied incoming; the POP screen gets a pulsing banner, the nav button a red badge. +- **Send dialog** (`screens/send.js`, `App.openSend({x,y,fromTownId,type})`, from the map tile sheet, Units, Movements): `GET /map/tile`, + types filtered by `milcore.moveOptions` (greyed ones say why), unit pickers (slider + stepper + all), cargo for transport, settle with + the wild-slot choice, latency/ETA/carry preview from `rules.movementMs`, `confirmEndProtection` checkbox, exploit-kit target, an + idempotency intent per opened dialog, server errors shown inline (`invalid_target` reasons translated). +- **Reports** (`screens/reports.js`, in More): cursor-paginated list, unread highlight + badge, mark read on open, mark all read, detail + layouts for raid/attack/takeover (role-aware victory/defeat, units sent/lost/left per group, strength, loot, siege, takeover loyalty), + scan (+ incumbent intel), scan_detected, incumbent, settle (opens the new POP), reinforce, movement_failed; coordinates jump to the map. +- **Expansion** (`screens/expand.js`, `send.js`, `main.js`, `render.js`): POP switcher in the resource bar, expansion card on the POP screen + (crews at home, footprint gate, POP list), settle through the send dialog; map draws your/incoming/allied movement lines with markers, + a red ring on your POPs that something is heading for, and a Send button in the tile sheet. +- **WebSocket** (`ws.js`): `createSocketClient` (injectable WebSocket and timers) + browser wiring. Auth as first message, ping every 25 s with + an 8 s pong timeout, jittered backoff 1 s .. 60 s, PROTOCOL close codes (4401/4400/1009 stop, 4429 waits 30 s), refetch after every + re-`ready`. Pushes go to `api.emit('push')` and refetch the affected thing; slow REST poll (45 s with the socket down, 3 min with it up). +- Tests: `test/client-mil.test.js` (type filter, unit roles, previews, perspective, backoff), `test/client-ws.test.js` (auth, ping/pong, backoff, + close codes, no token, throwing constructor); `client-i18n` parity covers `strings/military.js`. +- Looked at: headless Chromium (phone portrait/landscape, desktop; en and nb on the phone) against the real server in-process with a real + clock, seeded units/movements/reports, plus scripted flows on a phone profile: real WebSocket `open`, an `incoming` push from another + operator adding a row and a toast without polling, recall, raid/attack/transport/settle sends through the dialog (protection checkbox + gates the button, exploit-kit target reaches the server), train, withdraw, offline warning, report details of every type, POP list after + a settle resolved (`refreshTowns`). +Not done / not claimed: +- Not run: real devices or Safari, throttled networks, a socket behind nginx Proxy Manager, long sessions, the Playwright suite. The settle and + takeover resolution was exercised by fast-forwarding movement times in the DB, not by waiting. +- Takeover and capture flows (town_lost/town_gained pushes, losing the current POP) and the confederation `alliedIncoming` view have no + browser run. The Hostile takeover button stays enabled on a capital / last POP (the client cannot know); the server's refusal is shown. +- Withdraw and "call back" are one-tap with no confirmation. No unit icons (role icons only), no battle simulator / odds preview, no + cancel of training (the server has none), no sound or system notifications, no reports search/filter. +- The exploit-kit target picker only offers infrastructure types (the server also takes field slots f1..f18). Report group labels for + reinforcements show `#` because the report carries no names. +- Close 4401 stops the socket but does not itself send the player to login: that happens on the next REST 401 (`api` `unauthorized`). +- `ready.serverTime` is not used for the clock offset (no round-trip estimate on the socket); REST responses keep doing that. + +## Stage 6 (server half): WebSocket push +Built: `/ws` on the game's HTTP server (`server/push.js` transport, `server/pushHooks.js` routing), contract in `docs/PROTOCOL.md`. +Auth as first message (`ready` / close 4401), Origin check (`net.originAllowed`), per-IP cap `MAX_CONN_PER_IP` (HTTP 429), 1 KB frames, +10 s auth timeout (4408), per-socket token bucket (4429), bad-message budget (4400), ping/pong keepalive that terminates dead sockets and +re-checks the token on every tick (revoked/banned: 4401), graceful 1001 close inside `srv.close()`. Hints: `town`, `incoming`, +`notification`, `report`, `message`, `pong`. Every `notifications` row (via `scheduler.notify` -> post-commit outbox -> `onNotify`) pushes a +`notification` hint, plus the typed ones; finished events and committed commands push `town` to the owners of the POPs they touched. +Hints go out only after the transaction that caused them committed (a rolled-back event or command pushes nothing); identical hints of +one tick are merged. Small edits outside the new files: `scheduler.js` (outbox, `notify` returns the row id), `commands/index.js` +(`hooks.onCommand`, outbox flush/rollback), `index.js` (upgrade + shutdown). +Tests: `test/push-ws.test.js` (auth ok/bad/timeout, origin, path, per-IP cap and its release, rate limit, bad budget, oversize frame, dead +socket, revoked token, banned user, shutdown, REST with no socket) and `test/push-game.test.js` (build/train done, incoming only to the +defender, report/message/alliance invite hints, recall, coalescing, rollback). Real `ws` client, fake clock, port 0. `npm test`: 113 pass +(run after the push work, with the other agents' changes in the tree at that moment). +Not done / not claimed: +- The client now exists (`public/js/ws.js`, see "Client: military, expansion, WebSocket") and was run against this server in a headless browser; not through a proxy. +- Revocation closes the socket at the next ping tick (default 30 s), not instantly: `POST /auth/logout` and token deletion do not call push. +- No load test (many sockets, large catch-ups), no test behind a real nginx Proxy Manager (upgrade headers, idle timeouts, `X-Forwarded-For` + for the per-IP cap); only the code paths of `net.clientIp` are reused. The proxy's idle timeout (NPM default 60 s) is above nothing we + send: the 30 s ping keeps sockets alive, but that is reasoning, not a measurement. +- Hint gaps: owners of reinforcements standing in an attacked POP get `report` but no `town` hint for their home POP; no `incoming` for + confederates; no APNs/FCM sender (the `notifications` table plus `scheduler.onNotify` is where it would attach); no resume after a gap. +- The ws tuning knobs (`wsPingMs`, `wsRate`, ...) are `createServer` options only, not environment variables. + +## Trade, end game, gaps (server only; migration `004_trade_endgame.sql`) +Built and tested (`test/trade-*.test.js`, `test/endgame-*.test.js`; fake clock, in-memory db, port 0; contract-checked responses over HTTP): +- **Trade:** offers "give X of A for Y of B within Z tiles" with escrow, a link reserved per open offer, 1:2 ratio band, expiry event, + cancel, accept = two transports in one transaction (all or nothing), the `transportArrived` consumer completes the offer, void when the + POP is taken over. Conservation is asserted (every unit in POPs + escrow + on the road, before and after; the only loss is the existing + Rack hall overflow, asserted too). Routes under `/trade/offers`. +- **End game:** 7 seed-derived landing sites (`rules.backboneSites`, `tileAt` with the world age; spawn and settle refuse them from day 0), + open at world day 100 / speed, taken with scan/attack against a static heavy defence, node level 1..100 built from a stockpile fed by + transports (`/backbone/:id/ship`, `/build`), winner at level 100, `worldEnd` two world days later with a stored ranking snapshot and a frozen + world, `world_ended` for every game command, `GET /worlds/:id/status` and `/results`. One end-to-end test runs day 100 -> take -> ship -> + build -> win -> ended on a speed-2 world; the ended-world gate is also driven over HTTP. +- **Gaps closed:** shared report folder (`report_shares`, `/reports/:id/share`, `/alliances/:id/reports`), `alliedIncoming` in `GET /movements`, + `buildDone` is relative to the building's current level (test written first, failed before the fix). +Not done / not claimed: +- **Nothing here is balanced.** Defence multiplier 12 (+3% per level), node cost 4000 x 1.045^(L-1) (about 7.2 M of each resource in total), + node time 2 h x 1.025^(L-1) (about 36 world days), 48 h offer ttl, 10 tiles of reach per exchange level, 500-per-side offers: first guesses, + no bot run (`tools/bot.js` still does not exist). Whether an alliance can actually ship 7 M of everything in time is unknown. +- **No garrison at landing sites** (E1): defence is static, holders cannot station units. If the first world shows the race is decided by who + hits first, the next step is a small `site_units` table with reinforce-to-site and defenders in `landing.js`. +- No `backbone_open` push at the moment the sites appear unless something touches a site first (E2); clients see the phase by polling status. +- Trade: no multi-link deals (each side <= 500), no price history or order book, no counter-offers, no notification when a new offer appears + in reach, offers are not hidden from enemies, the escrow of a taken-over POP goes to the conqueror. +- Ended worlds: movements still `out` and queued builds are left as they were (events cancelled, E3); there is no admin "end world now" or + "reset" yet (stage 7 world lifecycle: the `worldEnd` event can be enqueued by hand); several winners are impossible by design. +- The ranking snapshot is the same numbers as `/rankings`, computed once; `/rankings/*` after the end still compute live from the frozen state. +- Client: nothing in `public/` was touched. New notification types (`trade_*`, `backbone_*`, `world_ended`), the `landing` report type, the + `backbone` map special / tile, `world_ended` and the new error codes (`trade_ratio`, `offer_closed`, `own_offer`, `trade_out_of_range`, + `world_ended`, `backbone_closed`) need strings and screens. + ## Not done - Everything else. See CLAUDE.md "Working in stages". diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md new file mode 100644 index 0000000..ec17d40 --- /dev/null +++ b/docs/PROTOCOL.md @@ -0,0 +1,146 @@ +# PROTOCOL: WebSocket push + +Endpoint `/ws` on the same HTTP server and port as the REST API (`ws://host:port/ws`, `wss://` behind the proxy). +Implementation: `server/push.js` (sockets), `server/pushHooks.js` (who gets which hint). Tests: `test/push-ws.test.js`, +`test/push-game.test.js`. + +**Push is a hint, never state.** A message says "something changed, go and look" and carries ids and times only. The client +refetches over REST (`GET /towns/:id`, `/movements`, `/reports`, `/notifications` ...). The game is fully playable with the socket +disconnected, lost hints are harmless, and nothing a hint says may be trusted without the REST read. Hints are sent only after +the database transaction that caused them committed. + +All messages are JSON text frames, one object per frame with a string `type`. Times are integer ms since the epoch (UTC), +server clock. + +## Connecting + +1. Open `/ws`. The upgrade is refused with plain HTTP status (the client sees a failed handshake, not a close code): + + | HTTP | Why | + | ---- | --- | + | 403 | `Origin` header present and not allowed: same host as `Host`, or listed in `ALLOWED_ORIGINS` (same rule as `net.originAllowed`). No `Origin` (non-browser clients) is fine. | + | 404 | any path other than `/ws` | + | 429 | already `MAX_CONN_PER_IP` (default 40, `0` = off) open sockets from this client address (`net.clientIp`, proxy aware). Counts sockets that have not authenticated yet. | + | 503 | server is shutting down | + | 426 | not from us: nginx Proxy Manager with **Websockets Support** off, see `docs/DEPLOY.md` | + +2. Send the first message within **10 s**. It must be exactly this, **never put the token in the URL** (proxy logs): + + ```json + {"type":"auth","token":""} + ``` + +3. The server answers `{"type":"ready","serverTime":1767225600000}`. Only after `ready` do hints flow. + Anything else as first message, an invalid, revoked or banned token, or no message in time closes the socket (below). + +One socket per device is enough; a user may have several (phone + desktop), each gets every hint. + +## Server to client + +| Message | Meaning | Client reaction | +| ------- | ------- | --------------- | +| `{"type":"ready","serverTime":n}` | authenticated | use `serverTime` to refresh the clock offset | +| `{"type":"pong","serverTime":n}` | answer to `ping` | same | +| `{"type":"town","townId":n}` | POP `n` (yours) changed: build/train/research done, resources spent, units arrived, returned or died, attacked, ownership changed, a command from another device | refetch `GET /towns/:id` (if on screen) | +| `{"type":"incoming","townId":n,"arriveAt":n}` | a movement from another operator was launched at your POP `townId`, arrives at `arriveAt`. Type and origin hidden on purpose (could be a scan, a raid, reinforcements or a transport). | show a warning with a countdown, refetch `GET /movements` for the details the API allows | +| `{"type":"notification","id":n,"kind":"..."}` | a row was added to your notifications. `kind` is `notifications.type`: `build_done`, `train_done`, `research_done`, `incoming`, `report`, `message`, `alliance_message`, `alliance_invite`, `town_lost`, `town_gained`, `transport_arrived`, `movement_returned`, `units_offline`, ... (the list grows, treat unknown kinds as generic) | bump the unread badge, `GET /notifications` | +| `{"type":"report","id":n}` | a battle or scan report with id `n` is ready for you | `GET /reports/:id` or refresh the list | +| `{"type":"message","id":n}` | a direct or alliance message with id `n` arrived for you (not sent to its sender) | refresh the inbox | + +`incoming`, `report` and `message` always come together with the matching `notification` hint (same event, two messages). +The generic `notification` hint is the one to build the badge on; the typed ones let the client skip a round trip. + +Guarantees and non-guarantees: + +* Hints are best effort: after a reconnect, refetch what is on screen (and `/notifications`, `/movements`); do not assume nothing + was missed. +* Identical hints produced in the same tick are merged (a 50 event catch-up gives one `town` hint per POP), order is otherwise + preserved per socket. +* A command's own `town` hint is also sent to the device that issued it (ignore your own echo if you already refetch). +* Reads (`GET`) never push. A hint is not sent for a refused or rolled-back command. +* At launch of a movement the target's owner gets `incoming`, not a plain `town` hint; `town` for that POP follows when it + arrives. + +## Client to server + +| Message | Answer | +| ------- | ------ | +| `{"type":"auth","token":"..."}` | only as the first message (see above); a second one counts as a bad message | +| `{"type":"ping"}` | `{"type":"pong","serverTime":n}` | + +Anything else (unknown `type`, invalid JSON, not an object, binary frame) is a **bad message**: ignored, counted. The 5th bad +message on a socket closes it with 4400. Before authentication any non-auth first message is fatal (4401). + +Keepalive: the server sends a protocol ping every 30 s and terminates a socket that did not answer (or send anything) by the next +tick. Browsers answer protocol pings automatically. The `{"type":"ping"}` message is for clients that want a clock sample or a +liveness probe of their own; it is not required. + +## Limits + +| Limit | Value | On exceeding | +| ----- | ----- | ------------ | +| Client message size | 1024 bytes | close 1009 | +| Time to send `auth` | 10 s | close 4408 | +| Messages per socket | 5 per second sustained, burst 15 (`net.TokenBucket`; authentication counts) | close 4429 | +| Bad messages | 5 per socket | close 4400 | +| Sockets per client address | `MAX_CONN_PER_IP`, default 40 | HTTP 429 on upgrade | +| Server-side backlog | a client that leaves 1 MB unread is terminated | close 1006 on the client | + +Server-side tuning for tests lives in the `createServer` options `wsAuthTimeoutMs`, `wsPingMs`, `wsRate`, `wsBurst`, `wsBadBudget` +(no environment variables; the defaults above are what production runs). + +## Close codes + +| Code | Reason string | Meaning | Client should | +| ---- | ------------- | ------- | ------------- | +| 1001 | `shutdown` | server is restarting | reconnect with backoff (a few seconds, then up to 30 s) and refetch | +| 1006 | | abnormal (network, proxy, server terminated a dead or backlogged socket) | reconnect with backoff, refetch | +| 1009 | | a client frame was larger than 1024 bytes | bug in the client; do not retry in a loop | +| 4400 | `too_many_bad_messages` | 5 bad messages | bug in the client; do not retry in a loop | +| 4401 | `invalid_token`, `auth_required`, `token_revoked` | token unknown, revoked, user banned, or first message was not `auth` | **do not reconnect** with this token: go to login. `token_revoked` is sent as soon as the next ping tick (at most 30 s) notices the revocation (logout on that device, revoked in settings, ban) | +| 4408 | `auth_timeout` | no `auth` within 10 s | reconnect | +| 4429 | `rate_limited` | more than 5 msg/s sustained | back off at least 30 s | + +Suggested client loop: connect, send auth, on `ready` reset the backoff, on close with 4401/4400/1009 stop, otherwise retry after +`min(30 s, 1 s * 2^n)` plus jitter; after every `ready` following a gap, refetch the visible screen and `/notifications`. + +## Example session + +```text +C: {"type":"auth","token":"mQ3...43 chars"} +S: {"type":"ready","serverTime":1767225600000} + ... alice queues a building on a phone ... +S: {"type":"town","townId":1} (the other devices; the phone gets its echo) + ... the building finishes ... +S: {"type":"town","townId":1} +S: {"type":"notification","id":14,"kind":"build_done"} + ... bobby sends a raid at POP 1 ... +S: {"type":"incoming","townId":1,"arriveAt":1767236400000} +S: {"type":"notification","id":15,"kind":"incoming"} + ... it lands ... +S: {"type":"town","townId":1} +S: {"type":"report","id":3} +S: {"type":"notification","id":16,"kind":"report"} +C: {"type":"ping"} +S: {"type":"pong","serverTime":1767236401000} +``` + +## Where the hints come from + +| Source | Hint | +| ------ | ---- | +| any `notifications` row (`scheduler.notify`, after the transaction committed) | `notification`; plus `incoming` / `report` / `message` for kinds `incoming` / `report` / `message`, `alliance_message`; plus `town` for kinds that change a POP whose owner may differ from the event's POP (`town_lost`, `town_gained`, `transport_arrived`, `transport_delivered`, `movement_returned`, `reinforcements_sent_home`) | +| a finished event (`scheduler.onEvent`) | `town` to the owner of `events.town_id` (build, train, research, power check) and of both ends of the movement for `arrive` / `return` | +| a committed command (`commands.hooks.onCommand`) | `town` to the owner of the POP named in `townId`, `fromTownId`, `hostTownId`, `ownerTownId` or the new POP of `joinWorld`; for `recallMovement` both ends of the movement | + +Adding a notification kind needs no change here (it arrives as a generic `notification`). A new kind that deserves its own typed +hint is one `case` in `server/pushHooks.js` plus a row in the table above. + +## Not covered (yet) + +* No APNs/FCM: the `notifications` table is the hook for it (`scheduler.onNotify` sees every row). +* No subscription channels: every authenticated socket gets all hints of its user, across worlds (the hint carries `townId`). +* No per-device mute, no "last seen id" resume: reconnect and refetch. +* Reinforcing owners (units stationed in a POP that gets attacked) are told by the `report` hint, not by a `town` hint for their + home POP. +* Confederates do not get `incoming` for each other's POPs (nothing in the game layer produces it yet). diff --git a/docs/openapi.json b/docs/openapi.json index 663a494..528f324 100644 --- a/docs/openapi.json +++ b/docs/openapi.json @@ -3,7 +3,7 @@ "info": { "title": "UPSTREAM API", "version": "1.0.0", - "description": "Generated by tools/gen-openapi.js from server/routes. Every response carries serverTime; errors use the { error: { code, message, details } } envelope. Codes: bad_request, validation_failed, unauthorized, invalid_credentials, forbidden, not_found, method_not_allowed, conflict, request_in_progress, idempotency_key_reuse, payload_too_large, rate_limited, internal_error, signup_closed, username_taken, world_full, unknown_building, not_buildable, max_level, requirements_not_met, already_queued, queue_full, not_enough_resources, peering_office_required, already_in_alliance, not_in_alliance, alliance_name_taken, alliance_tag_taken, alliance_full, invite_expired, leader_must_transfer, notes_full, diplomacy_invalid, diplomacy_pending, proposal_exists, proposal_expired, unknown_unit, not_researchable, not_enough_units, units_offline, invalid_target, target_protected, protection_active, out_of_range, footprint_too_low, cannot_takeover, recall_expired, capacity_exceeded, no_transport_link" + "description": "Generated by tools/gen-openapi.js from server/routes. Every response carries serverTime; errors use the { error: { code, message, details } } envelope. Codes: bad_request, validation_failed, unauthorized, invalid_credentials, forbidden, not_found, method_not_allowed, conflict, request_in_progress, idempotency_key_reuse, payload_too_large, rate_limited, internal_error, signup_closed, username_taken, world_full, unknown_building, not_buildable, max_level, requirements_not_met, already_queued, queue_full, not_enough_resources, peering_office_required, already_in_alliance, not_in_alliance, alliance_name_taken, alliance_tag_taken, alliance_full, invite_expired, leader_must_transfer, notes_full, diplomacy_invalid, diplomacy_pending, proposal_exists, proposal_expired, unknown_unit, not_researchable, not_enough_units, units_offline, invalid_target, target_protected, protection_active, out_of_range, footprint_too_low, cannot_takeover, recall_expired, capacity_exceeded, no_transport_link, trade_ratio, offer_closed, own_offer, trade_out_of_range, world_ended, backbone_closed" }, "servers": [ { @@ -1892,6 +1892,205 @@ } } }, + "/alliances/{id}/reports": { + "get": { + "summary": "The alliance's shared reports, newest first (cursor: after = id of the last report seen; members only)", + "tags": [ + "reports" + ], + "operationId": "getAlliancesIdReports", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + }, + { + "name": "after", + "in": "query", + "required": false, + "schema": { + "type": "integer", + "minimum": 1 + } + }, + { + "name": "limit", + "in": "query", + "required": false, + "schema": { + "type": "integer", + "minimum": 1, + "maximum": 100 + } + } + ], + "security": [ + { + "bearer": [] + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/SharedReportList" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "403": { + "description": "Error codes: forbidden", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + } + }, + "/alliances/{id}/reports/{reportId}": { + "get": { + "summary": "One shared report with its full data (members only)", + "tags": [ + "reports" + ], + "operationId": "getAlliancesIdReportsReportId", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + }, + { + "name": "reportId", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "security": [ + { + "bearer": [] + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/SharedReportResponse" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "403": { + "description": "Error codes: forbidden", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + } + }, "/alliances/{id}/role": { "post": { "summary": "Set a member role: diplomat, officer or member (leader only)", @@ -2512,6 +2711,299 @@ } } }, + "/backbone/{id}": { + "get": { + "summary": "One landing site; members of the holding alliance also see the contribution ledger and what they may do", + "tags": [ + "world" + ], + "operationId": "getBackboneId", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "security": [ + { + "bearer": [] + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/LandingSiteResponse" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + } + }, + "/backbone/{id}/build": { + "post": { + "summary": "Start the next Backbone node level on a landing site your alliance holds (paid from the site's stockpile; one level at a time, up to level 100)", + "tags": [ + "world" + ], + "operationId": "postBackboneIdBuild", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "security": [ + { + "bearer": [] + } + ], + "responses": { + "201": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BackboneBuildStarted" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "403": { + "description": "Error codes: forbidden", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "409": { + "description": "Error codes: already_queued, backbone_closed, max_level, not_enough_resources, world_ended", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: idempotency_key_reuse, validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + } + }, + "/backbone/{id}/ship": { + "post": { + "summary": "Send resources from one of your POPs to a landing site your alliance holds (a transport: Internet exchange links, 500 each)", + "tags": [ + "world" + ], + "operationId": "postBackboneIdShip", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "requestBody": { + "required": true, + "content": { + "application/json": { + "schema": { + "type": "object", + "required": [ + "fromTownId", + "cargo" + ], + "properties": { + "fromTownId": { + "type": "integer", + "minimum": 1 + }, + "cargo": { + "type": "object", + "additionalProperties": true, + "description": "fiber/hardware/capital -> amount" + } + } + } + } + } + }, + "security": [ + { + "bearer": [] + } + ], + "responses": { + "201": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/MovementSent" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "403": { + "description": "Error codes: forbidden", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "409": { + "description": "Error codes: backbone_closed, capacity_exceeded, no_transport_link, not_enough_resources, world_ended", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: idempotency_key_reuse, validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + } + }, "/diplomacy/proposals/{proposalId}": { "delete": { "summary": "Withdraw a proposal your alliance made (needs diplomacy)", @@ -5040,6 +5532,196 @@ } } }, + "/reports/{id}/share": { + "post": { + "summary": "Put one of your reports into your alliance's shared folder (needs shareReport; keeps the report for another 14 days)", + "tags": [ + "reports" + ], + "operationId": "postReportsIdShare", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "security": [ + { + "bearer": [] + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ReportShared" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "403": { + "description": "Error codes: forbidden", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "409": { + "description": "Error codes: not_in_alliance, world_ended", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: idempotency_key_reuse, validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + }, + "delete": { + "summary": "Take a report out of the alliance folder (whoever shared it, or leader/officer)", + "tags": [ + "reports" + ], + "operationId": "deleteReportsIdShare", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "security": [ + { + "bearer": [] + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ReportShared" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "403": { + "description": "Error codes: forbidden", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "409": { + "description": "Error codes: world_ended", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + } + }, "/towns/{id}": { "get": { "summary": "Full state of one of your POPs: resources, power, buildings, build queue", @@ -5729,6 +6411,794 @@ } } } + }, + "/trade/offers": { + "get": { + "summary": "Open offers you can take: within the offer's max distance and the reach of one of your Internet exchanges (newest first, cursor: after = last id seen)", + "tags": [ + "trade" + ], + "operationId": "getTradeOffers", + "parameters": [ + { + "name": "worldId", + "in": "query", + "required": false, + "schema": { + "type": "integer", + "minimum": 1 + } + }, + { + "name": "townId", + "in": "query", + "required": false, + "schema": { + "type": "integer", + "minimum": 1 + } + }, + { + "name": "give", + "in": "query", + "required": false, + "schema": { + "type": "string", + "enum": [ + "fiber", + "hardware", + "capital" + ] + } + }, + { + "name": "want", + "in": "query", + "required": false, + "schema": { + "type": "string", + "enum": [ + "fiber", + "hardware", + "capital" + ] + } + }, + { + "name": "after", + "in": "query", + "required": false, + "schema": { + "type": "integer", + "minimum": 0 + } + }, + { + "name": "limit", + "in": "query", + "required": false, + "schema": { + "type": "integer", + "minimum": 1, + "maximum": 100 + } + } + ], + "security": [ + { + "bearer": [] + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/TradeOfferList" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + }, + "post": { + "summary": "Post an offer from one of your POPs: give X of A for Y of B within a max distance. The offered amount is escrowed and a transport link reserved", + "tags": [ + "trade" + ], + "operationId": "postTradeOffers", + "parameters": [], + "requestBody": { + "required": true, + "content": { + "application/json": { + "schema": { + "type": "object", + "required": [ + "townId", + "giveRes", + "giveAmount", + "wantRes", + "wantAmount", + "maxDistance" + ], + "properties": { + "townId": { + "type": "integer", + "minimum": 1 + }, + "giveRes": { + "type": "string", + "enum": [ + "fiber", + "hardware", + "capital" + ] + }, + "giveAmount": { + "type": "integer", + "minimum": 1 + }, + "wantRes": { + "type": "string", + "enum": [ + "fiber", + "hardware", + "capital" + ] + }, + "wantAmount": { + "type": "integer", + "minimum": 1 + }, + "maxDistance": { + "type": "integer", + "minimum": 1, + "maximum": 300 + } + } + } + } + } + }, + "security": [ + { + "bearer": [] + } + ], + "responses": { + "201": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/TradeOfferResponse" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "409": { + "description": "Error codes: capacity_exceeded, no_transport_link, not_enough_resources, trade_ratio, world_ended", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: idempotency_key_reuse, validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + } + }, + "/trade/offers/mine": { + "get": { + "summary": "Offers you posted or accepted, any status (newest first)", + "tags": [ + "trade" + ], + "operationId": "getTradeOffersMine", + "parameters": [ + { + "name": "worldId", + "in": "query", + "required": false, + "schema": { + "type": "integer", + "minimum": 1 + } + }, + { + "name": "status", + "in": "query", + "required": false, + "schema": { + "type": "string", + "enum": [ + "open", + "accepted", + "completed", + "cancelled", + "expired", + "void" + ] + } + }, + { + "name": "after", + "in": "query", + "required": false, + "schema": { + "type": "integer", + "minimum": 0 + } + }, + { + "name": "limit", + "in": "query", + "required": false, + "schema": { + "type": "integer", + "minimum": 1, + "maximum": 100 + } + } + ], + "security": [ + { + "bearer": [] + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/TradeOfferList" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + } + }, + "/trade/offers/{id}": { + "get": { + "summary": "One offer (open ones to every operator of the world, closed ones to the two parties)", + "tags": [ + "trade" + ], + "operationId": "getTradeOffersId", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "security": [ + { + "bearer": [] + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/TradeOfferResponse" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + }, + "delete": { + "summary": "Cancel your open offer; the escrow returns to the POP", + "tags": [ + "trade" + ], + "operationId": "deleteTradeOffersId", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "security": [ + { + "bearer": [] + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/TradeCancelled" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "409": { + "description": "Error codes: offer_closed, world_ended", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + } + }, + "/trade/offers/{id}/accept": { + "post": { + "summary": "Take an open offer with one of your POPs: two transports leave at once (your payment, their goods) and the offer is settled when both arrive", + "tags": [ + "trade" + ], + "operationId": "postTradeOffersIdAccept", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "requestBody": { + "required": true, + "content": { + "application/json": { + "schema": { + "type": "object", + "required": [ + "townId" + ], + "properties": { + "townId": { + "type": "integer", + "minimum": 1 + } + } + } + } + } + }, + "security": [ + { + "bearer": [] + } + ], + "responses": { + "201": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/TradeAccepted" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "409": { + "description": "Error codes: capacity_exceeded, no_transport_link, not_enough_resources, offer_closed, own_offer, trade_out_of_range, world_ended", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: idempotency_key_reuse, validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + } + }, + "/worlds/{id}/results": { + "get": { + "summary": "The final ranking snapshot (operators, alliances, attackers, defenders, winner); available once the world has ended", + "tags": [ + "world" + ], + "operationId": "getWorldsIdResults", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "security": [ + { + "bearer": [] + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/WorldResults" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + } + }, + "/worlds/{id}/status": { + "get": { + "summary": "The state of the world: phase (running, backbone_open, ended), world age, the landing sites with holder, node level, stockpile and build progress, the winner", + "tags": [ + "world" + ], + "operationId": "getWorldsIdStatus", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "security": [ + { + "bearer": [] + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/WorldStatus" + } + } + } + }, + "401": { + "description": "Error codes: unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "404": { + "description": "Error codes: not_found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "422": { + "description": "Error codes: validation_failed", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + }, + "500": { + "description": "Error codes: internal_error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Error" + } + } + } + } + } + } } }, "components": { @@ -6417,6 +7887,10 @@ "bonus": { "type": "string", "nullable": true + }, + "site": { + "type": "object", + "additionalProperties": true } }, "required": [ @@ -7883,6 +9357,12 @@ "items": { "$ref": "#/components/schemas/Movement" } + }, + "alliedIncoming": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Movement" + } } }, "required": [ @@ -8316,6 +9796,736 @@ "protectionUntil" ], "additionalProperties": true + }, + "TradeAmount": { + "type": "object", + "properties": { + "resource": { + "type": "string" + }, + "amount": { + "type": "integer" + } + }, + "required": [ + "resource", + "amount" + ], + "additionalProperties": true + }, + "TradeOffer": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "status": { + "type": "string" + }, + "worldId": { + "type": "integer" + }, + "townId": { + "type": "integer" + }, + "townName": { + "type": "string", + "nullable": true + }, + "x": { + "type": "integer", + "nullable": true + }, + "y": { + "type": "integer", + "nullable": true + }, + "operator": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "name": { + "type": "string", + "nullable": true + } + }, + "required": [ + "id", + "name" + ], + "additionalProperties": true + }, + "give": { + "$ref": "#/components/schemas/TradeAmount" + }, + "want": { + "$ref": "#/components/schemas/TradeAmount" + }, + "maxDistance": { + "type": "integer" + }, + "createdAt": { + "type": "integer" + }, + "expiresAt": { + "type": "integer" + }, + "acceptedAt": { + "type": "integer", + "nullable": true + }, + "closedAt": { + "type": "integer", + "nullable": true + }, + "role": { + "type": "string" + }, + "acceptableFrom": { + "type": "array", + "items": { + "type": "object", + "properties": { + "townId": { + "type": "integer" + }, + "distance": { + "type": "number" + } + }, + "required": [ + "townId", + "distance" + ], + "additionalProperties": true + } + } + }, + "required": [ + "id", + "status", + "townId", + "operator", + "give", + "want", + "maxDistance", + "createdAt", + "expiresAt" + ], + "additionalProperties": true + }, + "TradeOfferList": { + "type": "object", + "properties": { + "serverTime": { + "type": "integer" + }, + "items": { + "type": "array", + "items": { + "$ref": "#/components/schemas/TradeOffer" + } + }, + "next": { + "type": "integer", + "nullable": true + }, + "exchangeLevels": { + "type": "array", + "items": { + "type": "object", + "properties": { + "townId": { + "type": "integer" + }, + "level": { + "type": "integer" + }, + "reach": { + "type": "number" + } + }, + "required": [ + "townId", + "level", + "reach" + ], + "additionalProperties": true + } + } + }, + "required": [ + "serverTime", + "items", + "next" + ], + "additionalProperties": true + }, + "TradeOfferResponse": { + "type": "object", + "properties": { + "serverTime": { + "type": "integer" + }, + "offer": { + "$ref": "#/components/schemas/TradeOffer" + } + }, + "required": [ + "serverTime", + "offer" + ], + "additionalProperties": true + }, + "TradeCancelled": { + "type": "object", + "properties": { + "serverTime": { + "type": "integer" + }, + "offerId": { + "type": "integer" + }, + "status": { + "type": "string" + }, + "returned": { + "$ref": "#/components/schemas/TradeAmount" + } + }, + "required": [ + "serverTime", + "offerId", + "status", + "returned" + ], + "additionalProperties": true + }, + "TradeAccepted": { + "type": "object", + "properties": { + "serverTime": { + "type": "integer" + }, + "offerId": { + "type": "integer" + }, + "status": { + "type": "string" + }, + "goodsMovementId": { + "type": "integer" + }, + "paymentMovementId": { + "type": "integer" + }, + "distance": { + "type": "number" + }, + "arriveAt": { + "type": "integer" + }, + "give": { + "$ref": "#/components/schemas/TradeAmount" + }, + "want": { + "$ref": "#/components/schemas/TradeAmount" + } + }, + "required": [ + "serverTime", + "offerId", + "status", + "goodsMovementId", + "paymentMovementId", + "distance", + "arriveAt", + "give", + "want" + ], + "additionalProperties": true + }, + "LandingSite": { + "type": "object", + "properties": { + "id": { + "type": "integer", + "nullable": true + }, + "index": { + "type": "integer" + }, + "x": { + "type": "integer" + }, + "y": { + "type": "integer" + }, + "holder": { + "type": "object", + "nullable": true, + "properties": { + "allianceId": { + "type": "integer" + }, + "tag": { + "type": "string" + }, + "name": { + "type": "string" + } + }, + "additionalProperties": true + }, + "takenBy": { + "type": "object", + "nullable": true, + "additionalProperties": true + }, + "takenAt": { + "type": "integer", + "nullable": true + }, + "level": { + "type": "integer" + }, + "maxLevel": { + "type": "integer" + }, + "progress": { + "type": "number" + }, + "pool": { + "$ref": "#/components/schemas/Cost" + }, + "build": { + "type": "object", + "nullable": true, + "properties": { + "toLevel": { + "type": "integer" + }, + "startedAt": { + "type": "integer" + }, + "dueAt": { + "type": "integer" + } + }, + "additionalProperties": true + }, + "next": { + "type": "object", + "nullable": true, + "properties": { + "toLevel": { + "type": "integer" + }, + "cost": { + "$ref": "#/components/schemas/Cost" + }, + "durationMs": { + "type": "integer" + } + }, + "additionalProperties": true + } + }, + "required": [ + "id", + "index", + "x", + "y", + "holder", + "takenBy", + "takenAt", + "level", + "maxLevel", + "progress", + "pool", + "build", + "next" + ], + "additionalProperties": true + }, + "WorldStatus": { + "type": "object", + "properties": { + "serverTime": { + "type": "integer" + }, + "worldId": { + "type": "integer" + }, + "name": { + "type": "string" + }, + "speed": { + "type": "number" + }, + "status": { + "type": "string" + }, + "phase": { + "type": "string" + }, + "ageDays": { + "type": "number" + }, + "openDay": { + "type": "integer" + }, + "opensAt": { + "type": "integer" + }, + "sites": { + "type": "array", + "items": { + "$ref": "#/components/schemas/LandingSite" + } + }, + "winner": { + "type": "object", + "nullable": true, + "additionalProperties": true + }, + "endsAt": { + "type": "integer", + "nullable": true + }, + "endedAt": { + "type": "integer", + "nullable": true + } + }, + "required": [ + "serverTime", + "worldId", + "name", + "speed", + "status", + "phase", + "ageDays", + "openDay", + "opensAt", + "sites", + "winner", + "endsAt", + "endedAt" + ], + "additionalProperties": true + }, + "WorldResults": { + "type": "object", + "properties": { + "serverTime": { + "type": "integer" + }, + "available": { + "type": "boolean" + }, + "status": { + "type": "string" + }, + "winner": { + "type": "object", + "nullable": true, + "additionalProperties": true + }, + "endsAt": { + "type": "integer", + "nullable": true + }, + "results": { + "type": "object", + "nullable": true, + "additionalProperties": true + } + }, + "required": [ + "serverTime", + "available", + "status", + "winner", + "endsAt", + "results" + ], + "additionalProperties": true + }, + "LandingSiteResponse": { + "type": "object", + "properties": { + "serverTime": { + "type": "integer" + }, + "site": { + "$ref": "#/components/schemas/LandingSite" + }, + "you": { + "type": "object", + "properties": { + "holder": { + "type": "boolean" + }, + "canBuild": { + "type": "boolean" + }, + "canShip": { + "type": "boolean" + }, + "canAttack": { + "type": "boolean" + } + }, + "required": [ + "holder", + "canBuild", + "canShip", + "canAttack" + ], + "additionalProperties": true + }, + "contributions": { + "type": "array", + "items": { + "type": "object", + "properties": { + "operatorId": { + "type": "integer" + }, + "name": { + "type": "string" + }, + "fiber": { + "type": "integer" + }, + "hardware": { + "type": "integer" + }, + "capital": { + "type": "integer" + } + }, + "required": [ + "operatorId", + "name", + "fiber", + "hardware", + "capital" + ], + "additionalProperties": true + } + } + }, + "required": [ + "serverTime", + "site", + "you" + ], + "additionalProperties": true + }, + "BackboneBuildStarted": { + "type": "object", + "properties": { + "serverTime": { + "type": "integer" + }, + "siteId": { + "type": "integer" + }, + "eventId": { + "type": "integer" + }, + "toLevel": { + "type": "integer" + }, + "startedAt": { + "type": "integer" + }, + "dueAt": { + "type": "integer" + }, + "cost": { + "$ref": "#/components/schemas/Cost" + } + }, + "required": [ + "serverTime", + "siteId", + "eventId", + "toLevel", + "startedAt", + "dueAt", + "cost" + ], + "additionalProperties": true + }, + "ReportShared": { + "type": "object", + "properties": { + "serverTime": { + "type": "integer" + }, + "changed": { + "type": "boolean" + }, + "reportId": { + "type": "integer" + }, + "allianceId": { + "type": "integer" + } + }, + "required": [ + "serverTime", + "changed", + "reportId", + "allianceId" + ], + "additionalProperties": true + }, + "SharedReportItem": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "type": { + "type": "string" + }, + "createdAt": { + "type": "integer" + }, + "sharedAt": { + "type": "integer" + }, + "sharedBy": { + "type": "object", + "properties": { + "operatorId": { + "type": "integer" + }, + "name": { + "type": "string" + } + }, + "required": [ + "operatorId", + "name" + ], + "additionalProperties": true + }, + "summary": { + "type": "object", + "additionalProperties": true + } + }, + "required": [ + "id", + "type", + "createdAt", + "sharedAt", + "sharedBy", + "summary" + ], + "additionalProperties": true + }, + "SharedReportList": { + "type": "object", + "properties": { + "serverTime": { + "type": "integer" + }, + "items": { + "type": "array", + "items": { + "$ref": "#/components/schemas/SharedReportItem" + } + }, + "next": { + "type": "integer", + "nullable": true + } + }, + "required": [ + "serverTime", + "items", + "next" + ], + "additionalProperties": true + }, + "SharedReport": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "type": { + "type": "string" + }, + "createdAt": { + "type": "integer" + }, + "expiresAt": { + "type": "integer" + }, + "sharedAt": { + "type": "integer" + }, + "sharedBy": { + "type": "object", + "properties": { + "operatorId": { + "type": "integer" + }, + "name": { + "type": "string" + } + }, + "required": [ + "operatorId", + "name" + ], + "additionalProperties": true + }, + "summary": { + "type": "object", + "additionalProperties": true + }, + "data": { + "type": "object", + "additionalProperties": true + } + }, + "required": [ + "id", + "type", + "createdAt", + "expiresAt", + "sharedAt", + "sharedBy", + "summary", + "data" + ], + "additionalProperties": true + }, + "SharedReportResponse": { + "type": "object", + "properties": { + "serverTime": { + "type": "integer" + }, + "report": { + "$ref": "#/components/schemas/SharedReport" + } + }, + "required": [ + "serverTime", + "report" + ], + "additionalProperties": true } }, "securitySchemes": { @@ -8522,6 +10732,30 @@ "no_transport_link": { "status": 409, "description": "All transport links are busy (or there is no Internet exchange)." + }, + "trade_ratio": { + "status": 409, + "description": "The offered and the wanted amount may differ by at most 1:2." + }, + "offer_closed": { + "status": 409, + "description": "That offer is not open any more." + }, + "own_offer": { + "status": 409, + "description": "You cannot accept your own offer." + }, + "trade_out_of_range": { + "status": 409, + "description": "That POP is too far from the offer (its max distance or your Internet exchange reach)." + }, + "world_ended": { + "status": 409, + "description": "This world has ended: it can still be read, but nothing can be changed." + }, + "backbone_closed": { + "status": 409, + "description": "The backbone landing sites have not appeared yet." } } } diff --git a/public/css/style.css b/public/css/style.css index df68459..e0eb35d 100644 --- a/public/css/style.css +++ b/public/css/style.css @@ -84,7 +84,10 @@ button:focus:not(:focus-visible), [tabindex="-1"]:focus { outline: none; } .nav-btn[aria-current="page"]::before { content: ""; position: absolute; top: 0; left: 28%; right: 28%; height: 3px; border-radius: 0 0 3px 3px; background: var(--cyan); } .nav-ic { position: relative; display: inline-flex; } .nav-ic svg.ic { width: 24px; height: 24px; } -.nav-badge { position: absolute; top: -5px; right: -9px; min-width: 17px; height: 17px; padding: 0 4px; border-radius: 9px; background: var(--red); color: #1a0710; font-size: 11px; font-weight: 700; display: grid; place-items: center; } +.nav-badge { position: absolute; top: -5px; right: -9px; min-width: 17px; height: 17px; padding: 0 4px; border-radius: 9px; background: var(--cyan); color: #04222b; font-size: 11px; font-weight: 700; display: grid; place-items: center; } +.nav-badge.is-alert { background: var(--red); color: #1a0710; animation: mil-pulse 1.4s ease-in-out infinite; } +@keyframes mil-pulse { 50% { box-shadow: 0 0 0 5px rgba(255, 107, 135, .0), 0 0 0 0 rgba(255, 107, 135, .5); transform: scale(1.12); } } +.more-list { display: grid; gap: 8px; padding-bottom: 6px; } .nav-lbl { max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } @media (orientation: landscape) and (max-height: 520px), (min-width: 900px) { @@ -321,4 +324,190 @@ input:focus-visible, select:focus-visible { outline: 2px solid var(--cyan); outl .device .row-sub { white-space: normal; } .card .btn.wide { margin-top: 10px; } +/* ---------------------------------------------------------------- social (alliance, messages, rankings): .soc- */ +.soc-page { gap: 10px; } +.soc-body, .soc-content, .soc-listbox { display: grid; gap: 10px; align-content: start; min-width: 0; } +.soc-card .card-head { margin-bottom: 8px; } +.soc-card > .detail-desc { margin-bottom: 10px; } +.soc-card .field { margin-top: 10px; } +.soc-head-actions { display: flex; align-items: center; gap: 4px; } +.soc-stack { grid-auto-flow: row; grid-auto-columns: auto; } +.soc-title { display: flex; align-items: center; gap: 10px; margin-bottom: 4px; min-width: 0; } +.soc-name { font-size: 20px; font-weight: 700; overflow-wrap: anywhere; } +.soc-head .bar { --c: var(--cyan); height: 6px; margin-top: 4px; } +.soc-tag { font-family: var(--mono); color: var(--cyan); flex: none; } +.soc-role-leader { color: #2b2204; background: var(--amber); border-color: var(--amber); font-weight: 650; } +.soc-role-diplomat { color: var(--violet); border-color: color-mix(in srgb, var(--violet) 60%, var(--line2)); } +.soc-role-officer { color: var(--cyan); border-color: color-mix(in srgb, var(--cyan) 55%, var(--line2)); } +.soc-state-war { color: var(--red); border-color: #7a2a3f; background: #2d1019; } +.soc-state-nap { color: var(--cyan); border-color: color-mix(in srgb, var(--cyan) 55%, var(--line2)); } +.soc-state-confed { color: var(--green); border-color: #1a6a4f; background: #0e2b23; } +.soc-state-same { color: var(--amber); } + +.soc-tabs { margin-bottom: 0; } +.soc-tabs .seg-btn { min-width: 0; padding: 0 4px; font-size: 14px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.soc-tabs4 .seg-btn { font-size: 13px; display: inline-flex; align-items: center; justify-content: center; gap: 5px; } +.soc-tabn { min-width: 18px; height: 18px; padding: 0 5px; border-radius: 9px; background: var(--red); color: #1a0710; font-size: 11px; font-weight: 700; display: inline-grid; place-items: center; } +.soc-subtabs { display: flex; gap: 8px; flex-wrap: wrap; } +.soc-subtabs .chip-btn { flex: 1; } +.soc-toolbar { display: flex; align-items: center; justify-content: space-between; gap: 8px; } + +.soc-list { display: grid; gap: 8px; min-width: 0; } +.soc-item { display: flex; align-items: center; gap: 8px; background: var(--panel2); border: 1px solid var(--line); border-radius: 12px; padding: 8px 10px; min-height: 56px; flex-wrap: wrap; min-width: 0; } +.soc-item > .row-main { min-width: 0; flex: 1 1 140px; } +.soc-item .row-sub { white-space: normal; overflow-wrap: anywhere; } +.soc-item .form-error { flex-basis: 100%; margin: 4px 0 0; } +.soc-actions { display: flex; gap: 8px; flex: none; } +.soc-invite .soc-actions { margin-left: auto; } +.soc-member .row-title b { overflow-wrap: anywhere; } +.soc-member .row-sub { white-space: normal; } +.soc-wrap { white-space: normal !important; } +.soc-req { margin: 2px 0 8px; } +.soc-hint { padding: 0 2px; } +.soc-inline { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 8px; align-items: center; } +.soc-err { display: grid; gap: 8px; justify-items: start; } + +.soc-text { width: 100%; min-height: 76px; max-height: 40vh; padding: 10px 12px; border-radius: 12px; background: #080e1c; border: 1px solid var(--line2); color: var(--text); font-size: 16px; line-height: 1.35; resize: vertical; font-family: var(--font); } +.soc-text:focus-visible { outline: 2px solid var(--cyan); outline-offset: 1px; border-color: var(--cyan); } +.soc-composer { display: grid; gap: 8px; } +.soc-composer-bar { display: flex; align-items: center; justify-content: space-between; gap: 10px; } +.soc-addnote { display: grid; gap: 8px; margin-top: 10px; } +.soc-count { font-size: 12px; color: var(--dimmer); } +.soc-count.over { color: var(--red); font-weight: 700; } +.soc-rate { color: var(--amber); background: #2b2204; border: 1px solid #6b5a1f; border-radius: 10px; padding: 8px 12px; font-size: 14px; } +.soc-text-out, .soc-msg-body { white-space: pre-wrap; overflow-wrap: anywhere; word-break: break-word; font-size: 15px; line-height: 1.4; } +.soc-note .soc-text-out { margin-bottom: 2px; } + +.soc-msgrow { display: flex; align-items: center; gap: 2px; } +.soc-msgrow .soc-msg { flex: 1; min-width: 0; align-items: flex-start; } +.soc-msg.unread { border-color: var(--cyan); background: #0c1f33; } +.soc-msg .when { margin-top: 2px; } +.soc-preview { color: var(--dim); font-size: 14px; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; overflow-wrap: anywhere; white-space: normal; } +.soc-feed { align-items: flex-start; } +.soc-feed.unread { border-color: var(--cyan); background: #0c1f33; } +.soc-feed .row-title { align-items: center; } +.soc-feed .when { margin-left: auto; } + +.soc-thread-head { display: flex; align-items: center; gap: 6px; } +.soc-thread-name { flex: 1; min-width: 0; font-size: 18px; overflow-wrap: anywhere; } +.soc-thread { display: grid; gap: 8px; } +.soc-bubble { max-width: 86%; padding: 8px 12px 6px; border-radius: 14px; background: var(--panel2); border: 1px solid var(--line); justify-self: start; min-width: 0; } +.soc-bubble.out { justify-self: end; background: #11304a; border-color: #1f5b86; } +.soc-bubble.unread { border-color: var(--cyan); } +.soc-bubble-meta { display: flex; align-items: center; justify-content: flex-end; gap: 6px; margin-top: 2px; color: var(--dimmer); } +.soc-del { width: 32px; height: 32px; display: inline-grid; place-items: center; background: none; border: 0; color: var(--dimmer); border-radius: 8px; } +.soc-del svg.ic { width: 14px; height: 14px; } +.soc-reply { position: sticky; bottom: 0; background: var(--bg); border-top: 1px solid var(--line); padding: 8px 0 calc(8px + 0px); margin-top: 4px; } + +.soc-dip { display: grid; gap: 10px; } +.soc-rel .row-sub { white-space: normal; display: flex; flex-wrap: wrap; align-items: center; gap: 4px; } +.soc-eta { color: var(--amber); } +.soc-moves { display: grid; gap: 8px; } +.soc-move { min-height: 64px; } + +.soc-yourank { display: flex; align-items: center; gap: 12px; border-color: var(--cyan); background: #0c1f33; padding: 10px 12px; } +.soc-yr-n { font-size: 24px; font-weight: 700; color: var(--cyan); min-width: 2.4ch; } +.soc-ranklist { display: grid; gap: 6px; list-style: none; padding: 0; margin: 0; } +.soc-rank { width: 100%; display: flex; align-items: center; gap: 10px; background: var(--panel2); border: 1px solid var(--line); border-radius: 12px; padding: 8px 10px; min-height: 54px; text-align: left; } +.soc-rank.you { border-color: var(--cyan); background: #0c1f33; box-shadow: 0 0 0 1px rgba(77, 227, 255, .3); } +.soc-rk { color: var(--dimmer); min-width: 3.2ch; font-size: 14px; } +.soc-rank .row-sub { white-space: normal; overflow-wrap: anywhere; } +.soc-val { font-size: 16px; color: var(--text); flex: none; } +@media (max-width: 380px) { .soc-tabs .seg-btn { font-size: 13px; } .soc-bubble { max-width: 94%; } } + @media (prefers-reduced-motion: reduce) { .sheet, .backdrop, .toast, .bar i { transition: none; } } + +/* ---------------------------------------------------------------- military + expansion (prefix mil-, send-, rep-) */ +.row-sub.wrap { white-space: normal; overflow: visible; } +.head-actions { display: flex; align-items: center; gap: 6px; } +.mil-sections { display: grid; gap: 12px; } +.mil-list { display: grid; gap: 8px; } +.mil-row { display: flex; align-items: center; gap: 10px; background: var(--panel2); border: 1px solid var(--line); border-radius: 12px; padding: 8px 10px; min-height: 58px; } +.mil-row.current { border-color: var(--cyan); } +.mil-row.out.type-return { opacity: .8; } +.mil-row .row-main { min-width: 0; } +.mil-row .lv { color: var(--dim); font-size: 13px; } +.mil-when { display: grid; justify-items: end; gap: 1px; flex: none; text-align: right; } +.mil-when small { color: var(--dimmer); font-size: 11px; } +.mil-cd { font-size: 15px; } +.mil-cd.big { font-size: 19px; color: var(--red); } +.mil-bar { margin-top: 5px; --c: var(--cyan); } +.mil-group { background: var(--panel2); border: 1px solid var(--line); border-radius: 12px; padding: 8px 10px; display: grid; gap: 4px; } +.row-ic.bad { background: #3a1620; color: var(--red); } +.warn-card { border-color: #7a2a3f; background: rgba(48, 14, 24, .9); } +.warn-card .card-head h2 { color: #ffc4d0; } +.mil-banner { display: flex; align-items: center; gap: 10px; } +.mil-banner .row-main { flex: 1; min-width: 0; } +.mil-banner b { color: #ffd0da; } +.mil-banner .mil-cd { color: var(--red); } +.mil-banner:not([hidden]) .row-ic { animation: mil-pulse-ic 1.4s ease-in-out infinite; } +@keyframes mil-pulse-ic { 50% { box-shadow: 0 0 0 6px rgba(255, 107, 135, .18); } } +.mil-recall { margin-top: 8px; width: max-content; } +.mil-recall .mil-cd { font-size: 13px; } +.mil-row .arrow { display: inline-flex; vertical-align: middle; margin: 0 4px; color: var(--dimmer); } +.mil-row .arrow svg.ic { width: 14px; height: 14px; } +.mil-end { display: inline-flex; align-items: center; flex-wrap: wrap; gap: 4px; } +.mil-coord { display: inline-flex; align-items: center; gap: 4px; background: none; border: 0; color: var(--cyan); padding: 2px 4px; min-height: 28px; font-size: 12px; text-decoration: underline; text-underline-offset: 2px; } +.mil-coord svg.ic { width: 13px; height: 13px; } +.pop-top { max-width: 1100px; margin: 0 auto; padding: 4px 12px 0; display: grid; gap: 8px; } +.row-btn.locked { opacity: .6; } +.card.inner { background: var(--panel2); } +.stepper { display: grid; grid-template-columns: auto auto minmax(0, 1fr) auto auto; gap: 6px; align-items: center; } +.stepper .btn { min-width: 46px; padding: 0 8px; } +input.mil-num { width: 100%; min-height: 46px; padding: 0 10px; border-radius: 12px; background: #080e1c; border: 1px solid var(--line2); color: var(--text); font-size: 16px; text-align: center; font-family: var(--mono); -moz-appearance: textfield; } +input.mil-num::-webkit-outer-spin-button, input.mil-num::-webkit-inner-spin-button { -webkit-appearance: none; margin: 0; } + +.send { gap: 14px; } +.send-sec { display: grid; gap: 8px; } +.send-sec:empty { display: none; } +.send-coords { display: grid; grid-template-columns: auto minmax(0, 1fr) auto minmax(0, 1fr) auto; gap: 6px; align-items: center; } +.chips { display: flex; flex-wrap: wrap; gap: 6px; } +.send-target { background: var(--panel2); border-radius: 12px; padding: 10px 12px; display: grid; gap: 4px; } +.wrap-seg { grid-auto-flow: row; grid-template-columns: repeat(auto-fit, minmax(130px, 1fr)); } +.wrap-seg .seg-btn { display: inline-flex; align-items: center; justify-content: center; gap: 6px; padding: 6px 8px; font-size: 14px; } +.seg-btn:disabled { opacity: .4; cursor: not-allowed; } +.send-why { display: grid; gap: 2px; } +.mil-pick { background: var(--panel2); border-radius: 12px; padding: 8px 10px; display: grid; gap: 6px; } +.pick-ctl { display: grid; grid-template-columns: auto minmax(60px, 1fr) auto 64px auto; gap: 6px; align-items: center; } +.pick-ctl .btn.small { min-width: 40px; padding: 0 8px; } +.pick-ctl input.mil-num { min-height: 40px; padding: 0 4px; } +.pick-ctl input[type="range"] { width: 100%; min-height: 40px; accent-color: var(--cyan); } +.send-preview { background: var(--panel2); border-radius: 12px; padding: 4px 12px; } +.send-warn { display: grid; gap: 8px; } +.warn-check { display: flex; gap: 10px; align-items: flex-start; background: #2a210a; border: 1px solid #6b5a1f; border-radius: 12px; padding: 10px 12px; color: var(--amber); font-size: 14px; } +.warn-check input { width: 22px; height: 22px; flex: none; margin-top: 2px; accent-color: var(--amber); } +select { width: 100%; } + +.alert.rep.tone-good .row-ic { color: var(--green); } +.alert.rep.tone-bad .row-ic { color: var(--red); } +.alert.rep.tone-warn .row-ic { color: var(--amber); } +.rep-detail { gap: 12px; } +.rep-verdict { display: flex; align-items: center; gap: 8px; padding: 10px 14px; border-radius: 12px; font-size: 18px; } +.rep-verdict.victory { background: #0e2b23; color: var(--green); border: 1px solid #1a6a4f; } +.rep-verdict.defeat { background: #2d1019; color: #ffc4d0; border: 1px solid #7a2a3f; } +.rep-sec { display: grid; gap: 6px; } +.rep-party { display: inline-flex; flex-wrap: wrap; align-items: center; justify-content: flex-end; gap: 4px; } +.mil-table { width: 100%; border-collapse: collapse; font-size: 14px; } +.mil-table th { text-align: right; font-weight: 500; color: var(--dimmer); font-size: 12px; padding: 2px 6px; } +.mil-table td { padding: 5px 6px; border-top: 1px solid var(--line); } +.mil-table td:not(:first-child) { text-align: right; } +.rep-group { display: grid; gap: 4px; margin-bottom: 8px; } +.rep-buildings { display: grid; grid-template-columns: repeat(auto-fill, minmax(150px, 1fr)); gap: 4px 12px; font-size: 14px; } +.rep-buildings li { display: flex; justify-content: space-between; gap: 8px; border-bottom: 1px solid var(--line); padding: 3px 0; } +.rep-raw { white-space: pre-wrap; font-size: 12px; color: var(--dim); } + +.hud-town { grid-column: 1 / -1; display: flex; align-items: center; gap: 8px; color: var(--cyan); } +.hud-town select { min-height: 36px; font-size: 14px; padding: 0 10px; width: auto; max-width: 100%; flex: 0 1 280px; } +.hud-town svg.ic { width: 18px; height: 18px; } +.lg.mv-out { height: 0; width: 14px; border-top: 2px dashed var(--cyan); } +.lg.mv-in { height: 0; width: 14px; border-top: 2px dashed var(--red); } +@media (orientation: landscape) and (max-height: 520px) { .hud-town select { min-height: 30px; } } +@media (prefers-reduced-motion: reduce) { .nav-badge.is-alert, .mil-banner .row-ic { animation: none; } } +.units-head { max-width: 1100px; margin: 0 auto; padding: 4px 12px 0; } +.send-foot { position: sticky; bottom: -1px; z-index: 2; display: grid; gap: 8px; padding: 10px 0 2px; margin-top: 4px; background: linear-gradient(180deg, rgba(12, 19, 34, 0), var(--panel) 22%); } +.send-foot .form-error { margin-bottom: 0; } +.row-btn.mil-train { flex-wrap: wrap; row-gap: 6px; } +.mil-train .costs { flex-basis: 100%; gap: 6px; padding-left: 48px; } +.mil-train .cost { padding: 3px 8px; } +.mil-train .cost svg.ic { width: 15px; height: 15px; } +.mil-train .pill { max-width: none; } diff --git a/public/icons/sprite.svg b/public/icons/sprite.svg index d5b2943..258e810 100644 --- a/public/icons/sprite.svg +++ b/public/icons/sprite.svg @@ -45,5 +45,22 @@ + + + + + + + + + + + + + + + + + diff --git a/public/index.html b/public/index.html index 4c15efe..b7894c5 100644 --- a/public/index.html +++ b/public/index.html @@ -33,14 +33,29 @@ + + + + + + + + + + + + + + + diff --git a/public/js/data.js b/public/js/data.js index f2799f1..292d7e3 100644 --- a/public/js/data.js +++ b/public/js/data.js @@ -109,6 +109,10 @@ editNotes: ['leader', 'diplomat', 'officer'], broadcast: ['leader', 'diplomat', 'officer', 'member'], disband: ['leader'], + shareReport: ['leader', 'diplomat', 'officer', 'member'], // put one of YOUR reports into the alliance folder + viewSharedReports: ['leader', 'diplomat', 'officer', 'member'], + unshareReport: ['leader', 'officer'], // plus whoever shared it + backboneBuild: ['leader', 'diplomat', 'officer', 'member'], // start the next Backbone node level on a held landing site }, allianceBaseSize: 10, // size cap = base + perLevel * Peering office level (best POP of the leader) allianceSizePerLevel: 2, @@ -235,6 +239,34 @@ researchSpeedMax: 0.5, }; - return { UNITS, UNIT_ORDER, MILITARY, RESEARCH, EXPANSION, TRANSPORT, MOVE_ROLES, INCUMBENT, HOUR_MS, RESOURCES, FORMULAS, FIELD_SLOTS, FIELD_TYPES, FIELD_PRODUCES, FIELDS_PER_TYPE, WILD_SLOTS, + // Trade at the Internet exchange. Offers are "give X of A for Y of B, max distance Z"; each side must fit one transport + // link (TRANSPORT.capacityPerLink). The exchange level sets how far you see and trade (reachPerLevel tiles per level) + // and how many offers you may keep open per POP together with running transports (links). + const TRADE = { + ratioMax: 2, // give/want must lie in [1/ratioMax, ratioMax] (pump-feeding guard) + ttlHours: 48, // an offer expires after this long, divided by world speed + reachPerLevel: 10, // tiles + maxDistance: 300, // upper bound of an offer's max distance + scanChunk: 200, // offers read per round trip when listing (the range filter runs in JS) + }; + + // End game (backbone race). World age is in WORLD days: real days * world speed. + const ENDGAME = { + openDay: 100, // the landing sites appear at this world age + sites: 7, + graceDays: 2, // after level maxLevel is reached the world ends this long after (divided by world speed) + siteRingMin: 0.35, siteRingMax: 0.8, // landing sites sit between these fractions of the map radius + siteMinSpacing: 6, // tiles between two sites + defenceMult: 12, // incumbent site defence x this = the heavy defence of a landing site + defencePerLevel: 0.03, // + 3% per built Backbone node level (the node is a bigger target) + scanStrength: 40, // a landing site counts as this many scanners when scanned + maxLevel: 100, // = BUILDINGS.backbone_node.maxLevel + costGrowth: 1.045, // level L costs BUILDINGS.backbone_node.cost * costGrowth^(L-1) of each resource + timeGrowth: 1.025, // level L takes BUILDINGS.backbone_node.time * timeGrowth^(L-1) seconds at 1x + notifyEvery: 10, // alliance members hear about every n-th level (and the last one) + rankingTop: 100, // final snapshot: entries per list + }; + + return { UNITS, UNIT_ORDER, MILITARY, RESEARCH, EXPANSION, TRANSPORT, MOVE_ROLES, INCUMBENT, TRADE, ENDGAME, HOUR_MS, RESOURCES, FORMULAS, FIELD_SLOTS, FIELD_TYPES, FIELD_PRODUCES, FIELDS_PER_TYPE, WILD_SLOTS, SOCIAL, BUILDINGS, START, TILE, PROTECTION_HOURS, AS_RANGE, WORLD_DEFAULTS }; })); diff --git a/public/js/i18n.js b/public/js/i18n.js index c821489..79bca0a 100644 --- a/public/js/i18n.js +++ b/public/js/i18n.js @@ -372,5 +372,17 @@ // Fictional AS numbers come from the private 32-bit range; shown as "AS4200000123". const fmtAs = (n) => 'AS' + n; - return { LANGS, strings, t, fill, detectLang, fmtNum, fmtDec, fmtDuration, fmtClock, fmtAgo, fmtAs }; + // Screens added by later stages bring their own strings: public/js/strings/.js calls + // UpstreamI18n.extend({ en: {...}, nb: {...} }). Duplicate keys are an error (loud, not last-one-wins). + function extend(dicts) { + for (const l of LANGS) { + const d = dicts[l] || {}; + for (const k of Object.keys(d)) { + if (Object.prototype.hasOwnProperty.call(strings[l], k)) throw new Error('duplicate i18n key ' + k + ' (' + l + ')'); + strings[l][k] = d[k]; + } + } + } + + return { LANGS, strings, extend, t, fill, detectLang, fmtNum, fmtDec, fmtDuration, fmtClock, fmtAgo, fmtAs }; })); diff --git a/public/js/main.js b/public/js/main.js index 565cec0..bfac537 100644 --- a/public/js/main.js +++ b/public/js/main.js @@ -5,6 +5,7 @@ * * App.registerScreen({ * id: 'pop', titleKey: 'screen.pop', navKey: 'nav.pop', icon: 'pop', // nav: false hides it from the nav + * navGroup: 'main' | 'more', // bar button (default) or behind the "More" sheet * hud: true, // show the resource bar above it * render(container) {}, // once, when the screen is first shown: build the persistent DOM * onShow(params) {}, // every time it becomes visible @@ -13,6 +14,8 @@ * }); * * Later stages add screens (units, reports, ...) the same way: one file, one registerScreen call, one script tag. + * The bar holds 5 slots; with any 'more' screen the 5th is the More button (see "Bottom nav with overflow" below). + * App.setBadge(screenId, n, 'alert'|'info') puts a count on a screen's nav button (the More button sums its screens). * Everything time-based is computed from api.serverNow() (server clock), never from the device clock alone. */ (function () { @@ -94,32 +97,102 @@ const elApp = () => document.getElementById('app'); App.registerScreen = (def) => { App.screens.set(def.id, def); }; + App.alertKinds = {}; // notification type -> describer, see screens/alerts.js + App.popSections = []; // extra cards of the POP screen: { slot: 'top' | 'main', render(townData) -> Node | null } + + // Bottom nav with overflow. A screen picks where it lives with `navGroup`: + // 'main' (default) one of the primary screens in the bar (registration order) + // 'more' behind the "More" button, which opens a sheet listing these screens + // The bar holds NAV_SLOTS buttons. If any 'more' screen exists, or there are more 'main' screens than slots, the last slot + // becomes "More" and the surplus 'main' screens go into the sheet in front of the 'more' ones. Keep it to about 4 primary + // screens. Badges: App.setBadge(screenId, n, 'alert'|'info') shows a count on the screen's button; the More button + // shows the sum of its screens' badges (red if any of them is an alert). Add the screen's script tag and you are done. + const NAV_SLOTS = 5; + const badges = new Map(); // screen id -> { n, kind } + function navSplit() { + const all = Array.from(App.screens.values()).filter((d) => d.nav !== false); + const main = all.filter((d) => d.navGroup !== 'more'), more = all.filter((d) => d.navGroup === 'more'); + if (!more.length && main.length <= NAV_SLOTS) return { bar: main, over: [] }; + return { bar: main.slice(0, NAV_SLOTS - 1), over: main.slice(NAV_SLOTS - 1).concat(more) }; + } + + function navButton(def, onclick) { + const badge = h('span', { class: 'nav-badge', hidden: true, 'aria-hidden': 'true' }); + return h('button', { class: 'nav-btn', type: 'button', dataset: { screen: def.id }, onclick }, + h('span', { class: 'nav-ic' }, icon(def.icon), badge), h('span', { class: 'nav-lbl', text: App.t(def.navKey || def.titleKey) })); + } function buildNav() { const nav = elNav(); clear(nav); nav.setAttribute('aria-label', App.t('nav.label')); - for (const def of App.screens.values()) { - if (def.nav === false) continue; - const badge = h('span', { class: 'nav-badge', hidden: true, 'aria-hidden': 'true' }); - const btn = h('button', { class: 'nav-btn', type: 'button', dataset: { screen: def.id }, onclick: () => App.go(def.id) }, - h('span', { class: 'nav-ic' }, icon(def.icon), badge), h('span', { class: 'nav-lbl', text: App.t(def.navKey || def.titleKey) })); - if (App.current && App.current.id === def.id) btn.setAttribute('aria-current', 'page'); + const { bar, over } = navSplit(); + for (const def of bar) nav.appendChild(navButton(def, () => App.go(def.id))); + if (over.length) { + const btn = navButton({ id: 'more', icon: 'more', navKey: 'nav.more' }, () => openMore()); + btn.setAttribute('aria-haspopup', 'dialog'); nav.appendChild(btn); } - updateBadge(); + markCurrent(); + updateBadges(); } - function updateBadge() { - const n = App.state.unread; - const b = elNav().querySelector('[data-screen="alerts"] .nav-badge'); + function markCurrent() { + const id = App.current ? App.current.id : null; + const { over } = navSplit(); + const inMore = over.some((d) => d.id === id); + for (const b of elNav().children) { + const on = b.dataset.screen === id || (b.dataset.screen === 'more' && inMore); + if (on) b.setAttribute('aria-current', 'page'); else b.removeAttribute('aria-current'); + } + } + + function openMore() { + const { over } = navSplit(); + const list = h('div', { class: 'more-list' }); + const sheet = UI.openSheet({ title: App.t('nav.more'), icon: 'more', closeLabel: App.t('common.close'), body: list }); + for (const def of over) { + const bd = badges.get(def.id); + list.appendChild(h('button', { class: 'row-btn', type: 'button', onclick: () => { sheet.close(true); App.go(def.id); } }, + h('span', { class: 'row-ic' }, icon(def.icon)), + h('span', { class: 'row-main' }, h('span', { class: 'row-title' }, h('b', { text: App.t(def.navKey || def.titleKey) }))), + bd && bd.n ? h('span', { class: 'pill ' + (bd.kind === 'alert' ? 'amber' : 'accent'), text: String(bd.n) }) : null)); + } + } + + function paintBadge(btn, n, kind, label) { + const b = btn.querySelector('.nav-badge'); if (!b) return; b.hidden = !n; b.textContent = n > 9 ? '9+' : String(n); - const btn = b.closest('button'); - if (btn) btn.setAttribute('aria-label', App.t('nav.alerts') + (n ? ' (' + App.t('alerts.count', { n }) + ')' : '')); + b.classList.toggle('is-alert', kind === 'alert'); + const lbl = btn.querySelector('.nav-lbl'); + btn.setAttribute('aria-label', (lbl ? lbl.textContent : label || '') + (n ? ' (' + n + ')' : '')); } + function updateBadges() { + const { over } = navSplit(); + const overIds = new Set(over.map((d) => d.id)); + let sum = 0, kind = 'info'; + for (const [id, bd] of badges) { + if (overIds.has(id)) { sum += bd.n; if (bd.kind === 'alert' && bd.n) kind = 'alert'; } + } + for (const btn of elNav().children) { + const id = btn.dataset.screen; + if (id === 'more') paintBadge(btn, sum, kind); + else { const bd = badges.get(id); paintBadge(btn, bd ? bd.n : 0, bd ? bd.kind : 'info'); } + } + } + + App.setBadge = (id, n, kind) => { + const prev = badges.get(id); + n = Math.max(0, Math.floor(n) || 0); + if (prev && prev.n === n && prev.kind === (kind || 'info')) return; + badges.set(id, { n, kind: kind || 'info' }); + updateBadges(); + }; + const updateBadge = () => App.setBadge('alerts', App.state.unread, 'info'); // alerts feed unread count + function setTitle(def) { document.getElementById('title').textContent = def.id === 'auth' ? App.t('app.name') : App.t(def.titleKey); document.title = (def.id === 'auth' ? '' : App.t(def.titleKey) + ' · ') + 'UPSTREAM'; } // Navigate. Sets the hash (so back/forward work); hashchange does the actual switch. @@ -150,7 +223,7 @@ app.dataset.screen = def.id; app.dataset.state = App.state.user ? 'in' : 'out'; elNav().hidden = !App.state.user; - for (const b of elNav().children) { if (b.dataset.screen === def.id) b.setAttribute('aria-current', 'page'); else b.removeAttribute('aria-current'); } + markCurrent(); setTitle(def); renderHud(false); if (def.onShow) def.onShow(App.params); @@ -225,9 +298,16 @@ let rulesCache = null; // The rules.js town shape from the API response: same function the server settles with, so the numbers agree. App.rulesTown = () => { - const st = App.state, td = st.townData; - if (!td || !st.world) return null; + const td = App.state.townData; + if (!td || !App.state.world) return null; if (rulesCache && rulesCache.src === td) return rulesCache.town; + const town = App.rulesTownFrom(td, App.fetchedServerTime || 0); + rulesCache = { src: td, town }; + return town; + }; + // Same for any POP payload of GET /towns/:id fetched at server time `at` (the send dialog looks at other POPs too). + App.rulesTownFrom = (td, at) => { + const st = App.state; const buildings = {}; let bdraw = 0; for (const b of td.buildings) { @@ -237,11 +317,10 @@ if (def && def.kind === 'infra') bdraw += def.draw * b.level; } const town = { - id: td.id, speed: st.world.speed, updatedAt: App.fetchedServerTime || 0, + id: td.id, speed: st.world.speed, updatedAt: at, res: { fiber: td.resources.fiber.amount, hardware: td.resources.hardware.amount, capital: td.resources.capital.amount, battery: td.power.buffer }, footprint: td.footprint, buildings, unitDraw: Math.max(0, Math.round(td.power.draw - bdraw)), bonus: td.bonus || {}, }; - rulesCache = { src: td, town }; return town; }; @@ -262,6 +341,8 @@ // ------------------------------------------------------------------ resource bar const hudRefs = {}; + App.on('towns', () => renderHud(true)); // POP list changed (founded / conquered / lost / renamed) + App.on('townchange', () => renderHud(true)); // the switcher shows the selected POP function renderHud(rebuild) { const hud = document.getElementById('hud'); @@ -272,6 +353,12 @@ if (!want) return; if (!rebuild && hud.firstChild) return; clear(hud); + // POP switcher (only with more than one POP): every screen with the resource bar gets it + if (App.state.towns.length > 1) { + hud.appendChild(h('label', { class: 'hud-town' }, icon('pop'), + h('select', { 'aria-label': App.t('screen.pop'), onchange: (e) => App.setTown(Number(e.target.value)) }, + App.state.towns.map((x) => h('option', { value: x.id, selected: x.id === App.state.townId, text: x.name + (x.isCapital ? ' ★' : '') }))))); + } for (const r of D.RESOURCES.concat(['power'])) { const refs = { val: h('b', { class: 'val' }), cap: h('span', { class: 'cap' }), rate: h('span', { class: 'rate' }), fill: h('i'), diff --git a/public/js/milcore.js b/public/js/milcore.js new file mode 100644 index 0000000..f65f1ea --- /dev/null +++ b/public/js/milcore.js @@ -0,0 +1,121 @@ +'use strict'; +/* + * Pure helpers of the military / expansion screens (no DOM, no storage, no clock): what can be sent where, which units go + * on which movement, report perspective, reconnect backoff. Loads as a browser script (window.UpstreamMil) and as a Node + * module (test/client-mil.test.js). The SERVER decides everything; this only hides choices that can never work, so the + * sheet is short, and says why the rest is greyed out. + */ +(function (root, factory) { + if (typeof module === 'object' && module.exports) module.exports = factory(require('./data.js'), require('./rules.js')); + else root.UpstreamMil = factory(root.UpstreamData, root.UpstreamRules); +}(typeof self !== 'undefined' ? self : this, function (D, R) { + const TYPES = ['scan', 'raid', 'attack', 'takeover', 'reinforce', 'settle', 'transport']; + const HOSTILE = ['raid', 'attack', 'takeover']; + const ROLE_ICON = { scout: 'eye', defender: 'shield', attacker: 'target', siege: 'alert', settler: 'flag', conquest: 'handshake' }; + const TYPE_ICON = { scan: 'eye', raid: 'target', attack: 'target', takeover: 'handshake', reinforce: 'shield', settle: 'flag', transport: 'box', return: 'return', unknown: 'alert' }; + + // Units of `home` ({id: n}) that may go on a movement of `type`: [{ unit, have }] in display order. + function unitsForType(type, home) { + const roles = D.MOVE_ROLES[type]; + if (!roles) return []; + const out = []; + for (const unit of D.UNIT_ORDER) { + const def = D.UNITS[unit]; + const have = (home && home[unit]) || 0; + if (have > 0 && !def.fixed && roles.indexOf(def.role) >= 0) out.push({ unit, have }); + } + return out; + } + + /* + * What can be sent to a tile. c = { + * tile: GET /map/tile response, + * home: units at the sending POP, transport: { links, active } of the sending POP, + * allianceId: my alliance id or null, crews: number of rollout crews at home + * } -> [{ type, ok, reason }] (reason is a code the sheet turns into text; null when ok) + * Hidden (not even greyed): types that make no sense for this kind of tile. Pact rules (NAP, confederation) are not + * known to the client: the server refuses those and the sheet shows its message. + */ + function moveOptions(c) { + const t = c.tile, home = c.home || {}; + const out = []; + if (!t) return out; + const has = (type) => unitsForType(type, home).length > 0; + const add = (type, ok, reason) => out.push({ type, ok: !!ok, reason: ok ? null : reason }); + if (t.town) { + if (t.town.mine) { + add('reinforce', has('reinforce'), 'no_units'); + const links = (c.transport && c.transport.links) || 0, active = (c.transport && c.transport.active) || 0; + add('transport', links > active, links === 0 ? 'no_link' : 'links_busy'); + } else { + add('scan', has('scan'), 'no_units'); + const prot = !!(t.town.owner && t.town.owner.protected); + for (const type of HOSTILE) { + let ok = !prot && has(type), reason = prot ? 'target_protected' : 'no_units'; + if (ok && type === 'takeover' && !(home[D.EXPANSION.conquestUnit] > 0)) { ok = false; reason = 'needs_ma_team'; } + add(type, ok, reason); + } + if (c.allianceId && t.town.owner && t.town.owner.allianceId === c.allianceId) add('reinforce', has('reinforce'), 'no_units'); + } + } else if (t.type === 'incumbent') { + add('scan', has('scan'), 'no_units'); + add('attack', has('attack'), 'no_units'); + } else if (t.type === 'land') { + const s = t.settle || {}; + if (!s.possible) add('settle', false, 'settle:' + (s.code || 'invalid_target')); + else add('settle', (c.crews || 0) >= D.EXPANSION.crews, 'needs_crews'); + } + return out; + } + + // Default selection when a type is picked: settle takes exactly the crews, everything else starts empty. + function defaultUnits(type, home) { + if (type === 'settle') { const o = {}; o[D.EXPANSION.settleUnit] = D.EXPANSION.crews; return o; } + return {}; + } + + // Drop zero entries and clamp to what is at home. + function cleanSelection(sel, home) { + const out = {}; + for (const k of Object.keys(sel || {})) { + const n = Math.max(0, Math.min(Math.floor(sel[k] || 0), (home && home[k]) || 0)); + if (n > 0) out[k] = n; + } + return out; + } + + // Preview of a movement: distance, latency (ms), carry capacity, slowest unit. + function preview(type, from, to, units, cargo, worldSpeed) { + const dist = R.distance(from.x, from.y, to.x, to.y); + const ms = type === 'transport' ? R.transportMs(dist, worldSpeed) : R.movementMs(dist, units, worldSpeed); + const s = R.slowestSpeed(units); + return { dist, ms, carry: R.carryOf(units), slowest: isFinite(s) ? s : null }; + } + + const isHostile = (type) => HOSTILE.indexOf(type) >= 0; + + // Report perspective: did *I* win? role is the recipient role of the report. + function perspective(role, outcome) { + const attackerSide = role === 'attacker'; + const attackerWon = outcome === 'attacker_won'; + return attackerSide === attackerWon ? 'victory' : 'defeat'; + } + + // When units that went offline are decommissioned (ms, server clock). + const decommissionAt = (offlineSince, speed) => offlineSince + R.decommissionMs(speed); + + // Reconnect delay for the WebSocket: exponential from 1 s, capped at 60 s, +-25% jitter (rnd in [0,1)). + function backoffMs(attempt, rnd) { + const base = Math.min(60000, 1000 * Math.pow(2, Math.min(attempt, 10))); + return Math.round(base * (0.75 + 0.5 * (rnd === undefined ? Math.random() : rnd))); + } + + const sumUnits = (u) => Object.keys(u || {}).reduce((s, k) => s + (u[k] || 0), 0); + + // Exploit-kit target choices: infrastructure types (the server also takes f1..f18 slots; the client does not know them). + function siegeTargets() { + return Object.keys(D.BUILDINGS).filter((k) => D.BUILDINGS[k].kind === 'infra' && !D.BUILDINGS[k].special); + } + + return { TYPES, HOSTILE, ROLE_ICON, TYPE_ICON, unitsForType, moveOptions, defaultUnits, cleanSelection, preview, isHostile, perspective, decommissionAt, backoffMs, sumUnits, siegeTargets }; +})); diff --git a/public/js/milstate.js b/public/js/milstate.js new file mode 100644 index 0000000..e026021 --- /dev/null +++ b/public/js/milstate.js @@ -0,0 +1,167 @@ +'use strict'; +/* + * Shared state and small view helpers of the military / expansion screens (browser only; loads after main.js). + * + * App.mil.moves { outgoing, incoming, at }: the last GET /movements, the single source for the nav badge, + * the POP banner, the movements screen and the map lines. Emits App.emit('movements'). + * App.refreshMovements() refetch it (coalesced). Called by the ticker when something arrived, by push, by the poll. + * App.refreshReportsUnread() refetch the unread count of reports (nav badge on Reports). + * App.refreshTowns() refetch /me and update the POP list WITHOUT resetting the session (after a settle/takeover). + * App.mil.* helpers unitName, unitsText, typeLabel, coordLink, countdown, chips ... + * + * Countdowns are elements with data-cd = server-clock deadline in ms; one ticker keeps all of them current, so screens + * only create them (mil.countdown) and never run their own timers for display. + */ +(function () { + const { h, icon } = UI; + const D = UpstreamData; + const Mil = UpstreamMil; + const api = App.api; + + const mil = App.mil = { moves: { outgoing: [], incoming: [], alliedIncoming: [], at: 0, loaded: false }, reportsUnread: 0 }; + + // ------------------------------------------------------------------ names and small pieces + mil.unitName = (id) => (UpstreamI18n.strings.en['unit.' + id + '.name'] ? App.t('unit.' + id + '.name') : id); + mil.unitDesc = (id) => (UpstreamI18n.strings.en['unit.' + id + '.desc'] ? App.t('unit.' + id + '.desc') : ''); + mil.typeLabel = (type) => (UpstreamI18n.strings.en['move.type.' + type] ? App.t('move.type.' + type) : type); + mil.reportTypeLabel = (type) => (UpstreamI18n.strings.en['report.type.' + type] ? App.t('report.type.' + type) : type); + mil.unitIcon = (id) => icon(Mil.ROLE_ICON[(D.UNITS[id] || {}).role] || 'units'); + mil.townName = (id) => { const t = App.state.towns.find((x) => x.id === id); return t ? t.name : null; }; + mil.ownTown = (id) => App.state.towns.find((x) => x.id === id) || null; + + // "3 × Script crew, 2 × Botnet" + mil.unitsText = (units) => { + const parts = []; + for (const u of D.UNIT_ORDER) if (units && units[u] > 0) parts.push(App.fmt.num(units[u]) + ' × ' + mil.unitName(u)); + return parts.length ? parts.join(', ') : '—'; + }; + + // Clock time (local) at server time `ms`. + mil.clockTime = (ms) => { + try { return new Date(ms).toLocaleTimeString(App.state.lang === 'nb' ? 'nb-NO' : 'en-GB', { hour: '2-digit', minute: '2-digit' }); } catch (e) { return ''; } + }; + mil.dayTime = (ms) => { + try { return new Date(ms).toLocaleString(App.state.lang === 'nb' ? 'nb-NO' : 'en-GB', { day: 'numeric', month: 'short', hour: '2-digit', minute: '2-digit' }); } catch (e) { return ''; } + }; + + // A link that jumps to the map at (x, y). Closes any sheet first. + mil.coordLink = (x, y, label) => h('button', { class: 'mil-coord mono', type: 'button', 'aria-label': App.t('mil.showOnMap', { x, y }), onclick: () => { UI.closeSheet(); App.go('map', { x, y, zoom: 40 }); } }, + icon('map'), label || (x + ', ' + y)); + + // A movement endpoint ({ townId, x, y, name, owner? }) as text + coordinates link. + mil.endLink = (end) => h('span', { class: 'mil-end' }, end.name ? h('span', { class: 'mil-end-name', text: end.name }) : null, mil.coordLink(end.x, end.y)); + + // Resource chips: { fiber, hardware, capital } (zero entries are skipped). + mil.resChips = (res, signed) => { + const out = []; + for (const r of D.RESOURCES) if (res && res[r]) out.push(h('span', { class: 'cost ' + r }, icon(r), h('b', { text: (signed ? '+' : '') + App.fmt.num(res[r]) }))); + return h('div', { class: 'costs' }, out.length ? out : h('span', { class: 'dimmer', text: '—' })); + }; + + // m:ss, kept current by the ticker below. + mil.countdown = (deadline, opts) => { + const el = h('b', { class: 'mono mil-cd' + (opts && opts.cls ? ' ' + opts.cls : ''), dataset: { cd: String(deadline) } }); + el.textContent = App.fmt.clock(deadline - App.now()); + return el; + }; + + // Progress 0..1 of a movement. + mil.progress = (m, now) => Math.max(0, Math.min(1, (now - m.departAt) / Math.max(1, m.arriveAt - m.departAt))); + + // ------------------------------------------------------------------ the ticker: countdowns + "something arrived" refetch + let lastMovesFetch = 0; + App.onTick((now) => { + for (const el of document.querySelectorAll('[data-cd]')) { + const s = App.fmt.clock(Number(el.dataset.cd) - now); + if (el.textContent !== s) el.textContent = s; + } + if (!App.state.user || !mil.moves.loaded) return; + // a movement is over (arrived / returned): the server dropped it, so refetch (retry no more often than every 3 s) + const due = mil.moves.outgoing.concat(mil.moves.incoming, mil.moves.alliedIncoming || []).some((m) => m.arriveAt - now < -600); + if (due && Date.now() - lastMovesFetch > 3000) { lastMovesFetch = Date.now(); App.refreshMovements().catch(() => {}); } + }); + + // ------------------------------------------------------------------ refetchers + let movesFlight = null; + App.refreshMovements = () => { + if (!App.state.user) return Promise.resolve(null); + if (movesFlight) return movesFlight; + lastMovesFetch = Date.now(); + movesFlight = api.get('/movements').then((r) => { + // a settle that is no longer on the wire has resolved: the POP list changed (the push-less path to the same refresh) + const settled = mil.moves.loaded && mil.moves.outgoing.some((m) => m.type === 'settle' && !(r.outgoing || []).some((n) => n.id === m.id)); + if (settled) App.refreshTowns().catch(() => {}); + mil.moves = { outgoing: r.outgoing || [], incoming: r.incoming || [], alliedIncoming: r.alliedIncoming || [], at: r.serverTime, loaded: true }; + App.setBadge('movements', mil.moves.incoming.length, 'alert'); + App.emit('movements', mil.moves); + return mil.moves; + }).finally(() => { movesFlight = null; }); + return movesFlight; + }; + + let reportsFlight = null; + App.refreshReportsUnread = () => { + if (!App.state.user) return Promise.resolve(null); + if (reportsFlight) return reportsFlight; + reportsFlight = api.get('/reports', { limit: 1 }).then((r) => { + mil.reportsUnread = r.unread || 0; + App.setBadge('reports', mil.reportsUnread, 'info'); + App.emit('reportsUnread', mil.reportsUnread); + return mil.reportsUnread; + }).finally(() => { reportsFlight = null; }); + return reportsFlight; + }; + + // The POP list changed (founded, conquered, lost): refresh /me without the destructive parts of setSession. + let townsFlight = null; + const townSig = (list) => list.map((t) => t.id + ':' + t.name + ':' + (t.isCapital ? 1 : 0)).join('|'); + App.refreshTowns = () => { + const st = App.state; + if (!st.user) return Promise.resolve(); + if (townsFlight) return townsFlight; + townsFlight = (async () => { + const me = await api.get('/me'); + const op = (me.operators || [])[0] || null; + if (!op) return; + const before = townSig(st.towns); + st.operators = me.operators; st.operator = op; st.world = op.world; st.towns = op.towns; + let gone = false; + if (!st.towns.some((t) => t.id === st.townId)) { + const pick = st.towns.find((t) => t.isCapital) || st.towns[0] || null; + st.townId = pick ? pick.id : null; st.townData = null; gone = true; + } + // only a real change rebuilds the screens (a redraw resets the scroll position, and this runs on every poll) + if (gone) { App.emit('townchange', st.townId); if (st.townId) App.refreshTown().catch(() => {}); } + if (gone || townSig(st.towns) !== before) App.emit('towns', st.towns); + })().finally(() => { townsFlight = null; }); + return townsFlight; + }; + + // Another of the player's POPs (GET /towns/:id), for the send dialog. -> { town, serverTime } + mil.loadTown = (id) => api.get('/towns/' + id); + + App.on('session', (st) => { + if (st && st.user) { App.refreshMovements().catch(() => {}); App.refreshReportsUnread().catch(() => {}); return; } + mil.moves = { outgoing: [], incoming: [], alliedIncoming: [], at: 0, loaded: false }; + mil.reportsUnread = 0; + App.setBadge('movements', 0, 'alert'); App.setBadge('reports', 0, 'info'); + }); + + // ------------------------------------------------------------------ the notification feed (screens/alerts.js) learns our types + const kinds = App.alertKinds; + const townTxt = (id) => mil.townName(id) || '#' + id; + kinds.incoming = (n, p) => ({ icon: 'alert', title: App.t('alerts.incoming'), detail: App.t('alerts.incoming.at', { town: townTxt(p.toTownId), time: mil.clockTime(p.arriveAt) }), go: 'movements' }); + kinds.report = (n, p) => ({ icon: 'report', title: App.t('alerts.report', { type: mil.reportTypeLabel(p.type) }), detail: '', go: 'reports', params: { open: p.reportId } }); + kinds.train_done = (n, p) => ({ icon: 'units', title: App.t('alerts.train_done', { n: App.fmt.num(p.count), unit: mil.unitName(p.unit) }), detail: App.t('alerts.build_done.in', { town: townTxt(p.townId) }), go: 'units' }); + kinds.research_done = (n, p) => ({ icon: 'flask', title: App.t('alerts.research_done', { unit: mil.unitName(p.unit), stat: App.t('stat.' + p.stat), level: p.level }), detail: App.t('alerts.build_done.in', { town: townTxt(p.townId) }), go: 'units' }); + kinds.movement_returned = (n, p) => ({ icon: 'return', title: App.t('alerts.movement_returned'), detail: [mil.unitsText(p.units)].concat(D.RESOURCES.some((r) => p.cargo && p.cargo[r]) ? [Object.keys(p.cargo).filter((r) => p.cargo[r]).map((r) => App.fmt.num(p.cargo[r]) + ' ' + App.resName(r)).join(', ')] : []).join(' · '), go: 'movements' }); + kinds.movement_lost = () => ({ icon: 'alert', title: App.t('alerts.movement_lost'), detail: '', go: 'movements' }); + kinds.transport_arrived = (n, p) => ({ icon: 'box', title: App.t('alerts.transport_arrived', { town: townTxt(p.townId) }), detail: Object.keys(p.cargo || {}).filter((r) => p.cargo[r]).map((r) => App.fmt.num(p.cargo[r]) + ' ' + App.resName(r)).join(', '), go: 'movements' }); + kinds.transport_delivered = (n, p) => ({ icon: 'box', title: App.t('alerts.transport_delivered'), detail: Object.keys(p.cargo || {}).filter((r) => p.cargo[r]).map((r) => App.fmt.num(p.cargo[r]) + ' ' + App.resName(r)).join(', '), go: 'movements' }); + kinds.units_offline = (n, p) => ({ icon: 'power', title: App.t('alerts.units_offline'), detail: App.t('alerts.build_done.in', { town: townTxt(p.townId) }), go: 'units' }); + kinds.units_decommissioned = (n, p) => ({ icon: 'power', title: App.t('alerts.units_decommissioned'), detail: mil.unitsText(p.units), go: 'units' }); + kinds.town_lost = (n, p) => ({ icon: 'alert', title: App.t('alerts.town_lost', { name: p.name }), detail: p.by ? App.t('alerts.town_lost.by', { name: p.by.name }) : '', go: 'pop' }); + kinds.town_gained = (n, p) => ({ icon: 'pop', title: App.t('alerts.town_gained', { name: p.name }), detail: '', go: 'pop' }); + kinds.reinforcements_sent_home = (n, p) => ({ icon: 'return', title: App.t('alerts.reinforcements_home'), detail: mil.unitsText(p.units), go: 'units' }); + +}()); diff --git a/public/js/render.js b/public/js/render.js index 8b28cfc..3960dfc 100644 --- a/public/js/render.js +++ b/public/js/render.js @@ -6,6 +6,8 @@ * source.forEachSpecial(x0, y0, x1, y1, fn(special)) rural + incumbent tiles in the rect * source.townsInRect(x0, y0, x1, y1) -> [town] POPs in the rect * source.isOwn(town) -> bool + * source.movements() -> [{ from: {x,y}, to: {x,y}, kind: 'out' | 'in' | 'ret' | 'ally', p: 0..1 }] optional: lines with a marker at progress p + * source.threatened(town) -> bool optional: an incoming movement is heading for this own POP (red ring) * onTap(x, y) a finger lift / click that was not a drag or a pinch (act on lift) * onMoveEnd(view) debounced after the camera stopped; view = { x0, y0, x1, y1, cx, cy, zoom } * @@ -292,6 +294,7 @@ } ctx.restore(); } + if (this.src.movements) this._movements(this.src.movements()); for (const t of towns) this._pop(t); // world border @@ -365,6 +368,10 @@ ctx.beginPath(); ctx.arc(s.x, s.y, Math.max(1.5, rad * (t.isCapital ? 0.38 : 0.22)), 0, Math.PI * 2); ctx.fill(); if (t.isCapital) { ctx.strokeStyle = col.stroke; ctx.lineWidth = 1; this._hex(s.x, s.y, rad * 0.68); ctx.stroke(); } } + if (own && this.src.threatened && this.src.threatened(t)) { + ctx.strokeStyle = '#ff6b87'; ctx.lineWidth = Math.max(2, z * 0.08); + this._hex(s.x, s.y, rad + Math.max(4, z * 0.2)); ctx.stroke(); + } if (z >= 18 && t.owner.protected) { ctx.strokeStyle = COLORS.select; ctx.lineWidth = Math.max(1, z * 0.05); ctx.setLineDash([3, 3]); this._hex(s.x, s.y, rad + z * 0.12); ctx.stroke(); ctx.setLineDash([]); @@ -380,6 +387,35 @@ } } + // Movement lines: dashed, cyan outgoing, red incoming, dim return legs, green allied traffic; a marker sits at progress p. + _movements(list) { + const { ctx, zoom: z } = this; + const col = { out: COLORS.own, in: '#ff6b87', ret: 'rgba(155,178,214,0.8)', ally: '#35e0a1' }; + ctx.save(); + ctx.lineCap = 'round'; + for (const m of list) { + const a = this.toScreen(m.from.x, m.from.y), b = this.toScreen(m.to.x, m.to.y); + if (Math.max(a.x, b.x) < -20 || Math.min(a.x, b.x) > this.w + 20 || Math.max(a.y, b.y) < -20 || Math.min(a.y, b.y) > this.h + 20) continue; + const c = col[m.kind] || COLORS.own; + ctx.strokeStyle = c; ctx.fillStyle = c; + ctx.globalAlpha = m.kind === 'ret' ? 0.55 : 0.85; + ctx.lineWidth = m.kind === 'in' ? 2.4 : 1.6; + ctx.setLineDash(m.kind === 'in' ? [3, 5] : [7, 6]); + ctx.beginPath(); ctx.moveTo(a.x, a.y); ctx.lineTo(b.x, b.y); ctx.stroke(); + ctx.setLineDash([]); + const p = Math.max(0, Math.min(1, m.p)); + const px = a.x + (b.x - a.x) * p, py = a.y + (b.y - a.y) * p; + const ang = Math.atan2(b.y - a.y, b.x - a.x), r = Math.max(4, Math.min(8, z * 0.3)); + ctx.globalAlpha = 1; + ctx.beginPath(); + ctx.moveTo(px + Math.cos(ang) * r, py + Math.sin(ang) * r); + ctx.lineTo(px + Math.cos(ang + 2.5) * r, py + Math.sin(ang + 2.5) * r); + ctx.lineTo(px + Math.cos(ang - 2.5) * r, py + Math.sin(ang - 2.5) * r); + ctx.closePath(); ctx.fill(); + } + ctx.restore(); + } + _selection(sel) { const { ctx, zoom: z } = this; const s = this.toScreen(sel.x, sel.y); diff --git a/public/js/rules.js b/public/js/rules.js index b09bc74..75e55c2 100644 --- a/public/js/rules.js +++ b/public/js/rules.js @@ -52,7 +52,19 @@ // ------------------------------------------------------------------ the map // Pure function of the world seed: 'land' | 'rural' | 'incumbent' | 'void' (outside the map). A rural tile also // says which resource it boosts. Towns are not part of this; they live in the database. - function tileAt(seed, radius, x, y) { + // `ageDays` (optional, world days) adds the end game: from D.ENDGAME.openDay on, the landing sites report 'backbone' + // (with `site`: its index). Without it (old callers, previews without a clock) the map is the plain terrain. + // Terrain never changes: a landing site is always a land tile underneath, see backboneSites. + function tileAt(seed, radius, x, y, ageDays) { + const t = terrainAt(seed, radius, x, y); + if (t.type === 'land' && ageDays !== undefined && ageDays >= D.ENDGAME.openDay) { + const s = backboneSiteAt(seed, radius, x, y); + if (s) return { type: 'backbone', site: s.index }; + } + return t; + } + + function terrainAt(seed, radius, x, y) { if (Math.abs(x) > radius || Math.abs(y) > radius) return { type: 'void' }; if (Math.abs(x) <= 2 && Math.abs(y) <= 2) return { type: 'land' }; // keep the centre free const h = hash(seed, x, y) / 4294967296; @@ -64,6 +76,54 @@ return { type: 'land' }; } + // The backbone landing sites: D.ENDGAME.sites fixed positions, a pure function of (seed, radius). One per sector of the + // circle (jittered), on plain land tiles between siteRingMin and siteRingMax of the radius, never in the free centre and + // at least siteMinSpacing apart. They exist from the start (spawn and settling refuse them) but only SHOW from openDay. + // -> [{ index, x, y }] + const siteCache = new Map(); + function backboneSites(seed, radius) { + const key = seed + '|' + radius; + if (siteCache.has(key)) return siteCache.get(key); + const E = D.ENDGAME; + const out = []; + for (let k = 0; k < E.sites; k++) { + const rand = rng(hash(seed, k, 0xb4cb)); + const ang = (k + 0.15 + 0.7 * rand()) * 2 * Math.PI / E.sites; + const rr = radius * (E.siteRingMin + (E.siteRingMax - E.siteRingMin) * rand()); + const cx = Math.round(Math.cos(ang) * rr), cy = Math.round(Math.sin(ang) * rr); + let found = null; + for (let d = 0; d <= radius && !found; d++) { // spiral outwards until a free land tile turns up + for (let dy = -d; dy <= d && !found; dy++) { + for (let dx = -d; dx <= d && !found; dx++) { + if (Math.max(Math.abs(dx), Math.abs(dy)) !== d) continue; + const x = cx + dx, y = cy + dy; + if (terrainAt(seed, radius, x, y).type !== 'land') continue; + if (Math.abs(x) <= 2 && Math.abs(y) <= 2) continue; + if (out.some((s) => distance(s.x, s.y, x, y) < E.siteMinSpacing)) continue; + found = { index: k, x, y }; + } + } + } + if (found) out.push(found); + } + if (siteCache.size > 64) siteCache.clear(); + siteCache.set(key, out); + return out; + } + function backboneSiteAt(seed, radius, x, y) { + for (const s of backboneSites(seed, radius)) if (s.x === x && s.y === y) return s; + return null; + } + const isBackboneSite = (seed, radius, x, y) => !!backboneSiteAt(seed, radius, x, y); + + // World age in world days (real days * speed). Negative ages are 0. + function worldAgeDays(startAt, now, speed) { return Math.max(0, (now - startAt) / DAY * (speed || 1)); } + // 'running' | 'backbone_open' | 'ended'. + function worldPhase(status, ageDays) { + if (status === 'ended') return 'ended'; + return ageDays >= D.ENDGAME.openDay ? 'backbone_open' : 'running'; + } + // Rural areas within reach of (x, y): the tiles whose bonus a POP there enjoys. Biggest bonus counts max 3. function ruralNear(seed, radius, x, y) { const out = []; @@ -101,7 +161,7 @@ const ang = rand() * Math.PI * 2; const rr = lo + rand() * (hi - lo); const x = Math.round(Math.cos(ang) * rr), y = Math.round(Math.sin(ang) * rr); - if (tileAt(seed, radius, x, y).type !== 'land') continue; + if (tileAt(seed, radius, x, y).type !== 'land' || isBackboneSite(seed, radius, x, y)) continue; if (near(x, y)) continue; return { x, y }; } @@ -577,6 +637,7 @@ // Founding a POP: info about the target tile and the operator. Codes: invalid_target, out_of_range, footprint_too_low. function settleCheck(o) { + if (o.backbone) return { ok: false, code: 'invalid_target', reason: 'backbone_site' }; // landing sites are taken, never settled if (o.tileType !== 'land' || o.occupied) return { ok: false, code: 'invalid_target', reason: o.occupied ? 'occupied' : 'not_empty_land' }; if (!(o.nearestOwnDist <= D.EXPANSION.maxDistance)) return { ok: false, code: 'out_of_range', max: D.EXPANSION.maxDistance, have: o.nearestOwnDist }; const g = footprintGate(o.ownedCount, o.footprint); @@ -654,8 +715,62 @@ return { ok: true, total }; } + // ---- trade (Internet exchange offers: give X of A for Y of B, max distance Z) + // How far (tiles) a POP with this Internet exchange level sees and trades. Level 0 = no exchange = 0. + const tradeReach = (level) => (level > 0 ? level * D.TRADE.reachPerLevel : 0); + // Is the exchange rate within the 1:ratioMax band (give/want in [1/ratioMax, ratioMax])? + const tradeRatioOk = (give, want) => give > 0 && want > 0 && give <= want * D.TRADE.ratioMax && want <= give * D.TRADE.ratioMax; + // Validate the terms of a new offer. `o` = { giveRes, giveAmount, wantRes, wantAmount, maxDistance }. Codes: validation_failed, + // trade_ratio, capacity_exceeded. Does not look at the town (resources, links) - the command does. + function tradeTermsCheck(o) { + const bad = (path, message) => ({ ok: false, code: 'validation_failed', errors: [{ path, message }] }); + if (D.RESOURCES.indexOf(o.giveRes) < 0) return bad('giveRes', 'must be one of ' + D.RESOURCES.join(', ')); + if (D.RESOURCES.indexOf(o.wantRes) < 0) return bad('wantRes', 'must be one of ' + D.RESOURCES.join(', ')); + if (o.giveRes === o.wantRes) return bad('wantRes', 'must differ from giveRes'); + if (!Number.isInteger(o.giveAmount) || o.giveAmount < 1) return bad('giveAmount', 'must be a whole number >= 1'); + if (!Number.isInteger(o.wantAmount) || o.wantAmount < 1) return bad('wantAmount', 'must be a whole number >= 1'); + if (!Number.isInteger(o.maxDistance) || o.maxDistance < 1 || o.maxDistance > D.TRADE.maxDistance) return bad('maxDistance', 'must be a whole number of tiles 1..' + D.TRADE.maxDistance); + const cap = D.TRANSPORT.capacityPerLink; + if (o.giveAmount > cap || o.wantAmount > cap) return { ok: false, code: 'capacity_exceeded', capacity: cap }; + if (!tradeRatioOk(o.giveAmount, o.wantAmount)) return { ok: false, code: 'trade_ratio', max: D.TRADE.ratioMax }; + return { ok: true }; + } + // May a POP at `dist` tiles with Internet exchange `level` take an offer (max distance `maxDistance`)? Both the offer's own + // limit and the taker's reach apply. + const tradeInRange = (dist, maxDistance, level) => level >= 1 && dist <= maxDistance && dist <= tradeReach(level); + + // ---- end game: backbone landing sites + // Heavy static defence of a landing site: the incumbent's site defence x defenceMult, plus defencePerLevel per node level. + function backboneDefence(seed, x, y, ageDays, level) { + return Math.round(incumbentDefence(seed, x, y, ageDays) * D.ENDGAME.defenceMult * (1 + D.ENDGAME.defencePerLevel * Math.max(0, level || 0))); + } + // Cost to build the Backbone node UP TO `level` (1..maxLevel), per resource. + function backboneCost(level) { + const def = D.BUILDINGS.backbone_node; + const out = {}; + for (const r of D.RESOURCES) out[r] = Math.round(def.cost[r] * Math.pow(D.ENDGAME.costGrowth, level - 1)); + return out; + } + function backboneTimeMs(level, speed) { + return Math.max(F.minBuildMs, Math.round(D.BUILDINGS.backbone_node.time * Math.pow(D.ENDGAME.timeGrowth, level - 1) / (speed || 1) * 1000)); + } + // Can the holder alliance start the next level? site = { level, build (null | { to }), pool: { fiber, hardware, capital } }. Codes: max_level, already_queued, not_enough_resources. + function backbonePlan(site, speed) { + const toLevel = site.level + 1; + const base = { ok: false, fromLevel: site.level, toLevel }; + if (toLevel > D.ENDGAME.maxLevel) return Object.assign(base, { code: 'max_level' }); + base.cost = backboneCost(toLevel); + base.durationMs = backboneTimeMs(toLevel, speed); + if (site.build) return Object.assign(base, { code: 'already_queued' }); + for (const r of D.RESOURCES) if ((site.pool[r] || 0) + 1e-6 < base.cost[r]) return Object.assign(base, { code: 'not_enough_resources' }); + base.ok = true; + return base; + } + return { unitDef, unitCount, costValue, unitValue, researchKey, researchLevel, researchMult, unitStat, unitCost, trainTimeMs, unitMissing, trainPlan, researchCost, researchTimeMs, researchSpeedBonus, researchPlan, slowestSpeed, movementMs, transportMs, checkUnitsForType, isProtected, firewallMult, effectiveFirewall, attackPower, defencePower, applyLoss, resolveBattle, battlePoints, cacheFraction, lootSplit, carryOf, siegeLevels, loyaltyDrop, takeoverBlock, footprintGate, settleCheck, cleanWild, newTownBuildings, scanStrength, resolveScan, incumbentDefence, decommissionMs, decommissionPlan, transportLinks, transportPlan, rng, hash, distance, tileAt, ruralNear, ruralBonus, pickSpawn, + terrainAt, backboneSites, backboneSiteAt, isBackboneSite, worldAgeDays, worldPhase, tradeReach, tradeRatioOk, tradeTermsCheck, tradeInRange, + backboneDefence, backboneCost, backboneTimeMs, backbonePlan, buildingDef, isFieldKey, fieldLayout, buildingCost, coreLevel, buildTimeMs, queueSlots, storageCap, batteryCap, fieldOutputPerHour, ratesPerHour, resourcesAt, batteryEmptyAt, unitsOnline, footprintPerDay, footprintAt, allianceCap, allianceCan, roleRank, outranks, diplomacyMove, pactCancelMs, diff --git a/public/js/screens/alerts.js b/public/js/screens/alerts.js index 2e3dff8..b8f5171 100644 --- a/public/js/screens/alerts.js +++ b/public/js/screens/alerts.js @@ -17,6 +17,9 @@ if (n.type === 'build_done') { return { icon: 'b-' + p.type, title: App.t('alerts.build_done', { name: App.buildingName(p.type), level: p.level }), detail: App.t('alerts.build_done.in', { town: townName(p.townId) }), go: 'pop' }; } + // Other screens describe their own notification types: App.alertKinds[type] = (n, p) => ({ icon, title, detail, go, params }) + const ext = App.alertKinds && App.alertKinds[n.type]; + if (ext) return ext(n, p); return { icon: 'bell', title: App.t('alerts.unknown', { type: n.type }), detail: '', go: null }; } @@ -28,7 +31,7 @@ const d = describe(n); const isNew = n.id > seenAtOpen; listEl.appendChild(h('li', null, - h('button', { class: 'alert' + (isNew ? ' new' : ''), type: 'button', onclick: () => { if (d.go) App.go(d.go); } }, + h('button', { class: 'alert' + (isNew ? ' new' : ''), type: 'button', onclick: () => { if (d.go) App.go(d.go, d.params); } }, h('span', { class: 'row-ic' }, icon(d.icon)), h('span', { class: 'row-main' }, h('span', { class: 'row-title' }, h('b', { text: d.title }), isNew ? h('span', { class: 'pill accent', text: App.t('alerts.new') }) : null), d.detail ? h('span', { class: 'row-sub', text: d.detail }) : null), @@ -57,7 +60,7 @@ } App.registerScreen({ - id: 'alerts', titleKey: 'screen.alerts', navKey: 'nav.alerts', icon: 'bell', hud: false, + id: 'alerts', titleKey: 'screen.alerts', navKey: 'nav.alerts', icon: 'bell', hud: false, navGroup: 'more', render(container) { box = container; listEl = h('ul', { class: 'alert-list' }); diff --git a/public/js/screens/alliance.js b/public/js/screens/alliance.js new file mode 100644 index 0000000..2557a7f --- /dev/null +++ b/public/js/screens/alliance.js @@ -0,0 +1,542 @@ +'use strict'; +/* + * Alliance screen. Not in an alliance: found one (Peering office needed) and answer invitations. In one: overview with pinned + * notes, members (role changes, kick, transfer, invite), diplomacy. What is offered follows data.js SOCIAL.permissions through + * rules.js allianceCan/outranks (via UpstreamSocial); the server re-checks everything and its error codes are translated. + * Every player-controlled string is set with textContent. + */ +(function () { + const { h, clear, icon, toast, openSheet } = UI; + const Soc = UpstreamSocial; + const R = UpstreamRules; + const D = UpstreamData; + const S = D.SOCIAL; + const X = () => window.SocUI; + + let box, body, tabsEl, content; + let mine = null; // GET /alliances/mine + let members = null; // GET /alliances/:id/members items + let tab = 'overview'; + let gen = 0; // bumped on every load: stale async results are dropped + let offTick = null; + const cache = {}; // per-tab data + + const myRole = () => (mine ? mine.role : null); + const acts = () => Soc.selfActions(myRole(), members ? members.length : (mine && mine.alliance ? mine.alliance.memberCount : 0)); + const kv = (k, v) => h('div', { class: 'kv' }, h('span', { class: 'k', text: k }), h('span', { class: 'v' }, v)); + + // ------------------------------------------------------------------ load + async function load() { + const my = ++gen; + const had = !!mine; + if (!had) { clear(body); body.appendChild(X().loading()); } + try { + const m = await App.api.get('/alliances/mine'); + if (my !== gen) return; + mine = m; + const al = m.alliance; + const cur = X().myAlliance(); + if ((al && (!cur || cur.id !== al.id)) || (!al && cur)) X().refreshOperator().catch(() => {}); + if (al) { + const r = await App.api.get('/alliances/' + al.id + '/members'); + if (my !== gen) return; + members = r.items; + for (const k of Object.keys(cache)) delete cache[k]; + drawIn(); + } else { + members = null; + const inv = await App.api.get('/alliance-invites'); + if (my !== gen) return; + cache.invites = inv.items; + drawNone(); + } + } catch (e) { + if (my !== gen) return; + clear(body); + body.appendChild(X().errorBox(e, load)); + } + } + + // Reload after a change of membership (found, join, leave, kick...). + function reload() { mine = null; members = null; tab = 'overview'; return load(); } + + // ------------------------------------------------------------------ not in an alliance + function drawNone() { + clear(body); + stopTick(); + const have = mine.peeringLevel, need = S.minPeeringLevel, ok = have >= need; + const err = h('p', { class: 'form-error', role: 'alert', hidden: true }); + const nameIn = h('input', { type: 'text', maxlength: String(S.nameLen[1] * 2), autocomplete: 'off', autocapitalize: 'words', spellcheck: 'false', id: 'soc-name' }); + const tagIn = h('input', { type: 'text', maxlength: String(S.tagLen[1]), autocomplete: 'off', autocapitalize: 'characters', spellcheck: 'false', id: 'soc-tag' }); + const create = h('button', { class: 'btn primary wide', type: 'button' }, icon('plus'), App.t('soc.create.go')); + const valid = () => { + const n = Array.from(Soc.cleanName(nameIn.value)).length, t = tagIn.value.trim(); + return ok && n >= S.nameLen[0] && n <= S.nameLen[1] && /^[A-Za-z0-9]+$/.test(t) && t.length >= S.tagLen[0] && t.length <= S.tagLen[1]; + }; + const sync = () => { create.disabled = !valid(); }; + nameIn.addEventListener('input', sync); tagIn.addEventListener('input', sync); + create.addEventListener('click', () => X().guard(create, async () => { + err.hidden = true; + try { + await App.api.post('/alliances', { name: Soc.cleanName(nameIn.value), tag: tagIn.value.trim() }, { intent: 'ally:create' }); + toast(App.t('soc.create.done'), 'ok'); + await reload(); + } catch (e) { + err.textContent = e.code === 'validation_failed' ? App.t('soc.create.invalid', { n1: S.nameLen[0], n2: S.nameLen[1], t1: S.tagLen[0], t2: S.tagLen[1] }) : X().err(e); + err.hidden = false; + } + })); + sync(); + + body.appendChild(h('div', { class: 'card soc-card' }, + h('div', { class: 'card-head' }, h('h2', null, icon('users'), App.t('soc.create.title'))), + h('p', { class: 'detail-desc', text: App.t('soc.create.intro') }), + h('ul', { class: 'reqs soc-req' }, h('li', { class: ok ? 'ok' : 'miss' }, icon(ok ? 'check' : 'lock'), + h('span', { text: App.buildingName('peering_office') + ' ' + App.t('pop.level', { n: need }) }), h('small', { text: App.t('sheet.have', { n: have }) }))), + ok ? null : h('p', { class: 'reason', text: App.t('soc.create.needOffice', { building: App.buildingName('peering_office'), n: need }) }), + h('label', { class: 'field', for: 'soc-name' }, h('span', { class: 'field-lbl', text: App.t('soc.create.name') }), nameIn, + h('span', { class: 'field-hint', text: App.t('soc.create.nameHint', { a: S.nameLen[0], b: S.nameLen[1] }) })), + h('label', { class: 'field', for: 'soc-tag' }, h('span', { class: 'field-lbl', text: App.t('soc.create.tag') }), tagIn, + h('span', { class: 'field-hint', text: App.t('soc.create.tagHint', { a: S.tagLen[0], b: S.tagLen[1] }) })), + err, create)); + + const invCard = h('div', { class: 'card soc-card' }, h('div', { class: 'card-head' }, h('h2', null, icon('mail'), App.t('soc.invites.title')), + h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('common.retry'), onclick: () => load() }, icon('refresh')))); + const items = cache.invites || []; + if (!items.length) invCard.appendChild(h('p', { class: 'empty', text: App.t('soc.invites.none') })); + else { + if (!ok) invCard.appendChild(h('p', { class: 'reason', text: App.t('soc.invites.needOffice', { building: App.buildingName('peering_office') }) })); + const list = h('ul', { class: 'soc-list' }); + const now = App.now(); + for (const inv of items) { + const e2 = h('p', { class: 'form-error', role: 'alert', hidden: true }); + const acc = h('button', { class: 'btn small primary', type: 'button', text: App.t('soc.invites.accept') }); + const dec = h('button', { class: 'btn small', type: 'button', text: App.t('soc.invites.decline') }); + const answer = (accept) => X().guard(accept ? acc : dec, async () => { + e2.hidden = true; + try { + await App.api.post('/alliance-invites/' + inv.id + (accept ? '/accept' : '/decline'), {}, { intent: 'ally:invite:' + inv.id }); + toast(App.t(accept ? 'soc.invites.accepted' : 'soc.invites.declined'), 'ok'); + await reload(); + } catch (e) { e2.textContent = X().err(e); e2.hidden = false; } + }); + acc.addEventListener('click', () => answer(true)); + dec.addEventListener('click', () => answer(false)); + list.appendChild(h('li', { class: 'soc-item soc-invite' }, + h('div', { class: 'row-main' }, + h('span', { class: 'row-title' }, X().tagPill(inv.alliance.tag), h('b', { text: inv.alliance.name })), + h('span', { class: 'row-sub', text: App.t('soc.invites.from', { name: inv.invitedBy.name }) + ' · ' + App.t('soc.invites.expires', { t: App.fmt.dur(Math.max(0, inv.expiresAt - now), 2) }) })), + h('div', { class: 'soc-actions' }, dec, acc), e2)); + } + invCard.appendChild(list); + } + body.appendChild(invCard); + } + + // ------------------------------------------------------------------ in an alliance + function drawIn() { + clear(body); + stopTick(); + const a = mine.alliance; + const sizeP = a.sizeCap > 0 ? Math.min(1, a.memberCount / a.sizeCap) : 0; + body.appendChild(h('div', { class: 'card soc-card soc-head' }, + h('div', { class: 'soc-title' }, X().tagPill(a.tag), h('h2', { class: 'soc-name', text: a.name })), + h('div', { class: 'pill-row' }, X().rolePill(mine.role), + h('span', { class: 'pill', text: App.t('soc.size', { n: a.memberCount, cap: a.sizeCap }) }), + h('span', { class: 'pill', text: App.t('soc.leaderIs', { name: a.leader ? a.leader.name : '-' }) })), + h('div', { class: 'bar', 'aria-hidden': 'true', style: { '--p': String(sizeP) } }, h('i')))); + + const tabs = [['overview', 'soc.tab.overview'], ['members', 'soc.tab.members'], ['diplomacy', 'soc.tab.diplomacy']]; + tabsEl = h('div', { class: 'seg soc-tabs', role: 'group', 'aria-label': App.t('soc.tab.label') }, + tabs.map(([id, key]) => h('button', { class: 'seg-btn', type: 'button', dataset: { tab: id }, 'aria-pressed': String(tab === id), text: App.t(key), onclick: () => setTab(id) }))); + content = h('div', { class: 'soc-content' }); + body.appendChild(tabsEl); + body.appendChild(content); + drawTab(); + } + + function setTab(id) { + tab = id; + for (const b of tabsEl.children) b.setAttribute('aria-pressed', String(b.dataset.tab === id)); + drawTab(); + } + + function drawTab() { + stopTick(); + clear(content); + if (tab === 'members') drawMembers(); + else if (tab === 'diplomacy') drawDiplomacy(); + else drawOverview(); + } + + // ---------------------------------------------------------------- overview: notes, leave / disband + const nameOf = (id) => { const m = (members || []).find((x) => x.operatorId === id); return m ? m.name : '#' + id; }; + + async function drawOverview() { + const my = gen; + const A = acts(); + const notesCard = h('div', { class: 'card soc-card' }, h('div', { class: 'card-head' }, h('h2', null, icon('pencil'), App.t('soc.notes.title')), + h('span', { class: 'pill dim mono', id: 'soc-notes-count' }))); + const notesList = h('ul', { class: 'soc-list' }); + notesCard.appendChild(notesList); + content.appendChild(notesCard); + + function drawNotes(items) { + clear(notesList); + notesCard.querySelector('#soc-notes-count').textContent = items.length + '/' + S.maxNotes; + if (!items.length) notesList.appendChild(h('li', { class: 'empty', text: App.t('soc.notes.none') })); + for (const n of items) { + const del = h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('soc.notes.remove'), onclick: (ev) => X().guard(ev.currentTarget, async () => { + await App.api.del('/alliances/' + mine.alliance.id + '/notes/' + n.id); + cache.notes = cache.notes.filter((x) => x.id !== n.id); + drawNotes(cache.notes); + }) }, icon('x')); + notesList.appendChild(h('li', { class: 'soc-item soc-note' }, + h('div', { class: 'row-main' }, h('p', { class: 'soc-text-out', text: n.text }), + h('span', { class: 'row-sub', text: nameOf(n.authorId) + ' · ' + App.fmt.ago(App.now() - n.createdAt) })), + A.editNotes ? del : null)); + } + } + + if (A.editNotes) { + const ta = h('textarea', { class: 'soc-text', rows: 2, maxlength: String(S.noteMax * 2), 'aria-label': App.t('soc.notes.add'), placeholder: App.t('soc.notes.placeholder') }); + const cnt = h('span', { class: 'soc-count mono' }); + const err = h('p', { class: 'form-error', role: 'alert', hidden: true }); + const add = h('button', { class: 'btn small primary', type: 'button' }, icon('plus'), App.t('soc.notes.add')); + const sync = () => { + const st = Soc.composeState(ta.value, S.noteMax); + cnt.textContent = st.n + '/' + S.noteMax; cnt.classList.toggle('over', st.over); + add.disabled = st.empty || st.over || (cache.notes && cache.notes.length >= S.maxNotes); + }; + ta.addEventListener('input', sync); + add.addEventListener('click', () => X().guard(add, async () => { + err.hidden = true; + try { + const r = await App.api.post('/alliances/' + mine.alliance.id + '/notes', { text: ta.value }); + cache.notes = (cache.notes || []).concat([r.note]); + ta.value = ''; + drawNotes(cache.notes); sync(); + } catch (e) { err.textContent = X().err(e); err.hidden = false; } + })); + notesCard.appendChild(h('div', { class: 'soc-addnote' }, ta, h('div', { class: 'soc-composer-bar' }, cnt, add), err)); + sync(); + } + + // leave / disband + const danger = h('div', { class: 'card soc-card' }, h('div', { class: 'card-head' }, h('h2', null, icon('shield'), App.t('soc.manage.title')))); + const row = h('div', { class: 'btn-row soc-stack' }); + if (A.leaveNeedsTransfer) { + danger.appendChild(h('p', { class: 'reason', text: App.t('soc.leave.mustTransfer') })); + row.appendChild(h('button', { class: 'btn', type: 'button', onclick: () => setTab('members') }, icon('users'), App.t('soc.leave.goTransfer'))); + } else { + row.appendChild(h('button', { class: 'btn danger', type: 'button', onclick: confirmLeave }, icon('logout'), App.t('soc.leave.go'))); + } + if (A.disband) row.appendChild(h('button', { class: 'btn danger', type: 'button', onclick: confirmDisband }, icon('x'), App.t('soc.disband.go'))); + danger.appendChild(row); + content.appendChild(danger); + + if (cache.notes) { drawNotes(cache.notes); return; } + notesList.appendChild(X().loading()); + try { + const r = await App.api.get('/alliances/' + mine.alliance.id + '/notes'); + if (my !== gen) return; + cache.notes = r.items; + if (tab === 'overview') drawNotes(cache.notes); + } catch (e) { if (my === gen && tab === 'overview') { clear(notesList); notesList.appendChild(X().errorBox(e, drawTab)); } } + } + + function confirmLeave() { + const alone = members && members.length <= 1; + X().confirmSheet({ + title: App.t('soc.leave.go'), icon: 'logout', danger: true, ok: App.t('soc.leave.go'), + text: App.t(alone ? 'soc.leave.confirmAlone' : 'soc.leave.confirm', { name: mine.alliance.name }), + onOk: async () => { await App.api.post('/alliances/' + mine.alliance.id + '/leave', {}, { intent: 'ally:leave' }); toast(App.t('soc.leave.done'), 'ok'); await reload(); }, + }); + } + + function confirmDisband() { + X().confirmSheet({ + title: App.t('soc.disband.go'), icon: 'alert', danger: true, ok: App.t('soc.disband.go'), + text: App.t('soc.disband.confirm', { name: mine.alliance.name }), + onOk: async () => { await App.api.post('/alliances/' + mine.alliance.id + '/disband', {}, { intent: 'ally:disband' }); toast(App.t('soc.disband.done'), 'ok'); await reload(); }, + }); + } + + // ---------------------------------------------------------------- members + function drawMembers() { + const A = acts(); + const now = App.now(); + const card = h('div', { class: 'card soc-card' }, h('div', { class: 'card-head' }, h('h2', null, icon('users'), App.t('soc.members')), + h('span', { class: 'pill dim mono', text: App.t('soc.size', { n: members.length, cap: mine.alliance.sizeCap }) }))); + const list = h('ul', { class: 'soc-list' }); + for (const m of members) { + const you = m.operatorId === X().myOperatorId(); + list.appendChild(h('li', null, h('button', { class: 'row-btn soc-member', type: 'button', onclick: () => openMember(m) }, + h('span', { class: 'row-main' }, + h('span', { class: 'row-title' }, h('b', { text: m.name }), you ? h('span', { class: 'pill accent', text: App.t('soc.you') }) : null, X().rolePill(m.role)), + h('span', { class: 'row-sub', text: App.t('soc.member.stats', { towns: m.towns, fp: App.fmt.dec(m.footprint) }) + ' · ' + (m.lastOnline ? App.t('soc.member.online', { t: App.fmt.ago(now - m.lastOnline) }) : App.t('soc.member.never')) }))))); + } + card.appendChild(list); + content.appendChild(card); + + if (A.invite) drawInvite(); + } + + async function drawInvite() { + const my = gen; + const card = h('div', { class: 'card soc-card' }, h('div', { class: 'card-head' }, h('h2', null, icon('mail'), App.t('soc.invite.title')))); + const err = h('p', { class: 'form-error', role: 'alert', hidden: true }); + const nameIn = h('input', { type: 'text', maxlength: '40', autocomplete: 'off', spellcheck: 'false', 'aria-label': App.t('soc.invite.name'), placeholder: App.t('soc.invite.name'), enterkeyhint: 'send' }); + const go = h('button', { class: 'btn primary', type: 'button' }, icon('up'), App.t('soc.invite.go')); + const pend = h('ul', { class: 'soc-list' }); + const sync = () => { go.disabled = !Soc.cleanName(nameIn.value); }; + nameIn.addEventListener('input', sync); + nameIn.addEventListener('keydown', (ev) => { if (ev.key === 'Enter' && !go.disabled) go.click(); }); + go.addEventListener('click', () => X().guard(go, async () => { + err.hidden = true; + const name = Soc.cleanName(nameIn.value); + try { + const r = await App.api.post('/alliances/' + mine.alliance.id + '/invite', { name }, { intent: 'ally:invite:' + name.toLowerCase() }); + toast(App.t(r.changed ? 'soc.invite.sent' : 'soc.invite.already', { name }), 'ok'); + nameIn.value = ''; sync(); + loadPending(); + } catch (e) { err.textContent = e.code === 'not_found' ? App.t('soc.invite.unknown', { name }) : X().err(e); err.hidden = false; } + })); + sync(); + card.appendChild(h('div', { class: 'soc-inline' }, nameIn, go)); + card.appendChild(err); + if (acts().viewInvites) { card.appendChild(h('div', { class: 'sub', text: App.t('soc.invite.pending') })); card.appendChild(pend); } + content.appendChild(card); + + async function loadPending() { + if (!acts().viewInvites) return; + try { + const r = await App.api.get('/alliances/' + mine.alliance.id + '/invites'); + if (my !== gen || tab !== 'members') return; + clear(pend); + if (!r.items.length) pend.appendChild(h('li', { class: 'empty', text: App.t('soc.invite.none') })); + const now = App.now(); + for (const inv of r.items) { + const cancel = h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('soc.invite.cancel'), onclick: (ev) => X().guard(ev.currentTarget, async () => { + await App.api.del('/alliances/' + mine.alliance.id + '/invites/' + inv.id); + loadPending(); + }) }, icon('x')); + pend.appendChild(h('li', { class: 'soc-item' }, h('div', { class: 'row-main' }, h('b', { text: inv.operator.name }), + h('span', { class: 'row-sub', text: App.t('soc.invites.from', { name: inv.invitedBy.name }) + ' · ' + App.t('soc.invites.expires', { t: App.fmt.dur(Math.max(0, inv.expiresAt - now), 2) }) })), + acts().cancelInvite ? cancel : null)); + } + } catch (e) { if (my === gen && tab === 'members') { clear(pend); pend.appendChild(X().errorBox(e, loadPending)); } } + } + loadPending(); + } + + // Member sheet: message, role (leader), transfer (leader), kick (outranking). + function openMember(m) { + const act = Soc.memberActions(myRole(), m, X().myOperatorId()); + const err = h('p', { class: 'form-error', role: 'alert', hidden: true }); + const bodyEl = h('div', { class: 'detail' }); + const sheet = openSheet({ title: m.name, icon: 'users', closeLabel: App.t('common.close'), body: bodyEl }); + const after = async () => { sheet.close(); await load(); }; + const run = (btn, fn) => X().guard(btn, async () => { err.hidden = true; try { await fn(); } catch (e) { err.textContent = X().err(e); err.hidden = false; } }); + + bodyEl.appendChild(h('div', { class: 'pill-row' }, X().rolePill(m.role), h('span', { class: 'pill mono', text: 'AS' + m.asNumber }))); + bodyEl.appendChild(h('div', null, + kv(App.t('soc.member.pops'), String(m.towns)), kv(App.t('soc.footprint'), App.fmt.dec(m.footprint)), + kv(App.t('soc.member.lastOnline'), m.lastOnline ? App.fmt.ago(App.now() - m.lastOnline) : App.t('soc.member.never')), + kv(App.t('soc.member.joined'), App.fmt.ago(App.now() - m.joinedAt)))); + if (act.message) bodyEl.appendChild(h('button', { class: 'btn wide', type: 'button', onclick: () => { sheet.close(); X().openCompose({ operator: { operatorId: m.operatorId, name: m.name } }); } }, icon('mail'), App.t('soc.member.message'))); + if (act.roles.length) { + bodyEl.appendChild(h('div', { class: 'sub', text: App.t('soc.member.setRole') })); + bodyEl.appendChild(h('div', { class: 'seg' }, act.roles.map((r) => h('button', { class: 'seg-btn', type: 'button', text: X().role(r), onclick: (ev) => run(ev.currentTarget, async () => { + await App.api.post('/alliances/' + mine.alliance.id + '/role', { operatorId: m.operatorId, role: r }, { intent: 'ally:role:' + m.operatorId + ':' + r }); + toast(App.t('soc.member.roleSet', { name: m.name, role: X().role(r) }), 'ok'); + await after(); + }) })))); + bodyEl.appendChild(h('p', { class: 'field-hint', text: App.t('soc.member.roleHint') })); + } + const row = h('div', { class: 'btn-row soc-stack' }); + if (act.transfer) row.appendChild(h('button', { class: 'btn', type: 'button', onclick: () => { + sheet.close(); + X().confirmSheet({ title: App.t('soc.transfer.go'), icon: 'shield', ok: App.t('soc.transfer.go'), text: App.t('soc.transfer.confirm', { name: m.name }), + onOk: async () => { await App.api.post('/alliances/' + mine.alliance.id + '/transfer', { operatorId: m.operatorId }, { intent: 'ally:transfer:' + m.operatorId }); toast(App.t('soc.transfer.done', { name: m.name }), 'ok'); await load(); } }); + } }, icon('shield'), App.t('soc.transfer.go'))); + if (act.kick) row.appendChild(h('button', { class: 'btn danger', type: 'button', onclick: () => { + sheet.close(); + X().confirmSheet({ title: App.t('soc.kick.go'), icon: 'alert', danger: true, ok: App.t('soc.kick.go'), text: App.t('soc.kick.confirm', { name: m.name }), + onOk: async () => { await App.api.post('/alliances/' + mine.alliance.id + '/kick', { operatorId: m.operatorId }, { intent: 'ally:kick:' + m.operatorId }); toast(App.t('soc.kick.done', { name: m.name }), 'ok'); await load(); } }); + } }, icon('x'), App.t('soc.kick.go'))); + if (row.children.length) bodyEl.appendChild(row); + bodyEl.appendChild(err); + } + + // ---------------------------------------------------------------- diplomacy + async function drawDiplomacy() { + const my = gen; + const A = acts(); + const card = h('div', { class: 'card soc-card' }, h('div', { class: 'card-head' }, h('h2', null, icon('shield'), App.t('soc.dip.title')), + A.diplomacy ? h('button', { class: 'btn small primary', type: 'button', onclick: openPicker }, icon('plus'), App.t('soc.dip.new')) : null)); + const holder = h('div', { class: 'soc-dip' }, X().loading()); + card.appendChild(holder); + if (!A.diplomacy) card.appendChild(h('p', { class: 'field-hint', text: App.t('soc.dip.readOnly') })); + content.appendChild(card); + + const draw = (d) => { + cache.dip = d; + clear(holder); + stopTick(); + if (d.proposalsIn.length) holder.appendChild(proposalBlock('soc.dip.incoming', d.proposalsIn, 'in')); + holder.appendChild(h('div', { class: 'sub', text: App.t('soc.dip.relations') })); + if (!d.relations.length) holder.appendChild(h('p', { class: 'empty', text: App.t('soc.dip.none') })); + const list = h('ul', { class: 'soc-list' }); + for (const r of d.relations) list.appendChild(relationRow(r)); + holder.appendChild(list); + if (d.proposalsOut.length) holder.appendChild(proposalBlock('soc.dip.outgoing', d.proposalsOut, 'out')); + const cds = holder.querySelectorAll('[data-eff]'); + if (cds.length) { + offTick = App.onTick((now) => { + for (const el of cds) { + if (!el.isConnected) continue; + const left = Math.max(0, Number(el.dataset.eff) - now); + const s = left > 0 ? App.t('soc.dip.in', { t: App.fmt.dur(left, 2) }) : App.t('soc.dip.applying'); + if (el.textContent !== s) el.textContent = s; + } + }); + } + }; + + const refetch = async () => { + try { + const d = await App.api.get('/alliances/' + mine.alliance.id + '/diplomacy'); + if (my !== gen || tab !== 'diplomacy') return; + draw(d); + } catch (e) { if (my === gen && tab === 'diplomacy') { clear(holder); holder.appendChild(X().errorBox(e, drawTab)); } } + }; + refreshDip = refetch; + if (cache.dip) draw(cache.dip); + refetch(); + } + let refreshDip = () => {}; + + function allianceLabel(other) { + return h('span', { class: 'row-title' }, other.tag ? X().tagPill(other.tag) : null, h('b', { text: other.name || '#' + other.id })); + } + + function relationRow(r) { + const A = acts(); + const now = App.now(); + const p = r.pending; + const eta = p ? h('span', { class: 'soc-eta mono', dataset: { eff: p.effectiveAt }, text: App.t('soc.dip.in', { t: App.fmt.dur(Math.max(0, p.effectiveAt - now), 2) }) }) : null; + const revoke = p && p.byUs && A.diplomacy + ? h('button', { class: 'btn small', type: 'button', text: App.t('soc.dip.revoke'), onclick: (ev) => X().guard(ev.currentTarget, async () => { + await App.api.del('/alliances/' + mine.alliance.id + '/diplomacy/' + r.other.id + '/pending'); + toast(App.t('soc.dip.revoked'), 'ok'); refreshDip(); + }) }) : null; + return h('li', { class: 'soc-item soc-rel' }, + h('div', { class: 'row-main' }, allianceLabel(r.other), + h('span', { class: 'row-sub' }, h('span', { class: 'pill soc-state soc-state-' + r.state, text: X().state(r.state) }), + p ? h('span', { class: 'soc-pending' }, ' → ', h('b', { text: X().state(p.to) }), ' · ', eta, ' · ', p.byUs ? App.t('soc.dip.byUs') : App.t('soc.dip.byThem')) : null)), + revoke); + } + + function proposalBlock(titleKey, items, dir) { + const A = acts(); + const wrap = h('div', null, h('div', { class: 'sub', text: App.t(titleKey) })); + const list = h('ul', { class: 'soc-list' }); + const now = App.now(); + for (const pr of items) { + const mk = (label, cls, path, method) => h('button', { class: 'btn small ' + cls, type: 'button', text: label, onclick: (ev) => X().guard(ev.currentTarget, async () => { + try { + if (method === 'del') await App.api.del(path); else await App.api.post(path, {}, { intent: 'dip:' + path }); + refreshDip(); + } catch (e) { toast(X().err(e), 'error'); refreshDip(); } + }) }); + const btns = !A.diplomacy ? [] : dir === 'in' + ? [mk(App.t('soc.dip.decline'), '', '/diplomacy/proposals/' + pr.id + '/decline'), mk(App.t('soc.dip.accept'), 'primary', '/diplomacy/proposals/' + pr.id + '/accept')] + : [mk(App.t('soc.dip.withdraw'), '', '/diplomacy/proposals/' + pr.id, 'del')]; + list.appendChild(h('li', { class: 'soc-item soc-rel' }, + h('div', { class: 'row-main' }, allianceLabel(pr.other), + h('span', { class: 'row-sub' }, h('span', { class: 'pill soc-state soc-state-' + pr.state, text: X().state(pr.state) }), h('span', { text: App.t('soc.dip.expires', { t: App.fmt.dur(Math.max(0, pr.expiresAt - now), 2) }) }))), + h('div', { class: 'soc-actions' }, btns))); + } + wrap.appendChild(list); + return wrap; + } + + // Pick another alliance (directory search), then the move. + function openPicker() { + const results = h('ul', { class: 'soc-list' }); + const q = h('input', { type: 'text', maxlength: '40', autocomplete: 'off', spellcheck: 'false', placeholder: App.t('soc.dip.search'), 'aria-label': App.t('soc.dip.search'), enterkeyhint: 'search' }); + const more = h('button', { class: 'btn small wide', type: 'button', hidden: true, text: App.t('soc.more') }); + let items = [], next = null, seq = 0, timer = null; + const sheet = openSheet({ title: App.t('soc.dip.pick'), icon: 'shield', closeLabel: App.t('common.close'), onClose: () => clearTimeout(timer), + body: h('div', { class: 'detail' }, q, results, more) }); + + function drawResults() { + clear(results); + const rows = items.filter((x) => x.id !== mine.alliance.id); + if (!rows.length) results.appendChild(h('li', { class: 'empty', text: App.t('soc.dip.noResults') })); + for (const a of rows) { + results.appendChild(h('li', null, h('button', { class: 'row-btn', type: 'button', onclick: () => { sheet.close(); openMove(a); } }, + h('span', { class: 'row-main' }, allianceLabel(a), h('span', { class: 'row-sub', text: App.t('soc.size', { n: a.memberCount, cap: a.sizeCap }) }))))); + } + more.hidden = next === null; + } + async function search(append) { + const my = ++seq; + try { + const r = await App.api.get('/alliances', { q: q.value.trim() || undefined, after: append ? next : undefined, limit: 30 }); + if (my !== seq) return; + items = append ? items.concat(r.items) : r.items; next = r.next; + drawResults(); + } catch (e) { if (my === seq) { clear(results); results.appendChild(X().errorBox(e, () => search(false))); } } + } + q.addEventListener('input', () => { clearTimeout(timer); timer = setTimeout(() => search(false), 250); }); + more.addEventListener('click', () => search(true)); + search(false); + } + + function openMove(other) { + const d = cache.dip || { relations: [] }; + const cur = Soc.relationTo(d.relations, other.id); + const opts = Soc.diplomacyOptions(cur.state, cur.pending); + const err = h('p', { class: 'form-error', role: 'alert', hidden: true }); + const list = h('div', { class: 'soc-moves' }); + const sheet = openSheet({ title: other.name, icon: 'shield', closeLabel: App.t('common.close'), + body: h('div', { class: 'detail' }, + h('div', { class: 'pill-row' }, X().tagPill(other.tag), h('span', { class: 'pill soc-state soc-state-' + cur.state, text: App.t('soc.dip.current', { state: X().state(cur.state) }) })), + cur.pending ? h('p', { class: 'reason', text: App.t('soc.dip.locked') }) : null, + !opts.length && !cur.pending ? h('p', { class: 'empty', text: App.t('soc.dip.noMoves') }) : null, + list, err) }); + for (const o of opts) { + const hint = o.kind === 'delayed' ? App.t('soc.kind.delayed.hint', { t: App.fmt.dur(R.pactCancelMs(App.state.world ? App.state.world.speed : 1), 2) }) : App.t('soc.kind.' + o.kind + '.hint'); + list.appendChild(h('button', { class: 'row-btn soc-move', type: 'button', onclick: (ev) => X().guard(ev.currentTarget, async () => { + err.hidden = true; + try { + const r = await App.api.post('/alliances/' + mine.alliance.id + '/diplomacy', { targetId: other.id, state: o.state }, { intent: 'dip:' + other.id + ':' + o.state }); + toast(App.t('soc.dip.result.' + r.result, { state: X().state(r.state), name: other.name }), 'ok'); + sheet.close(); + cache.dip = null; + if (tab === 'diplomacy') drawTab(); + } catch (e) { err.textContent = X().err(e); err.hidden = false; } + }) }, + h('span', { class: 'row-main' }, h('span', { class: 'row-title' }, h('span', { class: 'pill soc-state soc-state-' + o.state, text: X().state(o.state) }), h('b', { text: App.t('soc.kind.' + o.kind) })), h('span', { class: 'row-sub soc-wrap', text: hint })))); + } + } + + function stopTick() { if (offTick) { offTick(); offTick = null; } } + + App.registerScreen({ + id: 'alliance', titleKey: 'screen.alliance', navKey: 'nav.alliance', icon: 'users', hud: false, navGroup: 'more', + render(container) { + box = container; + body = h('div', { class: 'soc-body' }); + box.appendChild(h('div', { class: 'page soc-page' }, + h('div', { class: 'card-head page-head' }, h('h1', { id: 'soc-alliance-h', text: App.t('screen.alliance') }), + h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('common.retry'), onclick: () => load() }, icon('refresh'))), + body)); + App.on('session', () => { mine = null; members = null; tab = 'overview'; for (const k of Object.keys(cache)) delete cache[k]; }); + }, + onShow() { box.querySelector('#soc-alliance-h').textContent = App.t('screen.alliance'); load(); }, + onHide() { stopTick(); gen++; }, + }); +}()); diff --git a/public/js/screens/expand.js b/public/js/screens/expand.js new file mode 100644 index 0000000..6289d61 --- /dev/null +++ b/public/js/screens/expand.js @@ -0,0 +1,50 @@ +'use strict'; +/* + * Expansion on the POP screen (App.popSections, slot 'main'): your POPs (switch between them), and what founding the next + * one takes: rollout crews at home, the footprint gate, a shortcut to the map to pick a site (the map tile sheet then offers + * "Send" -> Settle with the wild-slot choice, see send.js). The founding itself is a settle movement; the settle report has + * an "Open POP" button. The POP switcher in the resource bar lives in main.js. + */ +(function () { + const { h, icon, toast } = UI; + const R = UpstreamRules; + const D = UpstreamData; + const mil = () => App.mil; + + function popsList(t) { + const st = App.state; + return h('ul', { class: 'mil-list' }, st.towns.map((x) => h('li', { class: 'mil-row' + (x.id === t.id ? ' current' : '') }, + h('span', { class: 'row-ic' }, icon('pop')), + h('span', { class: 'row-main' }, + h('span', { class: 'row-title' }, h('b', { text: x.name }), x.isCapital ? h('span', { class: 'pill accent', text: App.t('pop.capital') }) : null), + h('span', { class: 'row-sub' }, mil().coordLink(x.x, x.y))), + x.id === t.id ? h('span', { class: 'pill green', text: App.t('exp.current') }) + : h('button', { class: 'btn small', type: 'button', onclick: () => { App.setTown(x.id); } }, App.t('exp.open'))))); + } + + function card(t) { + const m = t.military; + const owned = App.state.towns.length; + const need = R.footprintNeeded(owned); + const crews = m ? (m.units.home[D.EXPANSION.settleUnit] || 0) : 0; + const canTrain = m && m.trainable.some((u) => u.unit === D.EXPANSION.settleUnit && !u.locked); + const rows = [ + h('div', { class: 'kv' }, h('span', { class: 'k', text: App.t('exp.crews') }), h('span', { class: 'v mono' + (crews >= D.EXPANSION.crews ? ' good' : ''), text: crews + ' / ' + D.EXPANSION.crews })), + h('div', { class: 'kv' }, h('span', { class: 'k', text: App.t('exp.footprint') }), h('span', { class: 'v mono', text: App.t('exp.footprint.v', { have: App.fmt.num(t.footprint), need: App.fmt.num(need) }) })), + h('div', { class: 'kv' }, h('span', { class: 'k', text: App.t('exp.range') }), h('span', { class: 'v mono', text: D.EXPANSION.maxDistance + ' ' + App.t('common.tiles') })), + ]; + const actions = []; + if (crews >= D.EXPANSION.crews) { + actions.push(h('button', { class: 'btn primary wide', type: 'button', onclick: () => { App.go('map', { x: t.x, y: t.y, zoom: 24 }); toast(App.t('exp.pick'), 'ok'); } }, icon('flag'), App.t('exp.found'))); + } else { + actions.push(h('p', { class: 'row-sub wrap', text: canTrain ? App.t('exp.needCrews', { n: D.EXPANSION.crews - crews, unit: mil().unitName(D.EXPANSION.settleUnit) }) : App.t('exp.needDepot') })); + if (canTrain) actions.push(h('button', { class: 'btn wide', type: 'button', onclick: () => App.go('units') }, icon('units'), App.t('exp.train'))); + } + return h('section', { class: 'card' }, + h('div', { class: 'card-head' }, h('h2', null, icon('flag'), App.t('exp.title')), h('span', { class: 'pill', text: App.t('exp.count', { n: owned }) })), + rows, h('p', { class: 'row-sub wrap', text: App.t('exp.hint') }), actions, + owned > 1 ? [h('h3', { class: 'sub', text: App.t('exp.pops') }), popsList(t)] : null); + } + + App.popSections.push({ slot: 'main', render: card }); +}()); diff --git a/public/js/screens/map.js b/public/js/screens/map.js index 6e0bff4..ce7b76d 100644 --- a/public/js/screens/map.js +++ b/public/js/screens/map.js @@ -77,7 +77,7 @@ } // ------------------------------------------------------------------ screen - let box, canvas, view, coordsEl, legendEl, ready = false, visible = false, pendingFocus = 'own'; + let box, canvas, view, coordsEl, legendEl, ready = false, visible = false, pendingFocus = 'own', offMoveTick = null; const store = new Store(); let infoSheet = null; @@ -113,6 +113,8 @@ forEachSpecial: (a, b, c, d, fn) => store.forEachSpecial(a, b, c, d, fn), townsInRect: (a, b, c, d) => store.townsInRect(a, b, c, d), isOwn: (t) => t.owner.id === ownOperatorId(), + movements: () => moveLines(), + threatened: (t) => App.mil.moves.incoming.some((m) => m.to && m.to.townId === t.id), }; view = new MapRender.MapView(canvas, source, { onTap: onTap, @@ -128,6 +130,21 @@ drawLegend(); } + // Lines for the movements of the shared cache (App.mil.moves): yours, incoming and allied ones, with progress at draw time. + function moveLines() { + const mv = App.mil && App.mil.moves; + if (!mv) return []; + const now = App.now(), out = []; + const add = (m, kind) => { + if (!m.from || !m.to || m.from.x === undefined || m.to.x === undefined) return; + out.push({ from: m.from, to: m.to, kind, p: (now - m.departAt) / Math.max(1, m.arriveAt - m.departAt) }); + }; + for (const m of mv.outgoing) add(m, m.type === 'return' ? 'ret' : 'out'); + for (const m of mv.incoming) add(m, 'in'); + for (const m of mv.alliedIncoming || []) add(m, 'ally'); + return out; + } + function drawLegend() { UI.clear(legendEl); const item = (cls, text) => h('li', null, h('span', { class: 'lg ' + cls }), text); @@ -135,6 +152,8 @@ legendEl.appendChild(item('rival', App.t('map.legend.rival'))); legendEl.appendChild(item('rural', App.t('map.legend.rural'))); legendEl.appendChild(item('incumbent', App.t('map.legend.incumbent'))); + legendEl.appendChild(item('mv-out', App.t('map.legend.out'))); + legendEl.appendChild(item('mv-in', App.t('map.legend.in'))); } // ------------------------------------------------------------------ tile info @@ -174,6 +193,9 @@ body.push(h('p', { class: 'detail-desc', text: App.t('map.info.land') })); } body.push(row('', App.t('map.info.coords', { x, y }))); + if (App.openSend && App.state.towns.length && (town || (special && special.type === 'incumbent') || (!special && known))) { + body.push(h('button', { class: 'btn wide' + (town && town.owner.id === ownOperatorId() ? '' : ' primary'), type: 'button', onclick: () => App.openSend({ x, y }) }, icon('target'), App.t('send.open'))); + } if (cap && !(town && town.id === cap.id)) body.push(row('', App.t('map.info.distance', { d: App.fmt.dec(R.distance(cap.x, cap.y, x, y)) }))); if (town && town.owner.id === ownOperatorId() && App.state.towns.some((t) => t.id === town.id)) { body.push(h('button', { class: 'btn primary wide', type: 'button', onclick: () => { closeSheet(); App.setTown(town.id); App.go('pop'); } }, icon('pop'), App.t('map.info.open'))); @@ -192,10 +214,19 @@ render(container) { box = container; App.on('session', () => { store.reset(); pendingFocus = 'own'; }); + App.on('movements', () => { if (visible && view) view.invalidate(); }); + App.on('towns', () => { if (view) view.invalidate(); }); App.on('town', () => { const t = App.state.townData; if (t) store.patchTown(t.id, { name: t.name }); }); }, onShow(params) { visible = true; + // marker positions move with the clock: redraw about once a second while any movement is on the wire + if (offMoveTick) offMoveTick(); + let lastSec = 0; + offMoveTick = App.onTick((now) => { + const sec = Math.floor(now / 1000), mv = App.mil.moves; + if (sec !== lastSec && view && (mv.outgoing.length || mv.incoming.length || (mv.alliedIncoming || []).length)) { lastSec = sec; view.invalidate(); } + }); if (!App.state.world) { UI.clear(box); box.appendChild(h('p', { class: 'empty pad', text: App.t('map.noWorld') })); ready = false; return; } setup(); view.setWorld(App.state.world.mapRadius); @@ -208,7 +239,7 @@ // the container was display:none until now: measure after layout requestAnimationFrame(() => { if (view.resize()) apply(); else setTimeout(() => { view.resize(); apply(); }, 60); }); }, - onHide() { visible = false; closeSheet(); }, + onHide() { visible = false; if (offMoveTick) offMoveTick(); offMoveTick = null; closeSheet(); }, onLang() { if (!ready) return; canvas.setAttribute('aria-label', App.t('map.label')); diff --git a/public/js/screens/messages.js b/public/js/screens/messages.js new file mode 100644 index 0000000..38a8ff4 --- /dev/null +++ b/public/js/screens/messages.js @@ -0,0 +1,334 @@ +'use strict'; +/* + * Messages: inbox, sent, alliance broadcast feed, blocked operators, one thread per operator, compose. Message text is + * plain text and only ever set with textContent (the CSS keeps line breaks). Lists are newest first and paged with + * `after` = the last id (the next page holds OLDER ids). The unread count of the inbox is polled in the background and + * shown through App.setBadge on the nav entry (or the "More" button). + */ +(function () { + const { h, clear, icon, toast, openSheet } = UI; + const Soc = UpstreamSocial; + const D = UpstreamData; + const X = () => window.SocUI; + const PAGE = 30; + + let box, tabsEl, listBox, tab = 'inbox'; + let thread = null; // { peer: {operatorId, name}, items, next, loading } while a conversation is open + let blocked = null; // Map operatorId -> name (loaded lazily) + let unreadOnly = false; + let offTick = null, gen = 0; + const feeds = { inbox: blank(), sent: blank(), alliance: blank() }; + let blocks = { items: null, err: null }; + + function blank() { return { items: [], next: null, loaded: false, loading: false, err: null }; } + const inAlliance = () => !!X().myAlliance(); + const urls = { inbox: '/messages/inbox', sent: '/messages/outbox', alliance: '/messages/alliance' }; + + // ------------------------------------------------------------------ unread badge (works without the screen being open) + const badge = { n: 0, polling: false }; + async function pollUnread() { + if (!App.state.user || badge.polling || document.hidden) return; + badge.polling = true; + try { const r = await App.api.get('/messages/inbox', { limit: 1 }); setUnread(r.unread || 0); } catch (e) { /* a badge is a convenience */ } finally { badge.polling = false; } + } + // App.setBadge (main.js) shows it on this screen's nav button, or summed on the "More" button when the screen lives there. + function setUnread(n) { badge.n = n; App.state.unreadMsgs = n; App.setBadge('messages', n, 'info'); } + setInterval(pollUnread, 60000); + document.addEventListener('visibilitychange', () => { if (!document.hidden) pollUnread(); }); + App.on('session', () => { setUnread(0); for (const k of Object.keys(feeds)) feeds[k] = blank(); blocks = { items: null, err: null }; thread = null; setTimeout(pollUnread, 800); }); + + // ------------------------------------------------------------------ loading + async function loadFeed(kind, more) { + const f = feeds[kind]; + if (f.loading) return; + f.loading = true; f.err = null; + const my = gen; + if (kind === tab && !thread) drawList(); + try { + const q = { limit: PAGE }; + if (more && f.next) q.after = f.next; + if (kind === 'inbox' && unreadOnly) q.unread = true; + const r = await App.api.get(urls[kind], q); + f.items = more ? Soc.mergeMessages(f.items, r.items) : r.items; + f.next = r.next; f.loaded = true; + if (kind === 'inbox' && typeof r.unread === 'number') setUnread(r.unread); + } catch (e) { f.err = e; if (kind === 'alliance' && e.code === 'not_in_alliance') { f.items = []; f.next = null; f.loaded = true; f.err = null; } } finally { + f.loading = false; + if (my === gen && kind === tab && !thread) drawList(); + } + } + + async function loadBlocks() { + blocks.err = null; + try { blocks.items = (await App.api.get('/messages/blocks')).items; blocked = new Map(blocks.items.map((b) => [b.operatorId, b.name])); } catch (e) { blocks.err = e; } + if (tab === 'blocked' && !thread) drawList(); + } + + async function markRead(ids) { + if (!ids.length) return; + try { + await App.api.post('/messages/read', { ids: ids.slice(0, 100) }); + const now = App.now(), set = new Set(ids); + for (const k of Object.keys(feeds)) for (const m of feeds[k].items) if (set.has(m.id) && !m.readAt) m.readAt = now; + if (thread) for (const m of thread.items) if (set.has(m.id) && !m.readAt) m.readAt = now; + pollUnread(); + } catch (e) { /* unread state only */ } + } + + async function deleteMessage(m, btn) { + await X().guard(btn, async () => { + await App.api.del('/messages/' + m.id); + for (const k of Object.keys(feeds)) feeds[k].items = feeds[k].items.filter((x) => x.id !== m.id); + if (thread) thread.items = thread.items.filter((x) => x.id !== m.id); + toast(App.t('soc.msg.deleted'), 'ok'); + pollUnread(); + thread ? drawThread() : drawList(); + }); + } + + // ------------------------------------------------------------------ list view + const ago = (at) => h('span', { class: 'when mono', dataset: { at }, text: App.fmt.ago(App.now() - at) }); + + function msgRow(m) { + const out = m.direction === 'out'; + const unread = !out && !m.readAt; + const alliance = m.kind === 'alliance'; + const who = out ? (alliance ? App.t('soc.msg.allianceFeed') : App.t('soc.msg.toShort', { name: m.to ? m.to.name : '?' })) : m.from.name; + const del = h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('soc.msg.delete'), onclick: (ev) => deleteMessage(m, ev.currentTarget) }, icon('x')); + return h('li', { class: 'soc-msgrow' }, + h('button', { class: 'row-btn soc-msg' + (unread ? ' unread' : ''), type: 'button', onclick: () => openMessage(m) }, + h('span', { class: 'row-main' }, + h('span', { class: 'row-title' }, h('b', { text: who }), alliance && m.alliance ? X().tagPill(m.alliance.tag) : null, unread ? h('span', { class: 'pill accent', text: App.t('soc.msg.new') }) : null), + h('span', { class: 'soc-preview', text: m.text })), + ago(m.createdAt)), + del); + } + + function openMessage(m) { + if (m.kind === 'alliance') { + if (m.direction === 'in' && !m.readAt) markRead([m.id]); + if (tab !== 'alliance') setTab('alliance'); else drawList(); + return; + } + const peer = Soc.peerOf(m); + openThread({ operatorId: peer.operatorId, name: peer.name }); + } + + function drawList() { + if (!listBox) return; + clear(listBox); + if (thread) return; + tabsEl.hidden = !!thread; + for (const b of tabsEl.children) b.setAttribute('aria-pressed', String(b.dataset.tab === tab)); + const inb = tabsEl.querySelector('[data-tab="inbox"] .soc-tabn'); + if (inb) { inb.textContent = badge.n ? String(badge.n) : ''; inb.hidden = !badge.n; } + const allyBtn = tabsEl.querySelector('[data-tab="alliance"]'); + if (allyBtn) allyBtn.hidden = !inAlliance(); + + if (tab === 'blocked') { drawBlocked(); return; } + const f = feeds[tab]; + + if (tab === 'inbox') { + listBox.appendChild(h('div', { class: 'soc-toolbar' }, + h('button', { class: 'chip-btn', type: 'button', 'aria-pressed': String(unreadOnly), text: App.t('soc.msg.unreadOnly'), onclick: () => { unreadOnly = !unreadOnly; feeds.inbox = blank(); loadFeed('inbox'); } }), + h('button', { class: 'btn small', type: 'button', disabled: !badge.n, text: App.t('soc.msg.markAll'), onclick: (ev) => X().guard(ev.currentTarget, async () => { + await App.api.post('/messages/read', { all: true }); + const now = App.now(); + for (const m of feeds.inbox.items) if (!m.readAt) m.readAt = now; + setUnread(0); drawList(); + }) }))); + } + if (tab === 'alliance') drawBroadcast(); + + if (f.err) { listBox.appendChild(X().errorBox(f.err, () => loadFeed(tab))); return; } + if (!f.loaded && f.loading) { listBox.appendChild(X().loading()); return; } + if (!f.items.length) { listBox.appendChild(h('p', { class: 'empty pad', text: App.t('soc.msg.empty.' + tab) })); return; } + const ul = h('ul', { class: 'soc-list' }); + for (const m of f.items) ul.appendChild(tab === 'alliance' ? feedItem(m) : msgRow(m)); + listBox.appendChild(ul); + if (f.next !== null) listBox.appendChild(h('button', { class: 'btn small wide', type: 'button', disabled: f.loading, text: App.t('soc.more'), onclick: () => loadFeed(tab, true) })); + } + + // One alliance broadcast shown in full. + function feedItem(m) { + const out = m.direction === 'out'; + const unread = !out && !m.readAt; + return h('li', { class: 'soc-item soc-feed' + (unread ? ' unread' : '') }, + h('div', { class: 'row-main' }, + h('span', { class: 'row-title' }, h('b', { text: m.from.name }), unread ? h('span', { class: 'pill accent', text: App.t('soc.msg.new') }) : null, ago(m.createdAt)), + h('p', { class: 'soc-msg-body', text: m.text })), + h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('soc.msg.delete'), onclick: (ev) => deleteMessage(m, ev.currentTarget) }, icon('x'))); + } + + let bc = null; + function drawBroadcast() { + if (!bc) { + bc = X().composer({ + label: App.t('soc.msg.toAlliance'), placeholder: App.t('soc.msg.broadcastPlaceholder'), sendLabel: App.t('soc.msg.broadcast'), rows: 2, + onSend: async (text) => { await App.api.post('/messages', { text, toAlliance: true }, { retries: 0 }); toast(App.t('soc.msg.sent'), 'ok'); feeds.alliance = blank(); loadFeed('alliance'); }, + }); + } + listBox.appendChild(h('div', { class: 'card soc-card' }, h('div', { class: 'sub', text: App.t('soc.msg.toAlliance') }), bc.el)); + } + + function drawBlocked() { + if (blocks.err) { listBox.appendChild(X().errorBox(blocks.err, loadBlocks)); return; } + if (!blocks.items) { listBox.appendChild(X().loading()); return; } + listBox.appendChild(h('p', { class: 'field-hint soc-hint', text: App.t('soc.block.hint') })); + if (!blocks.items.length) { listBox.appendChild(h('p', { class: 'empty pad', text: App.t('soc.block.none') })); return; } + const ul = h('ul', { class: 'soc-list' }); + for (const b of blocks.items) { + ul.appendChild(h('li', { class: 'soc-item' }, h('div', { class: 'row-main' }, h('b', { text: b.name }), h('span', { class: 'row-sub', text: App.t('soc.block.since', { t: App.fmt.ago(App.now() - b.createdAt) }) })), + h('button', { class: 'btn small', type: 'button', text: App.t('soc.block.unblock'), onclick: (ev) => X().guard(ev.currentTarget, async () => { + await App.api.del('/messages/blocks/' + b.operatorId); + toast(App.t('soc.block.unblocked', { name: b.name }), 'ok'); + await loadBlocks(); + }) }))); + } + listBox.appendChild(ul); + } + + // ------------------------------------------------------------------ thread view + async function openThread(peer) { + thread = { peer, items: [], next: null, loading: true, err: null }; + if (!blocked) loadBlocks(); + drawThread(); + await fetchThread(false); + } + + async function fetchThread(more) { + const t = thread; + if (!t) return; + t.loading = true; t.err = null; + try { + const q = { limit: PAGE }; + if (more && t.next) q.after = t.next; + const r = await App.api.get('/messages/thread/' + t.peer.operatorId, q); + if (thread !== t) return; + t.items = more ? Soc.mergeMessages(t.items, r.items) : r.items; + t.next = r.next; + const ids = Soc.unreadIds(t.items); + if (ids.length) markRead(ids); + } catch (e) { if (thread === t) t.err = e; } finally { + t.loading = false; + if (thread === t) drawThread(more ? undefined : 'bottom'); + } + } + + let threadComposer = null, threadFor = 0; + function drawThread(scroll) { + clear(listBox); + if (!thread) return; + tabsEl.hidden = true; + const t = thread; + const isBlocked = blocked && blocked.has(t.peer.operatorId); + const blockBtn = h('button', { class: 'btn small' + (isBlocked ? '' : ' danger'), type: 'button', text: App.t(isBlocked ? 'soc.block.unblock' : 'soc.block.go'), onclick: (ev) => X().guard(ev.currentTarget, async () => { + if (isBlocked) { await App.api.del('/messages/blocks/' + t.peer.operatorId); toast(App.t('soc.block.unblocked', { name: t.peer.name }), 'ok'); } else { await App.api.post('/messages/blocks', { operatorId: t.peer.operatorId }); toast(App.t('soc.block.blocked', { name: t.peer.name }), 'ok'); } + await loadBlocks(); drawThread(); + }) }); + listBox.appendChild(h('div', { class: 'soc-thread-head' }, + h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('common.back'), onclick: closeThread }, icon('back')), + h('h2', { class: 'soc-thread-name', text: t.peer.name }), blockBtn)); + if (isBlocked) listBox.appendChild(h('p', { class: 'field-hint soc-hint', text: App.t('soc.block.threadHint') })); + if (t.err) listBox.appendChild(X().errorBox(t.err, () => fetchThread(false))); + if (t.loading && !t.items.length) listBox.appendChild(X().loading()); + if (t.next !== null) listBox.appendChild(h('button', { class: 'btn small wide', type: 'button', disabled: t.loading, text: App.t('soc.msg.older'), onclick: () => fetchThread(true) })); + if (!t.items.length && !t.loading && !t.err) listBox.appendChild(h('p', { class: 'empty pad', text: App.t('soc.msg.thread.empty', { name: t.peer.name }) })); + const ul = h('ul', { class: 'soc-thread' }); + for (const m of Soc.chronological(t.items)) { + const out = m.direction === 'out'; + ul.appendChild(h('li', { class: 'soc-bubble ' + (out ? 'out' : 'in') + (!out && !m.readAt ? ' unread' : '') }, + h('p', { class: 'soc-msg-body', text: m.text }), + h('div', { class: 'soc-bubble-meta' }, ago(m.createdAt), h('button', { class: 'soc-del', type: 'button', 'aria-label': App.t('soc.msg.delete'), onclick: (ev) => deleteMessage(m, ev.currentTarget) }, icon('x'))))); + } + listBox.appendChild(ul); + if (!threadComposer || threadFor !== t.peer.operatorId) { + if (threadComposer) threadComposer.destroy(); + threadFor = t.peer.operatorId; + threadComposer = X().composer({ + label: App.t('soc.msg.to', { name: t.peer.name }), placeholder: App.t('soc.msg.reply'), rows: 2, + onSend: async (text) => { await App.api.post('/messages', { text, toOperatorId: t.peer.operatorId }, { retries: 0 }); feeds.sent = blank(); await fetchThread(false); }, + }); + } + listBox.appendChild(h('div', { class: 'soc-reply' }, threadComposer.el)); + if (scroll === 'bottom') requestAnimationFrame(() => { const v = document.getElementById('view'); if (v) v.scrollTop = v.scrollHeight; }); + } + + function closeThread() { + thread = null; + if (threadComposer) { threadComposer.destroy(); threadComposer = null; } + for (const k of ['inbox', 'sent']) feeds[k] = blank(); + drawList(); loadFeed(tab === 'blocked' ? 'inbox' : tab === 'alliance' ? 'alliance' : tab); + } + + // ------------------------------------------------------------------ new message sheet + function openNew(prefill) { + const nameIn = h('input', { type: 'text', maxlength: '40', autocomplete: 'off', autocapitalize: 'off', spellcheck: 'false', id: 'soc-to', value: prefill || '' }); + const hintEl = h('p', { class: 'field-hint', text: App.t('soc.msg.nameHint') }); + const comp = X().composer({ + onSend: async (text) => { + const name = Soc.cleanName(nameIn.value); + if (!name) { nameIn.focus(); throw Object.assign(new Error('name'), { code: 'validation_failed' }); } + try { await App.api.post('/messages', { text, toName: name }, { retries: 0 }); } catch (e) { + if (e.code === 'not_found') throw Object.assign(new Error(App.t('soc.msg.unknown', { name })), { code: 'x', message: App.t('soc.msg.unknown', { name }) }); + throw e; + } + toast(App.t('soc.msg.sent'), 'ok'); + sheet.close(); + feeds.sent = blank(); feeds.inbox = blank(); + if (tab === 'sent' || tab === 'inbox') loadFeed(tab); + }, + }); + const sheet = openSheet({ title: App.t('soc.msg.new.title'), icon: 'mail', closeLabel: App.t('common.close'), onClose: comp.destroy, + body: h('div', { class: 'detail' }, h('label', { class: 'field', for: 'soc-to' }, h('span', { class: 'field-lbl', text: App.t('soc.msg.recipient') }), nameIn, hintEl), comp.el) }); + setTimeout(() => (prefill ? comp.focus() : nameIn.focus()), 220); + } + + // ------------------------------------------------------------------ tabs + shell + function setTab(t) { + if (t === tab && !thread) return; + tab = t; thread = null; + if (threadComposer) { threadComposer.destroy(); threadComposer = null; } + if (t === 'blocked') { if (!blocks.items) loadBlocks(); } else if (!feeds[t].loaded) loadFeed(t); else drawList(); + drawList(); + } + + function startTick() { + if (offTick) offTick(); + offTick = App.onTick(() => { + const now = App.now(); + for (const el of listBox.querySelectorAll('.when')) { const s = App.fmt.ago(now - Number(el.dataset.at)); if (el.textContent !== s) el.textContent = s; } + }); + } + + App.registerScreen({ + id: 'messages', titleKey: 'screen.messages', navKey: 'nav.messages', icon: 'mail', hud: false, navGroup: 'more', + render(container) { + box = container; + const tabs = [['inbox', 'soc.msg.tab.inbox'], ['sent', 'soc.msg.tab.sent'], ['alliance', 'soc.msg.tab.alliance'], ['blocked', 'soc.msg.tab.blocked']]; + tabsEl = h('div', { class: 'seg soc-tabs soc-tabs4', role: 'group', 'aria-label': App.t('soc.tab.label') }, + tabs.map(([id, key]) => h('button', { class: 'seg-btn', type: 'button', dataset: { tab: id }, 'aria-pressed': String(tab === id), onclick: () => setTab(id) }, + h('span', { class: 'soc-tabt', text: App.t(key) }), id === 'inbox' ? h('span', { class: 'soc-tabn', hidden: true }) : null))); + listBox = h('div', { class: 'soc-listbox' }); + box.appendChild(h('div', { class: 'page soc-page' }, + h('div', { class: 'card-head page-head' }, h('h1', { id: 'soc-msg-h', text: App.t('screen.messages') }), + h('div', { class: 'soc-head-actions' }, + h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('common.retry'), onclick: () => { if (thread) fetchThread(false); else if (tab === 'blocked') loadBlocks(); else { feeds[tab] = blank(); loadFeed(tab); } } }, icon('refresh')), + h('button', { class: 'btn small primary', type: 'button', onclick: () => openNew() }, icon('pencil'), App.t('soc.msg.new.go')))), + tabsEl, listBox)); + }, + onShow(params) { + gen++; + box.querySelector('#soc-msg-h').textContent = App.t('screen.messages'); + const labels = { inbox: 'soc.msg.tab.inbox', sent: 'soc.msg.tab.sent', alliance: 'soc.msg.tab.alliance', blocked: 'soc.msg.tab.blocked' }; + for (const b of tabsEl.children) b.querySelector('.soc-tabt').textContent = App.t(labels[b.dataset.tab]); + bc = null; + if (!inAlliance() && tab === 'alliance') tab = 'inbox'; + if (params && params.to) { tab = 'inbox'; openNew(params.to); } + if (thread) drawThread(); else { drawList(); if (tab === 'blocked') loadBlocks(); else loadFeed(tab); } + startTick(); + pollUnread(); + }, + onHide() { if (offTick) { offTick(); offTick = null; } gen++; }, + }); +}()); diff --git a/public/js/screens/movements.js b/public/js/screens/movements.js new file mode 100644 index 0000000..642492d --- /dev/null +++ b/public/js/screens/movements.js @@ -0,0 +1,151 @@ +'use strict'; +/* + * Movements: what is on the wire right now. Incoming movements of other operators come first and are deliberately loud + * (the server hides their type and units: origin and ETA only); your own outgoing legs and returns follow, with live + * countdowns and a Recall button during the first 90 seconds. Also registers the incoming-warning banner on the POP screen. + * Data comes from App.mil.moves (milstate.js), which push, the poll and the ticker keep current. + */ +(function () { + const { h, clear, icon, toast } = UI; + const Mil = UpstreamMil; + + let box, listEl, visible = false, offTick = null, dirty = true; + + // ------------------------------------------------------------------ rows + function incomingRow(m) { + const from = m.from || {}; + const owner = from.owner; + return h('li', { class: 'mil-row incoming' }, + h('span', { class: 'row-ic bad' }, icon('alert')), + h('span', { class: 'row-main' }, + h('span', { class: 'row-title' }, h('b', { text: App.t('mov.incoming.title', { town: (m.to && m.to.name) || '?' }) })), + h('span', { class: 'row-sub wrap' }, owner ? App.t('mov.incoming.from', { operator: owner.name }) + ' · ' : '', mil().endLink(from)), + h('span', { class: 'row-sub wrap', text: App.t('mov.incoming.hint') })), + h('span', { class: 'mil-when' }, mil().countdown(m.arriveAt, { cls: 'big' }), h('small', { text: mil().clockTime(m.arriveAt) }))); + } + + const mil = () => App.mil; + + function outgoingRow(m, now) { + const type = m.type; + const sub = []; + if (m.units && Mil.sumUnits(m.units) > 0) sub.push(h('span', { class: 'row-sub wrap', text: mil().unitsText(m.units) })); + if (m.cargo && Object.keys(m.cargo).some((r) => m.cargo[r] > 0)) sub.push(mil().resChips(m.cargo)); + if (m.target) sub.push(h('span', { class: 'row-sub wrap', text: App.t('mov.target', { name: App.buildingName(m.target) }) })); + const recallable = m.recallableUntil && m.recallableUntil > now; + const bar = h('i'); + const row = h('li', { class: 'mil-row out type-' + type, dataset: { id: m.id } }, + h('span', { class: 'row-ic' }, icon(Mil.TYPE_ICON[type] || 'move')), + h('span', { class: 'row-main' }, + h('span', { class: 'row-title' }, h('b', { text: mil().typeLabel(type) })), + h('span', { class: 'row-sub wrap' }, mil().endLink(m.from), h('span', { class: 'arrow', 'aria-hidden': 'true' }, icon('move')), mil().endLink(m.to)), + sub, + h('span', { class: 'bar mil-bar', 'aria-hidden': 'true' }, bar), + recallable ? h('button', { class: 'btn small danger mil-recall', type: 'button', dataset: { until: String(m.recallableUntil), id: String(m.id) }, onclick: (ev) => recall(m, ev.currentTarget) }, + icon('return'), h('span', { text: App.t('mov.recall') }), mil().countdown(m.recallableUntil)) : null), + h('span', { class: 'mil-when' }, mil().countdown(m.arriveAt), h('small', { text: mil().clockTime(m.arriveAt) }))); + row._bar = bar; row._m = m; + return row; + } + + async function recall(m, btn) { + btn.disabled = true; + try { + await App.api.post('/movements/' + m.id + '/recall', {}, { intent: 'recall:' + m.id }); + toast(App.t('mov.recalled'), 'ok'); + } catch (e) { + toast(App.errMsg(e), 'error'); + } + App.refreshMovements().catch(() => {}); + App.refreshTown().catch(() => {}); + } + + // ------------------------------------------------------------------ screen + function draw() { + dirty = false; + clear(listEl); + const mv = mil().moves, now = App.now(); + const inc = mv.incoming.slice().sort((a, b) => a.arriveAt - b.arriveAt); + const out = mv.outgoing.slice().sort((a, b) => a.arriveAt - b.arriveAt); + if (inc.length) { + listEl.appendChild(h('section', { class: 'card warn-card', role: 'alert' }, + h('div', { class: 'card-head' }, h('h2', null, icon('alert'), App.t('mov.incoming.head', { n: inc.length }))), + h('ul', { class: 'mil-list' }, inc.map(incomingRow)))); + } + const allied = (mv.alliedIncoming || []).slice().sort((a, b) => a.arriveAt - b.arriveAt); + if (allied.length) { + listEl.appendChild(h('section', { class: 'card' }, + h('div', { class: 'card-head' }, h('h2', null, icon('handshake'), App.t('mov.allied.head'))), + h('ul', { class: 'mil-list' }, allied.map((m) => h('li', { class: 'mil-row' }, + h('span', { class: 'row-ic' }, icon('shield')), + h('span', { class: 'row-main' }, + h('span', { class: 'row-title' }, h('b', { text: App.t('mov.allied.title', { operator: m.toOperator ? m.toOperator.name : '?', town: (m.to && m.to.name) || '?' }) })), + h('span', { class: 'row-sub wrap' }, m.from && m.from.owner ? App.t('mov.incoming.from', { operator: m.from.owner.name }) + ' · ' : '', mil().endLink(m.from))), + h('span', { class: 'mil-when' }, mil().countdown(m.arriveAt), h('small', { text: mil().clockTime(m.arriveAt) }))))))); + } + listEl.appendChild(h('section', { class: 'card' }, + h('div', { class: 'card-head' }, h('h2', null, icon('move'), App.t('mov.outgoing.head')), h('span', { class: 'pill', text: String(out.length) })), + out.length ? h('ul', { class: 'mil-list' }, out.map((m) => outgoingRow(m, now))) : h('p', { class: 'empty', text: mv.loaded ? App.t('mov.empty') : App.t('common.loading') }))); + tick(now); + } + + function tick(now) { + if (!listEl) return; + for (const row of listEl.querySelectorAll('li.out')) { + if (!row._m) continue; + row._bar.style.setProperty('--p', String(mil().progress(row._m, now))); + } + for (const b of listEl.querySelectorAll('.mil-recall')) if (Number(b.dataset.until) <= now) b.remove(); + } + + App.registerScreen({ + id: 'movements', titleKey: 'screen.movements', navKey: 'nav.movements', icon: 'move', hud: false, + render(container) { + box = container; + listEl = h('div', { class: 'mil-sections' }); + box.appendChild(h('div', { class: 'page' }, + h('div', { class: 'card-head page-head' }, h('h1', { text: App.t('screen.movements') }), + h('div', { class: 'head-actions' }, + h('button', { class: 'btn small primary', type: 'button', onclick: () => App.openSend({}) }, icon('target'), App.t('mov.send')), + h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('common.retry'), onclick: () => App.refreshMovements().catch((e) => toast(App.errMsg(e), 'error')) }, icon('refresh')))), + listEl)); + App.on('movements', () => { if (visible) draw(); else dirty = true; }); + App.on('lang', () => { if (box) box.querySelector('h1').textContent = App.t('screen.movements'); }); + }, + onShow() { + visible = true; + box.querySelector('h1').textContent = App.t('screen.movements'); + draw(); + App.refreshMovements().catch(() => {}); + if (offTick) offTick(); + offTick = App.onTick(tick); + }, + onHide() { visible = false; if (offTick) offTick(); offTick = null; }, + }); + + // ------------------------------------------------------------------ incoming banner on the POP screen + function fillBanner(el) { + clear(el); + const inc = mil().moves.incoming.slice().sort((a, b) => a.arriveAt - b.arriveAt); + el.hidden = !inc.length; + if (!inc.length) return; + const next = inc[0]; + el.appendChild(h('div', { class: 'row-ic bad' }, icon('alert'))); + el.appendChild(h('div', { class: 'row-main' }, + h('b', { text: App.t('mov.banner.title', { n: inc.length }) }), + h('span', { class: 'row-sub wrap' }, App.t('mov.banner.next', { town: (next.to && next.to.name) || '?', operator: next.from && next.from.owner ? next.from.owner.name : '?' }) + ' '), + h('span', { class: 'row-sub wrap' }, App.t('mov.banner.in') + ' ', mil().countdown(next.arriveAt)))); + el.appendChild(h('button', { class: 'btn small', type: 'button', onclick: () => App.go('movements') }, App.t('mov.banner.details'))); + } + + App.popSections.push({ + slot: 'top', + render() { + const el = h('section', { class: 'card warn-card mil-banner', role: 'alert', 'aria-live': 'assertive' }); + fillBanner(el); + return el; + }, + }); + App.on('movements', () => { for (const el of document.querySelectorAll('.mil-banner')) fillBanner(el); }); + App.on('lang', () => { for (const el of document.querySelectorAll('.mil-banner')) fillBanner(el); }); +}()); diff --git a/public/js/screens/pop.js b/public/js/screens/pop.js index 2ee59fe..ff4857e 100644 --- a/public/js/screens/pop.js +++ b/public/js/screens/pop.js @@ -275,10 +275,7 @@ function header(t) { const st = App.state; const bonus = D.RESOURCES.filter((r) => (t.bonus && t.bonus[r] > 0)).map((r) => h('span', { class: 'pill res-' + r }, icon(r), '+' + Math.round(t.bonus[r] * 100) + '% ' + App.resName(r))); - const title = st.towns.length > 1 - ? h('select', { class: 'town-select', 'aria-label': App.t('screen.pop'), onchange: (e) => App.setTown(Number(e.target.value)) }, - st.towns.map((x) => h('option', { value: x.id, selected: x.id === t.id, text: x.name }))) - : h('h1', { class: 'town-name', text: t.name }); + const title = h('h1', { class: 'town-name', text: t.name }); // switching POPs lives in the resource bar (main.js) return h('section', { class: 'card pop-head' }, h('div', { class: 'pop-title' }, title, h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('pop.rename'), onclick: openRename }, icon('pencil'))), @@ -376,8 +373,12 @@ const t = td(); if (!App.state.townId) { box.appendChild(h('p', { class: 'empty pad', text: App.t('pop.noTown') })); return; } if (!t) { box.appendChild(h('div', { class: 'boot' }, h('div', { class: 'spinner', 'aria-hidden': 'true' }), h('p', { text: App.t('common.loading') }))); return; } + // other screens add cards here through App.popSections (military: incoming banner on top, expansion below the power card) + const extra = (slot) => (App.popSections || []).filter((s) => s.slot === slot).map((s) => { try { return s.render(t); } catch (e) { console.error(e); return null; } }); + const tops = extra('top'); + if (tops.some(Boolean)) box.appendChild(h('div', { class: 'pop-top' }, tops)); box.appendChild(h('div', { class: 'cols' }, - h('div', { class: 'col' }, header(t), queueCard(t), powerCard()), + h('div', { class: 'col' }, header(t), queueCard(t), powerCard(), extra('main')), h('div', { class: 'col' }, fieldsCard(t), infraCard(t)))); tick(App.now()); } @@ -482,6 +483,7 @@ App.on('town', onTown); App.on('session', () => { dirty = true; prevQueue = null; }); App.on('townchange', () => { dirty = true; if (visible) draw(); }); + App.on('towns', () => { dirty = true; if (visible) draw(); }); }, onShow() { visible = true; diff --git a/public/js/screens/rankings.js b/public/js/screens/rankings.js new file mode 100644 index 0000000..832972e --- /dev/null +++ b/public/js/screens/rankings.js @@ -0,0 +1,146 @@ +'use strict'; +/* + * Rankings: operators by footprint, alliances by summed footprint, battle points (attack / defense / total). The server + * returns `you` (your own rank, even when it is not on the loaded page) and a rank-offset cursor (`next`). Rows of your own + * operator or alliance are highlighted. Names are set with textContent only. + */ +(function () { + const { h, clear, icon, openSheet } = UI; + const Soc = UpstreamSocial; + const PAGE = 50; + const X = () => window.SocUI; + + let box, listBox, tabsEl, subEl; + let tab = 'operators', by = 'attack'; + const sets = {}; + let gen = 0; + + const keyOf = () => (tab === 'battles' ? 'battles:' + by : tab); + const cur = () => sets[keyOf()] || (sets[keyOf()] = { items: [], next: null, total: 0, you: null, available: true, loaded: false, loading: false, err: null }); + const path = () => '/rankings/' + tab; + + async function load(more) { + const key = keyOf(), s = cur(); + if (s.loading) return; + s.loading = true; s.err = null; + const my = gen; + if (key === keyOf()) draw(); + try { + const q = { limit: PAGE }; + if (more && s.next !== null) q.after = s.next; + if (tab === 'battles') q.by = by; + const r = await App.api.get(path(), q); + s.items = more ? Soc.mergeRanks(s.items, r.items) : r.items; + s.next = r.next; s.total = r.total; s.you = r.you; s.loaded = true; + if (typeof r.available === 'boolean') s.available = r.available; + } catch (e) { s.err = e; } finally { + s.loading = false; + if (my === gen && key === keyOf()) draw(); + } + } + + const num = (n) => App.fmt.num(Math.round(n)); + + // One row: rank, name (+ tag), the value columns. `main` is the metric shown big, `sub` the small line. + function row(r) { + const you = Soc.isYou(tab, r, youRow()); + let name, sub, val, tap; + if (tab === 'operators') { + name = r.name; sub = (r.allianceTag ? '[' + r.allianceTag + '] ' : '') + App.t('soc.rank.pops', { n: r.towns }); val = App.fmt.dec(r.footprint); + tap = () => openOperator(r); + } else if (tab === 'alliances') { + name = r.name; sub = '[' + r.tag + '] ' + App.t('soc.rank.members', { n: r.members }) + ' · ' + App.t('soc.rank.pops', { n: r.towns }); val = App.fmt.dec(r.footprint); + tap = () => X().openProfile(r.allianceId, { name: r.name }); + } else { + name = r.name; sub = (r.allianceTag ? '[' + r.allianceTag + '] ' : '') + App.t('soc.rank.att', { n: num(r.attackPoints) }) + ' · ' + App.t('soc.rank.def', { n: num(r.defensePoints) }); + val = num(Soc.battlePoints(r, by)); + tap = () => openOperator(r); + } + return h('li', null, h('button', { class: 'soc-rank' + (you ? ' you' : ''), type: 'button', onclick: tap, 'aria-current': you ? 'true' : null }, + h('span', { class: 'soc-rk mono', text: '#' + r.rank }), + h('span', { class: 'row-main' }, h('span', { class: 'row-title' }, h('b', { text: name }), you ? h('span', { class: 'pill accent', text: App.t('soc.you') }) : null), h('span', { class: 'row-sub', text: sub })), + h('span', { class: 'soc-val mono', text: val }))); + } + + const youRow = () => cur().you; + + function openOperator(r) { + const me = X().myOperatorId(); + const kv = (k, v) => h('div', { class: 'kv' }, h('span', { class: 'k', text: k }), h('span', { class: 'v', text: v })); + const body = h('div', { class: 'detail' }, + h('div', { class: 'pill-row' }, h('span', { class: 'pill soc-tag mono', text: '#' + r.rank }), r.allianceTag ? X().tagPill(r.allianceTag) : null, r.asNumber ? h('span', { class: 'pill mono', text: UpstreamI18n.fmtAs(r.asNumber) }) : null), + h('div', null, + r.footprint !== undefined ? kv(App.t('soc.footprint'), App.fmt.dec(r.footprint)) : null, + r.towns !== undefined ? kv(App.t('soc.member.pops'), String(r.towns)) : null, + r.attackPoints !== undefined ? kv(App.t('soc.rank.attack'), num(r.attackPoints)) : null, + r.defensePoints !== undefined ? kv(App.t('soc.rank.defense'), num(r.defensePoints)) : null)); + const sheet = openSheet({ title: r.name, icon: 'users', closeLabel: App.t('common.close'), body }); + if (r.allianceId) body.appendChild(h('button', { class: 'btn wide', type: 'button', onclick: () => { sheet.close(); X().openProfile(r.allianceId, { name: r.allianceTag }); } }, icon('users'), App.t('soc.rank.viewAlliance'))); + if (r.operatorId !== me) body.appendChild(h('button', { class: 'btn primary wide', type: 'button', onclick: () => { sheet.close(); X().openCompose({ operator: { operatorId: r.operatorId, name: r.name } }); } }, icon('mail'), App.t('soc.member.message'))); + } + + function draw() { + if (!listBox) return; + clear(listBox); + for (const b of tabsEl.children) b.setAttribute('aria-pressed', String(b.dataset.tab === tab)); + subEl.hidden = tab !== 'battles'; + for (const b of subEl.children) b.setAttribute('aria-pressed', String(b.dataset.by === by)); + const s = cur(); + if (s.err) { listBox.appendChild(X().errorBox(s.err, () => load(false))); return; } + if (!s.loaded) { listBox.appendChild(X().loading()); return; } + if (tab === 'battles' && !s.available) { listBox.appendChild(h('p', { class: 'empty pad', text: App.t('soc.rank.unavailable') })); return; } + + if (s.you) { + const y = s.you; + const inList = s.items.some((r) => r.rank === y.rank); + listBox.appendChild(h('div', { class: 'card soc-card soc-yourank' }, + h('span', { class: 'soc-yr-n mono', text: '#' + y.rank }), + h('span', { class: 'row-main' }, h('b', { text: App.t('soc.rank.yours') }), + h('span', { class: 'row-sub', text: App.t('soc.rank.of', { n: s.total }) + (tab === 'battles' ? ' · ' + num(Soc.battlePoints(y, by)) : ' · ' + App.fmt.dec(y.footprint)) })), + inList ? null : h('span', { class: 'pill dim', text: App.t('soc.rank.notShown') }))); + } else if (tab === 'alliances') { + listBox.appendChild(h('p', { class: 'field-hint soc-hint', text: App.t('soc.rank.noAlliance') })); + } else if (tab === 'battles') { + listBox.appendChild(h('p', { class: 'field-hint soc-hint', text: App.t('soc.rank.noPoints') })); + } + if (!s.items.length) { listBox.appendChild(h('p', { class: 'empty pad', text: App.t(tab === 'battles' ? 'soc.rank.noBattles' : 'soc.rank.empty') })); return; } + const ol = h('ol', { class: 'soc-ranklist' }); + for (const r of s.items) ol.appendChild(row(r)); + listBox.appendChild(ol); + if (s.next !== null) listBox.appendChild(h('button', { class: 'btn small wide', type: 'button', disabled: s.loading, text: App.t('soc.more') + ' (' + s.items.length + '/' + s.total + ')', onclick: () => load(true) })); + } + + function setTab(t) { + tab = t; + draw(); + if (!cur().loaded) load(false); + } + + App.registerScreen({ + id: 'rankings', titleKey: 'screen.rankings', navKey: 'nav.rankings', icon: 'trophy', hud: false, navGroup: 'more', + render(container) { + box = container; + const tabs = [['operators', 'soc.rank.tab.operators'], ['alliances', 'soc.rank.tab.alliances'], ['battles', 'soc.rank.tab.battles']]; + tabsEl = h('div', { class: 'seg soc-tabs', role: 'group', 'aria-label': App.t('soc.tab.label') }, + tabs.map(([id, key]) => h('button', { class: 'seg-btn', type: 'button', dataset: { tab: id }, 'aria-pressed': String(tab === id), text: App.t(key), onclick: () => setTab(id) }))); + subEl = h('div', { class: 'seg soc-subtabs', role: 'group', 'aria-label': App.t('soc.rank.by'), hidden: true }, + ['attack', 'defense', 'total'].map((k) => h('button', { class: 'chip-btn', type: 'button', dataset: { by: k }, 'aria-pressed': String(by === k), text: App.t('soc.rank.by.' + k), onclick: () => { by = k; draw(); if (!cur().loaded) load(false); } }))); + listBox = h('div', { class: 'soc-listbox' }); + box.appendChild(h('div', { class: 'page soc-page' }, + h('div', { class: 'card-head page-head' }, h('h1', { id: 'soc-rank-h', text: App.t('screen.rankings') }), + h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('common.retry'), onclick: () => { delete sets[keyOf()]; load(false); } }, icon('refresh'))), + tabsEl, subEl, listBox)); + App.on('session', () => { for (const k of Object.keys(sets)) delete sets[k]; }); + }, + onShow() { + gen++; + box.querySelector('#soc-rank-h').textContent = App.t('screen.rankings'); + const labels = { operators: 'soc.rank.tab.operators', alliances: 'soc.rank.tab.alliances', battles: 'soc.rank.tab.battles' }; + for (const b of tabsEl.children) b.textContent = App.t(labels[b.dataset.tab]); + for (const b of subEl.children) b.textContent = App.t('soc.rank.by.' + b.dataset.by); + draw(); + load(false); // rankings move: always refresh the first page when the screen opens + }, + onHide() { gen++; }, + }); +}()); diff --git a/public/js/screens/reports.js b/public/js/screens/reports.js new file mode 100644 index 0000000..f130865 --- /dev/null +++ b/public/js/screens/reports.js @@ -0,0 +1,316 @@ +'use strict'; +/* + * Reports: newest first, cursor-paginated (GET /reports?after=), unread highlighted, a detail sheet per report + * (GET /reports/:id, then POST /reports/:id/read). Detail layouts exist for battle (raid/attack/takeover), scan, + * scan_detected, incumbent, settle, reinforce and movement_failed; coordinates are links that jump to the map. + * `data` differs by report type AND by the recipient's role (attacker / defender / reinforcer / sender / target). + */ +(function () { + const { h, clear, icon, toast, openSheet } = UI; + const D = UpstreamData; + const Mil = UpstreamMil; + const mil = () => App.mil; + const num = (n) => App.fmt.num(n); + const PAGE = 25; + + let box, listEl, moreBtn, statusEl, items = [], next = null, loading = false, visible = false, offAgo = null; + + // ------------------------------------------------------------------ list rows + const nameOf = (o) => (o && o.name) || '?'; + const townOf = (t) => (t ? t.name : '?'); + + // { icon, title, sub, tone } for the list + function describe(it) { + const s = it.summary || {}; + switch (it.type) { + case 'raid': case 'attack': case 'takeover': { + const res = Mil.perspective(it.role, s.outcome); + const mine = it.role === 'attacker'; + const title = mil().reportTypeLabel(it.type) + ': ' + townOf(s.target); + const sub = mine ? App.t('rep.sub.you_vs', { name: nameOf(s.defender) }) : App.t('rep.sub.by', { name: nameOf(s.attacker) }); + return { icon: Mil.TYPE_ICON[it.type], title, sub: sub + (s.captured ? ' · ' + App.t('rep.captured') : ''), tone: res === 'victory' ? 'good' : 'bad', badge: App.t('rep.' + res) }; + } + case 'scan': { + const where = s.target ? townOf(s.target) : (s.site ? s.site.x + ', ' + s.site.y : '?'); + return { icon: 'eye', title: App.t('rep.scan.title', { where }), sub: s.success ? App.t('rep.scan.ok') : App.t('rep.scan.failed'), tone: s.success ? 'good' : 'bad' }; + } + case 'scan_detected': + return { icon: 'eye', title: App.t('rep.detected.title', { town: townOf(s.target) }), sub: s.identityRevealed && s.by ? App.t('rep.sub.by', { name: nameOf(s.by) }) : App.t('rep.detected.unknown'), tone: 'warn' }; + case 'incumbent': + return { icon: 'b-core_router', title: App.t('rep.incumbent.title', { x: s.site ? s.site.x : '?', y: s.site ? s.site.y : '?' }), sub: '', tone: s.outcome === 'attacker_won' ? 'good' : 'bad', badge: s.outcome === 'attacker_won' ? App.t('rep.victory') : App.t('rep.defeat') }; + case 'settle': + return { icon: 'flag', title: App.t('rep.settle.title', { name: s.town ? s.town.name : '?' }), sub: '', tone: 'good' }; + case 'reinforce': + return { icon: 'shield', title: it.role === 'sender' ? App.t('rep.reinforce.sender', { town: townOf(s.host) }) : App.t('rep.reinforce.target', { town: townOf(s.host) }), sub: mil().unitsText(s.units), tone: 'neutral' }; + case 'movement_failed': + return { icon: 'alert', title: App.t('rep.failed.title', { type: mil().typeLabel(s.movementType) }), sub: reasonText(s.reason), tone: 'bad' }; + default: + return { icon: 'report', title: mil().reportTypeLabel(it.type), sub: '', tone: 'neutral' }; + } + } + + function reasonText(code) { + if (!code) return ''; + if (UpstreamI18n.strings.en['rep.reason.' + code]) return App.t('rep.reason.' + code); + if (UpstreamI18n.strings.en['err.' + code]) return App.t('err.' + code); + return code; + } + + function row(it) { + const d = describe(it); + return h('li', null, h('button', { class: 'alert rep tone-' + d.tone + (it.read ? '' : ' new'), type: 'button', dataset: { id: String(it.id) }, onclick: () => openReport(it.id) }, + h('span', { class: 'row-ic' }, icon(d.icon)), + h('span', { class: 'row-main' }, + h('span', { class: 'row-title' }, h('b', { text: d.title }), d.badge ? h('span', { class: 'pill ' + (d.tone === 'good' ? 'green' : 'amber'), text: d.badge }) : null, it.read ? null : h('span', { class: 'pill accent', text: App.t('alerts.new') })), + d.sub ? h('span', { class: 'row-sub', text: d.sub }) : null), + h('span', { class: 'when mono', dataset: { at: String(it.createdAt) }, text: App.fmt.ago(App.now() - it.createdAt) }))); + } + + function draw() { + clear(listEl); + if (!items.length) { listEl.appendChild(h('li', null, h('p', { class: 'empty pad', text: loading ? App.t('common.loading') : App.t('rep.empty') }))); } + for (const it of items) listEl.appendChild(row(it)); + moreBtn.hidden = next === null; + } + + async function load(more) { + if (loading) return; + loading = true; statusEl.hidden = true; + try { + const r = await App.api.get('/reports', { limit: PAGE, after: more ? next : undefined }); + items = more ? items.concat(r.items.filter((x) => !items.some((y) => y.id === x.id))) : r.items; + next = r.next; + mil().reportsUnread = r.unread; + App.setBadge('reports', r.unread, 'info'); + } catch (e) { + statusEl.textContent = App.errMsg(e); statusEl.hidden = false; + } finally { loading = false; } + draw(); + } + + async function markAll() { + try { + await App.api.post('/reports/read-all', {}, { intent: 'reports:read-all' }); + for (const it of items) it.read = true; + App.setBadge('reports', 0, 'info'); + draw(); + } catch (e) { toast(App.errMsg(e), 'error'); } + } + + // ------------------------------------------------------------------ detail pieces + const sec = (title, ...kids) => h('section', { class: 'rep-sec' }, h('h3', { class: 'sub', text: title }), kids); + const kv = (k, v) => h('div', { class: 'kv' }, h('span', { class: 'k', text: k }), h('span', { class: 'v' }, v)); + + function unitsTable(sent, lost, survivors) { + const ids = D.UNIT_ORDER.filter((u) => (sent && sent[u]) || (lost && lost[u]) || (survivors && survivors[u])); + if (!ids.length) return h('p', { class: 'empty', text: App.t('rep.noUnits') }); + return h('table', { class: 'mil-table' }, + h('thead', null, h('tr', null, h('th', { text: '' }), h('th', { text: App.t('rep.sent') }), h('th', { text: App.t('rep.lost') }), h('th', { text: App.t('rep.left') }))), + h('tbody', null, ids.map((u) => h('tr', null, + h('td', { text: mil().unitName(u) }), + h('td', { class: 'mono', text: num((sent && sent[u]) || 0) }), + h('td', { class: 'mono' + (lost && lost[u] ? ' bad' : ''), text: num((lost && lost[u]) || 0) }), + h('td', { class: 'mono', text: num((survivors && survivors[u]) || 0) }))))); + } + + const party = (label, operator, town) => kv(label, h('span', { class: 'rep-party' }, + h('b', { text: operator ? operator.name : '?' }), operator && operator.asNumber ? h('small', { class: 'dimmer', text: ' ' + UpstreamI18n.fmtAs(operator.asNumber) }) : null, + town ? mil().endLink(town) : null)); + + function verdict(role, outcome) { + const res = Mil.perspective(role, outcome); + return h('div', { class: 'rep-verdict ' + res }, icon(res === 'victory' ? 'check' : 'alert'), h('b', { text: App.t('rep.' + res) })); + } + + function combatBody(r) { + const d = r.data, out = []; + out.push(verdict(r.role, d.outcome)); + out.push(h('p', { class: 'row-sub', text: App.t('rep.arrived', { t: mil().dayTime(d.arrivedAt) }) + ' · ' + mil().reportTypeLabel(d.type) })); + out.push(party(App.t('rep.attacker'), d.attacker.operator, d.attacker.town)); + out.push(party(App.t('rep.defender'), d.defender.operator, d.defender.town)); + const p = d.power || {}; + out.push(sec(App.t('rep.power'), + kv(App.t('rep.power.attack'), h('b', { class: 'mono', text: num(p.attack || 0) })), + kv(App.t('rep.power.defence'), h('b', { class: 'mono', text: num(p.defence || 0) })), + p.firewallLevel !== undefined ? kv(App.t('rep.power.firewall'), h('span', { class: 'mono', text: p.firewallLevel + (p.effectiveFirewall !== undefined && p.effectiveFirewall !== p.firewallLevel ? ' → ' + App.fmt.dec(p.effectiveFirewall) : '') })) : null)); + out.push(sec(App.t('rep.attackerUnits'), unitsTable(d.attacker.units.sent, d.attacker.units.lost, d.attacker.units.survivors))); + const groups = (d.defender.groups || []); + out.push(sec(App.t('rep.defenderUnits'), groups.length ? groups.map((g) => h('div', { class: 'rep-group' }, + h('p', { class: 'row-sub wrap' }, g.ownerTownId === (d.defender.town && d.defender.town.id) ? App.t('rep.group.home') : App.t('rep.group.reinf', { town: '#' + g.ownerTownId }), g.offline ? ' · ' + App.t('rep.group.offline') : ''), + unitsTable(g.sent, g.lost, g.survivors))) : h('p', { class: 'empty', text: App.t('rep.noUnits') }))); + if (d.loot && D.RESOURCES.some((x) => d.loot[x])) { + out.push(sec(App.t('rep.loot'), mil().resChips(d.loot, true), d.cacheHidden ? h('p', { class: 'row-sub', text: App.t('rep.cache', { p: Math.round(d.cacheHidden * 100) }) }) : null)); + } + if (d.siege) out.push(sec(App.t('rep.siege'), h('p', { text: App.t('rep.siege.line', { name: App.buildingName(d.siege.type), a: d.siege.from, b: d.siege.to }) }))); + if (d.takeover) { + const t = d.takeover; + const lines = []; + if (t.blocked) lines.push(h('p', { class: 'reason', text: App.t('rep.takeover.blocked.' + t.blocked) })); + else { + lines.push(kv(App.t('rep.takeover.loyalty'), h('b', { class: 'mono', text: num(t.loyaltyBefore) + ' → ' + num(t.loyaltyAfter) + ' (−' + num(t.drop) + ')' }))); + if (t.capital) lines.push(h('p', { class: 'row-sub wrap', text: App.t('rep.takeover.capital') })); + } + if (d.capturedTown) lines.push(h('p', { class: 'good', text: App.t('rep.takeover.captured') })); + out.push(sec(App.t('rep.takeover'), lines)); + } + return out; + } + + function scanBody(r) { + const d = r.data, out = []; + out.push(h('div', { class: 'rep-verdict ' + (d.success ? 'victory' : 'defeat') }, icon(d.success ? 'eye' : 'alert'), h('b', { text: d.success ? App.t('rep.scan.ok') : App.t('rep.scan.failed') }))); + if (d.site) out.push(kv(App.t('rep.site'), mil().coordLink(d.site.x, d.site.y))); + if (d.target) out.push(party(App.t('rep.defender'), d.operator, d.target)); + if (d.strength) out.push(kv(App.t('rep.scan.strength'), h('span', { class: 'mono', text: App.fmt.dec(d.strength.attacker) + ' vs ' + App.fmt.dec(d.strength.defender) }))); + out.push(sec(App.t('rep.scanners'), unitsTable(d.scanners && d.scanners.sent, d.scanners && d.scanners.lost, d.scanners && d.scanners.survivors))); + const intel = d.intel; + if (!intel) { out.push(h('p', { class: 'reason', text: App.t('rep.scan.noIntel') })); return out; } + if (d.site) { // incumbent site + out.push(sec(App.t('rep.intel'), + kv(App.t('rep.power.defence'), h('b', { class: 'mono', text: num(intel.defence) })), + intel.bonusAvailable ? h('p', { class: 'row-sub wrap', text: App.t('rep.incumbent.bonus', { n: num(intel.hardwareBonus) }) }) : h('p', { class: 'row-sub wrap', text: App.t('rep.incumbent.taken') }))); + return out; + } + out.push(sec(App.t('rep.intel.resources'), mil().resChips(intel.resources))); + out.push(sec(App.t('rep.intel.units'), + !intel.online ? h('p', { class: 'reason', text: App.t('rep.intel.offline') }) : null, + unitsTable(intel.units.home, {}, intel.units.home), + (intel.units.stationed || []).map((g) => h('div', { class: 'rep-group' }, h('p', { class: 'row-sub wrap', text: App.t('rep.group.reinf', { town: '#' + g.ownerTownId }) }), h('p', { text: mil().unitsText(g.units) }))))); + if (intel.buildings) { + out.push(sec(App.t('rep.intel.buildings'), + h('ul', { class: 'rep-buildings' }, intel.buildings.filter((b) => b.level > 0).map((b) => h('li', null, h('span', { text: App.buildingName(b.type) }), h('b', { class: 'mono', text: String(b.level) })))))); + } + if (intel.loyalty !== undefined) out.push(kv(App.t('pop.loyalty'), h('b', { class: 'mono', text: num(intel.loyalty) }))); + if (intel.outgoing && intel.outgoing.length) { + out.push(sec(App.t('rep.intel.outgoing'), h('ul', { class: 'rep-buildings' }, intel.outgoing.map((m) => h('li', null, h('span', { text: mil().typeLabel(m.type) }), mil().coordLink(m.to.x, m.to.y), h('small', { class: 'dimmer', text: mil().clockTime(m.arriveAt) })))))); + } + return out; + } + + function detectedBody(r) { + const d = r.data, out = []; + out.push(h('div', { class: 'rep-verdict defeat' }, icon('eye'), h('b', { text: App.t('rep.detected.title', { town: townOf(d.target) }) }))); + if (d.target) out.push(kv(App.t('rep.target'), mil().endLink(d.target))); + if (d.identityRevealed && d.by) out.push(party(App.t('rep.scannedBy'), d.by.operator, d.by.town)); + else out.push(h('p', { class: 'row-sub wrap', text: App.t('rep.detected.unknown') })); + return out; + } + + function incumbentBody(r) { + const d = r.data, out = []; + out.push(verdict('attacker', d.outcome)); + out.push(kv(App.t('rep.site'), mil().coordLink(d.site.x, d.site.y))); + if (d.origin) out.push(kv(App.t('rep.from'), mil().endLink(d.origin))); + out.push(sec(App.t('rep.power'), kv(App.t('rep.power.attack'), h('b', { class: 'mono', text: num(d.power.attack) })), kv(App.t('rep.power.defence'), h('b', { class: 'mono', text: num(d.power.defence) })))); + out.push(sec(App.t('rep.attackerUnits'), unitsTable(d.attacker.units.sent, d.attacker.units.lost, d.attacker.units.survivors))); + if (d.bonus) out.push(sec(App.t('rep.incumbent.reward'), mil().resChips({ hardware: d.bonus.hardware }, true), d.bonus.researchSpeedBonus ? h('p', { class: 'row-sub', text: App.t('units.research.speed', { p: Math.round(d.bonus.researchSpeedBonus * 100) }) }) : null)); + return out; + } + + function settleBody(r, ctl) { + const d = r.data, out = []; + out.push(h('div', { class: 'rep-verdict victory' }, icon('flag'), h('b', { text: App.t('rep.settle.title', { name: d.town.name }) }))); + out.push(kv(App.t('rep.site'), mil().coordLink(d.town.x, d.town.y))); + out.push(kv(App.t('rep.settle.wild'), h('span', { text: (d.wild || []).map((w) => App.buildingName(w)).join(', ') }))); + out.push(h('button', { class: 'btn primary wide', type: 'button', onclick: async () => { + ctl.close(); + try { await App.refreshTowns(); } catch (e) { /* the POP list may be stale; setTown below copes */ } + App.setTown(d.town.id); App.go('pop'); + } }, icon('pop'), App.t('rep.settle.open'))); + out.push(h('p', { class: 'row-sub wrap', text: App.t('rep.settle.hint') })); + return out; + } + + function reinforceBody(r) { + const d = r.data, out = []; + out.push(kv(App.t('rep.from'), h('span', null, h('b', { text: nameOf(d.operator) }), mil().endLink(d.from)))); + out.push(kv(App.t('rep.host'), h('span', null, h('b', { text: nameOf(d.hostOperator) }), mil().endLink(d.host)))); + out.push(sec(App.t('rep.units'), h('p', { text: mil().unitsText(d.units) }))); + return out; + } + + function failedBody(r) { + const d = r.data, out = []; + out.push(h('div', { class: 'rep-verdict defeat' }, icon('alert'), h('b', { text: App.t('rep.failed.title', { type: mil().typeLabel(d.movementType) }) }))); + out.push(h('p', { text: reasonText(d.reason) })); + if (d.to) out.push(kv(App.t('rep.target'), mil().coordLink(d.to.x, d.to.y))); + out.push(sec(App.t('rep.units'), h('p', { text: mil().unitsText(d.units) }), h('p', { class: 'row-sub wrap', text: App.t('rep.failed.home') }))); + return out; + } + + function genericBody(r) { + return [h('pre', { class: 'rep-raw', text: JSON.stringify(r.summary || {}, null, 1).slice(0, 1500) })]; + } + + function bodyFor(r, ctl) { + switch (r.type) { + case 'raid': case 'attack': case 'takeover': return combatBody(r); + case 'scan': return scanBody(r); + case 'scan_detected': return detectedBody(r); + case 'incumbent': return incumbentBody(r); + case 'settle': return settleBody(r, ctl); + case 'reinforce': return reinforceBody(r); + case 'movement_failed': return failedBody(r); + default: return genericBody(r); + } + } + + // ------------------------------------------------------------------ detail sheet + async function openReport(id) { + const body = h('div', { class: 'detail rep-detail' }, h('div', { class: 'boot' }, h('div', { class: 'spinner', 'aria-hidden': 'true' }))); + const ctl = openSheet({ title: App.t('screen.reports'), icon: 'report', closeLabel: App.t('common.close'), body }); + try { + const res = await App.api.get('/reports/' + id); + const r = res.report; + ctl.setTitle(mil().reportTypeLabel(r.type)); + clear(body); + body.appendChild(h('p', { class: 'row-sub', text: mil().dayTime(r.createdAt) + ' · ' + App.t('rep.role.' + r.role) + ' · ' + App.t('rep.expires', { t: mil().dayTime(r.expiresAt) }) })); + let parts; + try { parts = bodyFor(r, ctl); } catch (e) { parts = genericBody(r); } + for (const p of parts.flat(2)) if (p) body.appendChild(p); + if (!r.read) { + App.api.post('/reports/' + id + '/read', {}).then(() => { + const it = items.find((x) => x.id === id); if (it) it.read = true; + if (visible) draw(); + App.refreshReportsUnread().catch(() => {}); + }).catch(() => {}); + } + } catch (e) { + clear(body); + body.appendChild(h('p', { class: 'form-error', text: App.errMsg(e) })); + } + } + + // ------------------------------------------------------------------ screen + App.registerScreen({ + id: 'reports', titleKey: 'screen.reports', navKey: 'nav.reports', icon: 'report', navGroup: 'more', hud: false, + render(container) { + box = container; + listEl = h('ul', { class: 'alert-list' }); + statusEl = h('p', { class: 'form-error', role: 'alert', hidden: true }); + moreBtn = h('button', { class: 'btn wide', type: 'button', hidden: true, onclick: () => load(true) }, App.t('rep.older')); + box.appendChild(h('div', { class: 'page' }, + h('div', { class: 'card-head page-head' }, h('h1', { text: App.t('screen.reports') }), + h('div', { class: 'head-actions' }, + h('button', { class: 'btn small', type: 'button', onclick: markAll }, icon('check'), App.t('rep.markAll')), + h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('common.retry'), onclick: () => load(false) }, icon('refresh')))), + statusEl, listEl, moreBtn)); + App.on('session', () => { items = []; next = null; }); + App.on('report', () => { if (visible) load(false); }); + }, + onShow(params) { + visible = true; + box.querySelector('h1').textContent = App.t('screen.reports'); + moreBtn.textContent = App.t('rep.older'); + draw(); + load(false); + if (params && params.open) openReport(Number(params.open)); + if (offAgo) offAgo(); + offAgo = App.onTick(() => { + const now = App.now(); + for (const el of listEl.querySelectorAll('.when')) { const s = App.fmt.ago(now - Number(el.dataset.at)); if (el.textContent !== s) el.textContent = s; } + }); + }, + onHide() { visible = false; if (offAgo) offAgo(); offAgo = null; }, + }); +}()); diff --git a/public/js/screens/send.js b/public/js/screens/send.js new file mode 100644 index 0000000..0a212ba --- /dev/null +++ b/public/js/screens/send.js @@ -0,0 +1,339 @@ +'use strict'; +/* + * The send dialog: App.openSend({ x, y, fromTownId, type }). Opened from a map tile, the POP screen, the units screen and the + * movements screen. It looks the target up (GET /map/tile), offers the movement types that can work, lets you pick units + * (or cargo, or the wild slots of a new POP), previews latency and arrival from rules.js and sends POST /movements. The + * server re-validates everything; this dialog only avoids obviously doomed sends and explains the greyed-out ones. + * An Idempotency intent is generated per opened dialog (and again after a successful send), so a retried tap cannot send twice. + */ +(function () { + const { h, clear, icon, toast, openSheet } = UI; + const R = UpstreamRules; + const D = UpstreamData; + const Mil = UpstreamMil; + const mil = () => App.mil; + const num = (n) => App.fmt.num(n); + const nonce = () => Math.random().toString(36).slice(2, 10) + Date.now().toString(36).slice(-4); + + App.openSend = function openSend(opts) { + opts = opts || {}; + const st = { + x: Number.isInteger(opts.x) ? opts.x : null, y: Number.isInteger(opts.y) ? opts.y : null, + tile: null, tileErr: null, fromId: null, from: null, type: null, units: {}, cargo: {}, target: '', + wild: D.START.wild.slice(), endProtection: false, busy: false, nonce: nonce(), loadSeq: 0, tileSeq: 0, options: [], + }; + const own = App.state.towns; + st.fromId = own.some((t) => t.id === opts.fromTownId) ? opts.fromTownId : (App.state.townId || (own[0] && own[0].id)); + if (!st.fromId) { toast(App.t('pop.noTown'), 'error'); return; } + + const body = h('div', { class: 'detail send' }); + let offTick = null; + const ctl = openSheet({ title: App.t('send.title'), icon: 'target', closeLabel: App.t('common.close'), body, onClose: () => { if (offTick) offTick(); } }); + + const secTarget = h('div', { class: 'send-sec' }); + const secFrom = h('div', { class: 'send-sec' }); + const secType = h('div', { class: 'send-sec' }); + const secUnits = h('div', { class: 'send-sec' }); + const secPreview = h('div', { class: 'send-sec' }); + const secWarn = h('div', { class: 'send-sec' }); + const errEl = h('p', { class: 'form-error', role: 'alert', hidden: true }); + const submit = h('button', { class: 'btn primary wide', type: 'button', onclick: () => go() }, icon('target'), h('span', { text: App.t('send.go') })); + body.appendChild(secTarget); body.appendChild(secFrom); body.appendChild(secType); body.appendChild(secUnits); body.appendChild(secPreview); body.appendChild(secWarn); + body.appendChild(h('div', { class: 'send-foot' }, errEl, submit)); + + const fromTown = () => own.find((t) => t.id === st.fromId); + const home = () => (st.from ? st.from.td.military.units.home : {}); + const op = () => App.state.operator; + + // ------------------------------------------------------------------ data + async function loadFrom() { + const seq = ++st.loadSeq; + let r; + try { + if (st.fromId === App.state.townId && App.state.townData && App.state.townData.military) r = { td: App.state.townData, rt: App.rulesTown(), at: App.fetchedServerTime }; + else { const x = await mil().loadTown(st.fromId); r = { td: x.town, rt: App.rulesTownFrom(x.town, x.serverTime), at: x.serverTime }; } + } catch (e) { if (seq === st.loadSeq) showErr(App.errMsg(e)); return; } + if (seq !== st.loadSeq) return; + st.from = r; + afterData(); + } + + async function loadTile() { + if (st.x === null || st.y === null) { st.tile = null; return; } + const seq = ++st.tileSeq; + st.tile = null; st.tileErr = null; + drawTarget(); + try { + const t = await App.api.get('/map/tile', { x: st.x, y: st.y }); + if (seq !== st.tileSeq) return; + st.tile = t; + } catch (e) { + if (seq !== st.tileSeq) return; + st.tileErr = e.code === 'not_found' ? App.t('tile.void') : App.errMsg(e); + } + afterData(); + } + + function afterData() { + drawTarget(); + drawFrom(); + if (!st.tile || !st.from) { drawTypes(); return; } + computeOptions(); + drawTypes(); + } + + function computeOptions() { + const m = st.from.td.military; + st.options = Mil.moveOptions({ tile: st.tile, home: m.units.home, transport: m.transport, allianceId: op() ? op().allianceId : null, crews: m.units.home[D.EXPANSION.settleUnit] || 0 }); + const want = st.type && st.options.some((o) => o.type === st.type) ? st.type : (opts.type && st.options.some((o) => o.type === opts.type && o.ok) ? opts.type : null); + const first = st.options.find((o) => o.ok); + setType(want || (first ? first.type : (st.options[0] ? st.options[0].type : null)), true); + } + + function setType(type, keep) { + if (!keep && type === st.type) return; + st.type = type; + st.units = type ? Mil.defaultUnits(type, home()) : {}; + st.cargo = {}; st.target = ''; st.endProtection = false; + showErr(''); + drawTypes(); drawUnits(); refresh(); + } + + // ------------------------------------------------------------------ sections + function drawTarget() { + clear(secTarget); + const t = st.tile; + const xin = h('input', { type: 'number', inputmode: 'numeric', value: st.x === null ? '' : String(st.x), class: 'mil-num', 'aria-label': 'x', placeholder: 'x' }); + const yin = h('input', { type: 'number', inputmode: 'numeric', value: st.y === null ? '' : String(st.y), class: 'mil-num', 'aria-label': 'y', placeholder: 'y' }); + const lookup = () => { + const x = Math.round(Number(xin.value)), y = Math.round(Number(yin.value)); + if (xin.value === '' || yin.value === '' || !Number.isFinite(x) || !Number.isFinite(y)) return; + st.x = x; st.y = y; st.type = null; loadTile(); + }; + secTarget.appendChild(h('h3', { class: 'sub', text: App.t('send.target') })); + secTarget.appendChild(h('div', { class: 'send-coords' }, h('span', { class: 'mono', text: 'x' }), xin, h('span', { class: 'mono', text: 'y' }), yin, + h('button', { class: 'btn small', type: 'button', onclick: lookup }, icon('locate'), App.t('send.lookup')))); + if (!t) { + secTarget.appendChild(h('div', { class: 'chips' }, own.map((o) => h('button', { class: 'chip-btn', type: 'button', onclick: () => { st.x = o.x; st.y = o.y; st.type = null; loadTile(); } }, o.name)))); + } + if (st.tileErr) { secTarget.appendChild(h('p', { class: 'reason', text: st.tileErr })); return; } + if (st.x !== null && !t) { secTarget.appendChild(h('p', { class: 'dimmer', text: App.t('common.loading') })); return; } + if (!t) return; + const pills = [h('span', { class: 'pill', text: App.t('tile.' + t.type) })]; + if (t.town) { + if (t.town.mine) pills.push(h('span', { class: 'pill accent', text: App.t('map.info.yours') })); + if (t.town.isCapital) pills.push(h('span', { class: 'pill', text: App.t('map.info.capital') })); + if (t.town.owner && t.town.owner.protected) pills.push(h('span', { class: 'pill amber' }, icon('shield'), App.t('map.info.protected'))); + } + if (t.type === 'rural' && t.bonus) pills.push(h('span', { class: 'pill res-' + t.bonus }, icon(t.bonus), App.resName(t.bonus))); + secTarget.appendChild(h('div', { class: 'send-target' }, + h('div', { class: 'row' }, h('b', { text: t.town ? t.town.name : App.t('tile.' + t.type) }), mil().coordLink(t.x, t.y)), + t.town && t.town.owner ? h('p', { class: 'row-sub wrap', text: t.town.owner.name + ' · ' + UpstreamI18n.fmtAs(t.town.owner.asNumber) }) : null, + h('div', { class: 'pill-row' }, pills))); + } + + function drawFrom() { + clear(secFrom); + if (own.length < 2) return; + secFrom.appendChild(h('label', { class: 'field' }, h('span', { class: 'field-lbl', text: App.t('send.from') }), + h('select', { onchange: (e) => { st.fromId = Number(e.target.value); st.from = null; st.type = null; st.units = {}; drawUnits(); drawTypes(); loadFrom(); } }, + own.map((o) => h('option', { value: o.id, selected: o.id === st.fromId, text: o.name }))))); + } + + function reasonText(o) { + const r = o.reason || ''; + if (r.indexOf('settle:') === 0) { + const code = r.slice(7), s = st.tile && st.tile.settle ? st.tile.settle : {}; + if (code === 'footprint_too_low') return App.t('send.reason.footprint', { have: num(s.footprint), need: num(s.footprintNeeded) }); + if (code === 'out_of_range') return App.t('send.reason.range', { n: s.maxDistance || D.EXPANSION.maxDistance }); + return App.t('send.reason.cannotSettle'); + } + return App.t('send.reason.' + r); + } + + function drawTypes() { + clear(secType); + if (!st.tile || !st.from) return; + if (!st.options.length) { secType.appendChild(h('p', { class: 'empty', text: App.t('send.nothing') })); return; } + secType.appendChild(h('h3', { class: 'sub', text: App.t('send.what') })); + secType.appendChild(h('div', { class: 'seg wrap-seg', role: 'group', 'aria-label': App.t('send.what') }, st.options.map((o) => + h('button', { class: 'seg-btn', type: 'button', disabled: !o.ok, 'aria-pressed': String(o.type === st.type), onclick: () => setType(o.type) }, icon(Mil.TYPE_ICON[o.type]), h('span', { text: mil().typeLabel(o.type) }))))); + const off = st.options.filter((o) => !o.ok); + if (off.length) secType.appendChild(h('ul', { class: 'send-why' }, off.map((o) => h('li', { class: 'row-sub wrap', text: mil().typeLabel(o.type) + ': ' + reasonText(o) })))); + } + + function pickRow(label, have, cur, onChange, sub) { + const range = h('input', { type: 'range', min: '0', max: String(have), step: '1', value: String(cur), 'aria-label': label }); + const numIn = h('input', { type: 'number', inputmode: 'numeric', min: '0', max: String(have), value: String(cur), class: 'mil-num', 'aria-label': label }); + const set = (v) => { v = Math.max(0, Math.min(have, Math.floor(Number(v)) || 0)); range.value = String(v); numIn.value = String(v); onChange(v); }; + range.addEventListener('input', () => set(range.value)); + numIn.addEventListener('input', () => set(numIn.value)); + return h('div', { class: 'mil-pick' }, + h('div', { class: 'row' }, h('span', null, h('b', { text: label }), h('span', { class: 'dimmer', text: ' / ' + num(have) })), sub || null), + h('div', { class: 'pick-ctl' }, + h('button', { class: 'btn small', type: 'button', 'aria-label': '-1', onclick: () => set(Number(numIn.value) - 1) }, '−'), + range, + h('button', { class: 'btn small', type: 'button', 'aria-label': '+1', onclick: () => set(Number(numIn.value) + 1) }, '+'), + numIn, + h('button', { class: 'btn small', type: 'button', onclick: () => set(have) }, App.t('send.all')))); + } + + function drawUnits() { + clear(secUnits); + const type = st.type; + if (!type || !st.from) return; + const opt = st.options.find((o) => o.type === type); + if (!opt || !opt.ok) return; // greyed out: the reason is shown with the type picker + const h0 = home(); + if (type === 'settle') { + const s = st.tile.settle || {}; + secUnits.appendChild(h('h3', { class: 'sub', text: App.t('send.settle.title') })); + secUnits.appendChild(h('p', { class: 'preview', text: App.t('send.settle.crews', { n: D.EXPANSION.crews, unit: mil().unitName(D.EXPANSION.settleUnit) }) })); + secUnits.appendChild(h('p', { class: 'row-sub wrap', text: App.t('send.settle.footprint', { have: num(s.footprint), need: num(s.footprintNeeded), n: s.maxDistance || D.EXPANSION.maxDistance }) })); + for (let i = 0; i < D.WILD_SLOTS; i++) { + secUnits.appendChild(h('label', { class: 'field' }, h('span', { class: 'field-lbl', text: App.t('send.settle.wild', { n: i + 1 }) }), + h('select', { onchange: (e) => { st.wild[i] = e.target.value; } }, + D.FIELD_TYPES.map((ft) => h('option', { value: ft, selected: st.wild[i] === ft, text: App.buildingName(ft) + ' (' + App.resName(D.FIELD_PRODUCES[ft]) + ')' }))))); + } + return; + } + if (type === 'transport') { + const m = st.from.td.military; + const cur = R.resourcesAt(st.from.rt, App.now()).amounts; + secUnits.appendChild(h('h3', { class: 'sub', text: App.t('send.cargo') })); + secUnits.appendChild(h('p', { class: 'row-sub wrap', text: App.t('send.cargo.cap', { n: num(m.transport.capacityPerLink), free: Math.max(0, m.transport.links - m.transport.active), links: m.transport.links }) })); + for (const r of D.RESOURCES) { + const have = Math.floor(cur[r] || 0); + secUnits.appendChild(pickRow(App.resName(r), have, st.cargo[r] || 0, (v) => { if (v > 0) st.cargo[r] = v; else delete st.cargo[r]; refresh(); })); + } + return; + } + const rows = Mil.unitsForType(type, h0); + secUnits.appendChild(h('h3', { class: 'sub', text: App.t('send.units') })); + if (!rows.length) { secUnits.appendChild(h('p', { class: 'empty', text: App.t('send.reason.no_units') })); return; } + for (const r of rows) { + const def = D.UNITS[r.unit]; + secUnits.appendChild(pickRow(mil().unitName(r.unit), r.have, st.units[r.unit] || 0, (v) => { if (v > 0) st.units[r.unit] = v; else delete st.units[r.unit]; refresh(); }, + h('span', { class: 'row-sub', text: def.speed + ' ' + App.t('send.tilesPerHour') }))); + } + } + + // ------------------------------------------------------------------ preview, warnings, button state + function ready() { + if (!st.tile || !st.from || !st.type) return { ok: false, why: '' }; + const o = st.options.find((x) => x.type === st.type); + if (!o || !o.ok) return { ok: false, why: '' }; + const m = st.from.td.military; + if (!m.units.online) return { ok: false, why: App.t('err.units_offline') }; + if (st.type === 'transport') { + const total = Object.keys(st.cargo).reduce((s, k) => s + st.cargo[k], 0); + if (total < 1) return { ok: false, why: '' }; + if (total > m.transport.capacityPerLink) return { ok: false, why: App.t('err.capacity_exceeded') }; + } else { + const sel = Mil.cleanSelection(st.units, home()); + if (Mil.sumUnits(sel) < 1) return { ok: false, why: '' }; + if (st.type === 'takeover' && !(sel[D.EXPANSION.conquestUnit] > 0)) return { ok: false, why: App.t('send.reason.needs_ma_team') }; + const chk = R.checkUnitsForType(st.type, sel); + if (chk) return { ok: false, why: '' }; + } + if (needsProtectionConfirm() && !st.endProtection) return { ok: false, why: App.t('send.protection.need') }; + return { ok: true, why: '' }; + } + + const needsProtectionConfirm = () => Mil.isHostile(st.type) && op() && op().protectionUntil > App.now(); + + function refresh() { + drawPreview(); + drawWarn(); + const r = ready(); + submit.disabled = !r.ok || st.busy; + } + + function drawPreview() { + clear(secPreview); + if (!st.tile || !st.from || !st.type) return; + const from = fromTown(); + if (!from) return; + const units = st.type === 'transport' ? {} : Mil.cleanSelection(st.units, home()); + const hasSel = st.type === 'transport' ? Object.keys(st.cargo).length > 0 : Mil.sumUnits(units) > 0; + if (!hasSel) { secPreview.appendChild(h('p', { class: 'dimmer', text: App.t('send.pickSome') })); return; } + const p = Mil.preview(st.type, from, { x: st.tile.x, y: st.tile.y }, units, st.cargo, App.state.world.speed); + secPreview.appendChild(h('div', { class: 'send-preview' }, + h('div', { class: 'kv' }, h('span', { class: 'k', text: App.t('send.distance') }), h('span', { class: 'v mono', text: App.fmt.dec(p.dist) + ' ' + App.t('common.tiles') })), + h('div', { class: 'kv' }, h('span', { class: 'k', text: App.t('send.latency') }), h('span', { class: 'v mono', text: App.fmt.dur(p.ms) })), + h('div', { class: 'kv' }, h('span', { class: 'k', text: App.t('send.arrives') }), h('span', { class: 'v mono', text: mil().clockTime(App.now() + p.ms) })), + p.slowest ? h('div', { class: 'kv' }, h('span', { class: 'k', text: App.t('send.slowest') }), h('span', { class: 'v mono', text: p.slowest + ' ' + App.t('send.tilesPerHour') })) : null, + (st.type === 'raid' || st.type === 'attack' || st.type === 'takeover') && p.carry > 0 ? h('div', { class: 'kv' }, h('span', { class: 'k', text: App.t('send.carry') }), h('span', { class: 'v mono', text: num(p.carry) })) : null)); + } + + function drawWarn() { + clear(secWarn); + if (!st.tile || !st.from || !st.type) return; + const type = st.type; + const items = []; + if (needsProtectionConfirm()) { + const cb = h('input', { type: 'checkbox', checked: st.endProtection, onchange: (e) => { st.endProtection = e.target.checked; refresh(); } }); + items.push(h('label', { class: 'warn-check' }, cb, h('span', null, h('b', { text: App.t('send.protection.title') }), ' ', App.t('send.protection.body', { t: mil().dayTime(op().protectionUntil) })))); + } + if ((type === 'attack' || type === 'takeover') && (st.units.exploit_kit || 0) > 0) { + items.push(h('label', { class: 'field' }, h('span', { class: 'field-lbl', text: App.t('send.siege') }), + h('select', { onchange: (e) => { st.target = e.target.value; } }, + h('option', { value: '', text: App.t('send.siege.none') }), + Mil.siegeTargets().map((k) => h('option', { value: k, selected: st.target === k, text: App.buildingName(k) }))), + h('span', { class: 'field-hint', text: App.t('send.siege.hint', { n: D.MILITARY.kitsMin }) }))); + } + if (type === 'takeover') items.push(h('p', { class: 'row-sub wrap', text: App.t('send.takeover.hint') })); + if (type === 'raid') items.push(h('p', { class: 'row-sub wrap', text: App.t('send.raid.hint') })); + if (type === 'scan') items.push(h('p', { class: 'row-sub wrap', text: App.t('send.scan.hint') })); + if (type === 'reinforce' && st.tile.town && st.tile.town.mine) items.push(h('p', { class: 'row-sub wrap', text: App.t('send.reinforce.own') })); + if (Mil.isHostile(type) && st.tile.town && !st.tile.town.mine) items.push(h('p', { class: 'row-sub wrap', text: App.t('send.hostile.hint') })); + const r = ready(); + if (r.why) items.push(h('p', { class: 'reason', text: r.why })); + secWarn.appendChild(h('div', { class: 'send-warn' }, items)); + } + + function showErr(msg) { errEl.textContent = msg || ''; errEl.hidden = !msg; } + + // ------------------------------------------------------------------ send + async function go() { + const r = ready(); + if (!r.ok || st.busy) return; + st.busy = true; submit.disabled = true; showErr(''); + const body = { fromTownId: st.fromId, type: st.type }; + if (st.tile.town) body.toTownId = st.tile.town.id; else { body.x = st.tile.x; body.y = st.tile.y; } + if (st.type === 'transport') body.cargo = Object.assign({}, st.cargo); + else body.units = Mil.cleanSelection(st.units, home()); + if (st.type === 'settle') body.wild = st.wild.slice(0, D.WILD_SLOTS); + if ((st.type === 'attack' || st.type === 'takeover') && st.target && (body.units.exploit_kit || 0) > 0) body.target = st.target; + if (needsProtectionConfirm() && st.endProtection) body.confirmEndProtection = true; + try { + const res = await App.api.post('/movements', body, { intent: 'send:' + st.fromId + ':' + st.nonce }); + st.nonce = nonce(); + toast(App.t('send.sent', { type: mil().typeLabel(res.type), t: App.fmt.dur(res.arriveAt - res.departAt) }), 'ok'); + ctl.close(); + App.refreshMovements().catch(() => {}); + App.refreshTown().catch(() => {}); + if (App.state.operator && res.protectionEnded) App.state.operator.protectionUntil = 0; + } catch (e) { + st.busy = false; + let msg = App.errMsg(e); + const reason = e.details && e.details.reason; + if (e.code === 'invalid_target' && reason && UpstreamI18n.strings.en['send.invalid.' + reason]) msg += ' ' + App.t('send.invalid.' + reason); + showErr(msg); + if (e.code === 'not_enough_units' || e.code === 'units_offline' || e.code === 'conflict') { st.from = null; loadFrom(); } + refresh(); + } + } + + // keep the arrival clock and affordability honest while the dialog stays open + let lastSlot = 0; + offTick = App.onTick((now) => { + const slot = Math.floor(now / 15000); + if (slot !== lastSlot && !st.busy && st.from && st.tile && st.type) { lastSlot = slot; drawPreview(); } + }); + drawTarget(); drawFrom(); + loadFrom(); + if (st.x !== null) loadTile(); + refresh(); + }; +}()); diff --git a/public/js/screens/settings.js b/public/js/screens/settings.js index 12ad78b..cd7d40b 100644 --- a/public/js/screens/settings.js +++ b/public/js/screens/settings.js @@ -77,7 +77,7 @@ } App.registerScreen({ - id: 'settings', titleKey: 'screen.settings', navKey: 'nav.settings', icon: 'gear', hud: false, + id: 'settings', titleKey: 'screen.settings', navKey: 'nav.settings', icon: 'gear', hud: false, navGroup: 'more', render(container) { box = container; App.on('session', () => { tokens = null; }); }, onShow() { draw(); loadTokens(); }, }); diff --git a/public/js/screens/social-ui.js b/public/js/screens/social-ui.js new file mode 100644 index 0000000..76e20fe --- /dev/null +++ b/public/js/screens/social-ui.js @@ -0,0 +1,166 @@ +'use strict'; +/* + * Pieces shared by the social screens (alliance, messages, rankings): window.SocUI. Everything player-controlled (operator + * names, alliance names and tags, notes, message text) goes in through textContent / text nodes only, never innerHTML. + */ +(function () { + const { h, clear, icon, toast, openSheet } = UI; + const Soc = UpstreamSocial; + const D = UpstreamData; + + const role = (r) => (D.SOCIAL.roles.includes(r) ? App.t('soc.role.' + r) : String(r)); + const state = (s) => (D.SOCIAL.diplomacyStates.includes(s) ? App.t('soc.state.' + s) : String(s)); + const kindLabel = (k) => App.t('soc.kind.' + k); + + // Error text for a failed call. A 429 from the message limiter carries retryAfter (seconds). + function err(e) { + if (e && e.code === 'rate_limited' && e.retryAfter && (!e.details || !e.details.scope || e.details.scope === 'messages')) return App.t('soc.rate', { t: App.fmt.dur(Soc.retrySeconds(e) * 1000, 2) }); + return App.errMsg(e); + } + + // /me caches the operator's alliance; after founding, joining, leaving or being kicked refresh just that, without + // App.setSession (which would reset the POP view). + async function refreshOperator() { + const me = await App.api.get('/me'); + const mineOp = (me.operators || []).find((o) => App.state.operator && o.id === App.state.operator.id); + if (mineOp && App.state.operator) { + App.state.operator.alliance = mineOp.alliance; + App.state.operator.allianceId = mineOp.allianceId; + App.emit('alliance', mineOp.alliance); + } + return mineOp; + } + const myAlliance = () => (App.state.operator && App.state.operator.alliance) || null; + const myOperatorId = () => (App.state.operator ? App.state.operator.id : 0); + + const tagPill = (tag) => h('span', { class: 'pill soc-tag', text: '[' + tag + ']' }); + const rolePill = (r) => h('span', { class: 'pill soc-role soc-role-' + r, text: role(r) }); + + // A busy button: disables itself while the promise runs and reports errors as a toast (or via `onError`). + async function guard(btn, fn, onError) { + if (btn) btn.disabled = true; + try { return await fn(); } catch (e) { + if (onError) onError(e); else toast(err(e), 'error'); + return undefined; + } finally { if (btn && btn.isConnected) btn.disabled = false; } + } + + // Confirmation sheet. onOk() may throw: the error is shown inside the sheet and it stays open. + function confirmSheet(o) { + const msg = h('p', { class: 'form-error', role: 'alert', hidden: true }); + const ok = h('button', { class: 'btn ' + (o.danger ? 'danger' : 'primary'), type: 'button', text: o.ok || App.t('common.confirm') }); + const sheet = openSheet({ + title: o.title, icon: o.icon || 'alert', closeLabel: App.t('common.close'), + body: h('div', { class: 'detail' }, h('p', { class: 'detail-desc', text: o.text }), msg, + h('div', { class: 'btn-row' }, h('button', { class: 'btn', type: 'button', onclick: () => sheet.close(), text: App.t('common.cancel') }), ok)), + }); + ok.addEventListener('click', async () => { + ok.disabled = true; msg.hidden = true; + try { await o.onOk(); sheet.close(); } catch (e) { msg.textContent = err(e); msg.hidden = false; ok.disabled = false; } + }); + return sheet; + } + + // ------------------------------------------------------------------ composer: textarea + live counter + send + // composer({ onSend(text) -> Promise, placeholder, sendLabel, label }) -> { el, focus(), clear(), input } + // A rate_limited answer disables sending and counts the seconds down; the text is kept. + function composer(o) { + const max = D.SOCIAL.messageMax; + const input = h('textarea', { class: 'soc-text', rows: o.rows || 3, maxlength: String(max * 2), placeholder: o.placeholder || '', 'aria-label': o.label || App.t('soc.msg.text'), enterkeyhint: 'enter' }); + const counter = h('span', { class: 'soc-count mono' }); + const note = h('p', { class: 'soc-rate', role: 'alert', hidden: true }); + const send = h('button', { class: 'btn primary', type: 'button' }, icon('up'), o.sendLabel || App.t('soc.msg.send')); + const el = h('div', { class: 'soc-composer' }, input, h('div', { class: 'soc-composer-bar' }, counter, send), note); + let until = 0, off = null, busy = false; + + function refresh() { + const st = Soc.composeState(input.value, max); + counter.textContent = st.n + '/' + max; + counter.classList.toggle('over', st.over); + counter.setAttribute('aria-label', App.t('soc.msg.counter', { n: st.n, max })); + const waiting = until > App.now(); + send.disabled = busy || st.empty || st.over || waiting; + } + function tick() { + if (!el.isConnected) { stopTick(); return; } + const left = Math.ceil((until - App.now()) / 1000); + if (left <= 0) { until = 0; note.hidden = true; stopTick(); refresh(); return; } + const s = App.t('soc.rate', { t: App.fmt.dur(left * 1000, 2) }); + if (note.textContent !== s) note.textContent = s; + } + function startTick() { if (!off) off = App.onTick(tick); } + function stopTick() { if (off) { off(); off = null; } } + + input.addEventListener('input', refresh); + send.addEventListener('click', async () => { + const text = input.value; + if (send.disabled) return; + busy = true; refresh(); note.hidden = true; + try { + await o.onSend(text); + input.value = ''; + } catch (e) { + if (e && e.code === 'rate_limited') { + until = App.now() + Soc.retrySeconds(e) * 1000; + note.textContent = App.t('soc.rate', { t: App.fmt.dur(Soc.retrySeconds(e) * 1000, 2) }); note.hidden = false; + startTick(); + } else { note.textContent = err(e); note.hidden = false; } + } finally { busy = false; refresh(); } + }); + refresh(); + return { el, input, focus: () => { try { input.focus({ preventScroll: true }); } catch (e) { /* ignore */ } }, refresh, destroy: stopTick }; + } + + // Compose sheet. target: { operator: { operatorId, name } } or { alliance: true }. + function openCompose(target, onSent) { + const toAlliance = !!target.alliance; + const to = toAlliance ? '[' + ((myAlliance() || {}).tag || '') + ']' : target.operator.name; + const comp = composer({ + onSend: async (text) => { + const body = toAlliance ? { text, toAlliance: true } : { text, toOperatorId: target.operator.operatorId }; + await App.api.post('/messages', body, { retries: 0 }); + toast(App.t('soc.msg.sent'), 'ok'); + sheet.close(); + if (onSent) onSent(); + }, + }); + const sheet = openSheet({ + title: toAlliance ? App.t('soc.msg.toAlliance') : App.t('soc.msg.to', { name: to }), + icon: 'mail', closeLabel: App.t('common.close'), onClose: comp.destroy, + body: h('div', { class: 'detail' }, toAlliance ? h('p', { class: 'detail-desc', text: App.t('soc.msg.broadcastHint', { tag: to }) }) : null, comp.el), + }); + setTimeout(comp.focus, 220); + return sheet; + } + + // ------------------------------------------------------------------ alliance profile sheet (public view) + async function openProfile(allianceId, extra) { + const body = h('div', { class: 'detail' }, h('p', { class: 'empty', text: App.t('common.loading') })); + const sheet = openSheet({ title: extra && extra.name ? extra.name : App.t('soc.profile'), icon: 'users', closeLabel: App.t('common.close'), body }); + try { + const a = (await App.api.get('/alliances/' + allianceId)).alliance; + sheet.setTitle(a.name); + clear(body); + const kv = (k, v) => h('div', { class: 'kv' }, h('span', { class: 'k', text: k }), h('span', { class: 'v' }, v)); + body.appendChild(h('div', { class: 'pill-row' }, tagPill(a.tag), + a.relation ? h('span', { class: 'pill soc-state soc-state-' + a.relation, text: a.relation === 'same' ? App.t('soc.relation.same') : state(a.relation) }) : null, + a.myRole ? rolePill(a.myRole) : null)); + body.appendChild(h('div', null, + kv(App.t('soc.members'), App.t('soc.size', { n: a.memberCount, cap: a.sizeCap })), + kv(App.t('soc.leader'), a.leader ? a.leader.name : '-'), + kv(App.t('soc.footprint'), App.fmt.dec(a.footprint || 0)), + kv(App.t('soc.founded'), App.fmt.ago(App.now() - a.createdAt)))); + } catch (e) { + clear(body); + body.appendChild(h('p', { class: 'form-error', role: 'alert', text: err(e) })); + } + return sheet; + } + + // Loading / error / empty placeholders for a list container. + const loading = () => h('p', { class: 'empty', text: App.t('common.loading') }); + const errorBox = (e, retry) => h('div', { class: 'soc-err' }, h('p', { class: 'form-error', role: 'alert', text: err(e) }), + retry ? h('button', { class: 'btn small', type: 'button', onclick: retry }, icon('refresh'), App.t('common.retry')) : null); + + window.SocUI = { role, state, kindLabel, err, refreshOperator, myAlliance, myOperatorId, tagPill, rolePill, guard, confirmSheet, composer, openCompose, openProfile, loading, errorBox }; +}()); diff --git a/public/js/screens/units.js b/public/js/screens/units.js new file mode 100644 index 0000000..862fb06 --- /dev/null +++ b/public/js/screens/units.js @@ -0,0 +1,368 @@ +'use strict'; +/* + * Units: what stands in this POP (home, reinforcements from others, your units standing elsewhere), the training queue + * with a train form, research, and the power/offline status. Everything comes from GET /towns/:id (town.military); the + * client previews cost/time with rules.trainPlan / researchPlan (same functions the server runs) and the server decides. + */ +(function () { + const { h, clear, icon, toast, openSheet, closeSheet } = UI; + const R = UpstreamRules; + const D = UpstreamData; + const Mil = UpstreamMil; + + const td = () => App.state.townData; + const mi = () => (td() ? td().military : null); + const mil = () => App.mil; + + let box, bodyEl, visible = false, dirty = true, offTick = null; + const refetch = new Map(); // training/research event id -> { n, at } + + const num = (n) => App.fmt.num(n); + const val = (x) => (Number.isInteger(x) ? num(x) : App.fmt.dec(x)); + + // ------------------------------------------------------------------ pieces + function statLine(unit, levels) { + const def = D.UNITS[unit]; + const a = R.unitStat(unit, 'attack', levels), d = R.unitStat(unit, 'defence', levels); + return App.t('unit.stats', { a: val(a), d: val(d), s: def.speed || 0, c: def.carry || 0 }) + (def.fixed ? ' · ' + App.t('unit.fixed') : ''); + } + + function unitRow(unit, count, levels, right) { + return h('li', { class: 'mil-row unit' }, + h('span', { class: 'row-ic' }, mil().unitIcon(unit)), + h('span', { class: 'row-main' }, + h('span', { class: 'row-title' }, h('b', { text: mil().unitName(unit) }), count !== null ? h('span', { class: 'lv mono', text: '× ' + num(count) }) : null), + h('span', { class: 'row-sub wrap', text: statLine(unit, levels) })), + right || null); + } + + function unitList(units, levels) { + const rows = D.UNIT_ORDER.filter((u) => units && units[u] > 0).map((u) => unitRow(u, units[u], levels)); + return rows.length ? h('ul', { class: 'mil-list' }, rows) : null; + } + + // ------------------------------------------------------------------ status + function statusCard(m) { + const t = td(); + if (!m.units.online) { + const until = Mil.decommissionAt(m.units.offlineSince || App.now(), App.state.world.speed); + return h('section', { class: 'card warn-card', role: 'alert' }, + h('div', { class: 'card-head' }, h('h2', null, icon('power'), App.t('units.offline.title'))), + h('p', { class: 'detail-desc', text: App.t('units.offline.body') }), + h('p', { class: 'row-sub wrap' }, App.t('units.offline.decom') + ' ', mil().countdown(until))); + } + return h('section', { class: 'card' }, + h('div', { class: 'card-head' }, h('h2', null, icon('units'), App.t('units.status')), + h('span', { class: 'pill green', text: App.t('units.online') })), + h('p', { class: 'row-sub wrap', text: App.t('units.powerNet', { n: App.fmt.dec(t.power.net, true) }) })); + } + + // ------------------------------------------------------------------ home / stationed + function homeCard(m) { + const levels = m.research.levels; + const list = unitList(m.units.home, levels); + return h('section', { class: 'card' }, + h('div', { class: 'card-head' }, h('h2', null, icon('units'), App.t('units.home')), + h('button', { class: 'btn small primary', type: 'button', disabled: !list, onclick: () => App.openSend({ fromTownId: td().id }) }, icon('target'), App.t('mov.send'))), + list || h('p', { class: 'empty', text: App.t('units.home.empty') })); + } + + async function withdraw(hostTownId, ownerTownId, btn) { + btn.disabled = true; + try { + await App.api.post('/towns/' + hostTownId + '/withdraw', { ownerTownId }, { intent: 'withdraw:' + hostTownId + ':' + ownerTownId }); + toast(App.t('units.withdrawn'), 'ok'); + } catch (e) { toast(App.errMsg(e), 'error'); } + App.refreshMovements().catch(() => {}); + App.refreshTown().catch(() => {}); + } + + function stationedCards(m) { + const out = []; + if (m.units.stationedHere.length) { + out.push(h('section', { class: 'card' }, + h('div', { class: 'card-head' }, h('h2', null, icon('shield'), App.t('units.hosted'))), + h('ul', { class: 'mil-list' }, m.units.stationedHere.map((g) => h('li', { class: 'mil-group' }, + h('div', { class: 'row' }, + h('span', null, h('b', { text: g.ownerTownName || '#' + g.ownerTownId }), g.owner ? h('span', { class: 'dimmer', text: ' · ' + g.owner.name }) : null), + h('button', { class: 'btn small', type: 'button', onclick: (ev) => withdraw(td().id, g.ownerTownId, ev.currentTarget) }, icon('return'), App.t('units.sendHome'))), + h('p', { class: 'row-sub wrap', text: mil().unitsText(g.units) })))))); + } + if (m.units.stationedAway.length) { + out.push(h('section', { class: 'card' }, + h('div', { class: 'card-head' }, h('h2', null, icon('flag'), App.t('units.away'))), + h('ul', { class: 'mil-list' }, m.units.stationedAway.map((g) => h('li', { class: 'mil-group' }, + h('div', { class: 'row' }, + h('span', null, h('b', { text: g.hostTownName || '#' + g.hostTownId })), + h('button', { class: 'btn small', type: 'button', onclick: (ev) => withdraw(g.hostTownId, td().id, ev.currentTarget) }, icon('return'), App.t('units.callBack'))), + h('p', { class: 'row-sub wrap', text: mil().unitsText(g.units) })))))); + } + return out; + } + + // ------------------------------------------------------------------ training + const tailFor = (m, building) => m.training.filter((b) => b.building === building).reduce((t, b) => Math.max(t, b.dueAt), 0); + + function trainingCard(m) { + const queue = h('ul', { class: 'mil-list queue' }); + for (const b of m.training) { + const bar = h('i'); + const li = h('li', { class: 'mil-row batch' }, + h('span', { class: 'row-ic' }, mil().unitIcon(b.unit)), + h('span', { class: 'row-main' }, + h('span', { class: 'row-title' }, h('b', { text: mil().unitName(b.unit) }), h('span', { class: 'lv mono', text: '× ' + num(b.count) }), h('span', { class: 'lv', text: App.buildingName(b.building) })), + h('span', { class: 'bar mil-bar', 'aria-hidden': 'true' }, bar)), + h('span', { class: 'mil-when' }, mil().countdown(b.dueAt))); + li._bar = bar; li._b = b; + queue.appendChild(li); + } + const trainable = h('ul', { class: 'mil-list' }, m.trainable.map((u) => { + const def = D.UNITS[u.unit]; + const row = h('button', { class: 'row-btn mil-train' + (u.locked ? ' locked' : ''), type: 'button', dataset: { unit: u.unit }, onclick: () => openTrain(u.unit) }, + h('span', { class: 'row-ic' }, mil().unitIcon(u.unit)), + h('span', { class: 'row-main' }, + h('span', { class: 'row-title' }, h('b', { text: mil().unitName(u.unit) }), h('span', { class: 'lv', text: App.buildingName(def.building) })), + u.locked + ? h('span', { class: 'row-sub wrap', text: App.t('units.needs') + ' ' + u.missing.map((x) => App.buildingName(x.type) + ' ' + App.t('pop.level', { n: x.level })).join(', ') }) + : h('span', { class: 'row-sub wrap', text: App.t('units.perUnit', { t: App.fmt.dur(u.timeMs) }) })), + u.locked ? h('span', { class: 'pill dim' }, icon('lock')) : mil().resChips(u.cost)); + return h('li', null, row); + })); + return h('section', { class: 'card' }, + h('div', { class: 'card-head' }, h('h2', null, icon('clock'), App.t('units.training')), h('span', { class: 'pill', text: String(m.training.length) })), + m.training.length ? queue : h('p', { class: 'empty', text: App.t('units.training.empty') }), + h('h3', { class: 'sub', text: App.t('units.train') }), trainable); + } + + function openTrain(unit) { + const body = h('div', { class: 'detail' }); + let off = null; + const ctl = openSheet({ title: mil().unitName(unit), icon: 'units', closeLabel: App.t('common.close'), body, onClose: () => { if (off) off(); } }); + const els = {}; + let count = 1, busy = false; + const def = D.UNITS[unit]; + + function plan() { + const t = td(), m = mi(); + const rt = App.rulesTown(); + if (!t || !rt) return null; + const p = R.trainPlan(rt, unit, count, App.now(), tailFor(m, def.building)); + if (p.ok && m.training.filter((b) => b.building === def.building).length >= D.MILITARY.maxTrainQueue) return Object.assign(p, { ok: false, code: 'queue_full' }); + return p; + } + function maxAffordable() { + const cur = App.resourcesNow(); + if (!cur) return 1; + let n = D.MILITARY.maxBatch; + for (const r of D.RESOURCES) if (def.cost[r] > 0) n = Math.min(n, Math.floor(cur.amounts[r] / def.cost[r] + 1e-6)); + return Math.max(0, n); + } + + body.appendChild(h('p', { class: 'detail-desc', text: mil().unitDesc(unit) })); + body.appendChild(h('p', { class: 'preview', text: statLine(unit, mi().research.levels) + ' · ' + App.t('unit.draw', { n: def.draw }) })); + els.input = h('input', { type: 'number', inputmode: 'numeric', min: '1', max: String(D.MILITARY.maxBatch), value: '1', class: 'mil-num', 'aria-label': App.t('units.count') }); + const step = (d) => { count = Math.max(1, Math.min(D.MILITARY.maxBatch, count + d)); els.input.value = String(count); live(); }; + els.input.addEventListener('input', () => { const v = Math.floor(Number(els.input.value)); count = Number.isFinite(v) && v >= 1 ? Math.min(v, D.MILITARY.maxBatch) : 1; live(); }); + body.appendChild(h('div', { class: 'stepper' }, + h('button', { class: 'btn', type: 'button', 'aria-label': '-10', onclick: () => step(-10) }, '−10'), + h('button', { class: 'btn', type: 'button', 'aria-label': '-1', onclick: () => step(-1) }, '−'), + els.input, + h('button', { class: 'btn', type: 'button', 'aria-label': '+1', onclick: () => step(1) }, '+'), + h('button', { class: 'btn', type: 'button', 'aria-label': '+10', onclick: () => step(10) }, '+10'))); + body.appendChild(h('button', { class: 'btn small wide', type: 'button', onclick: () => { count = Math.max(1, maxAffordable()); els.input.value = String(count); live(); } }, App.t('units.max'))); + els.costs = h('div', { class: 'costs' }); + els.time = h('b'); + els.done = h('span', { class: 'dimmer' }); + body.appendChild(h('h3', { class: 'sub', text: App.t('sheet.cost') })); + body.appendChild(els.costs); + body.appendChild(h('div', { class: 'row meta' }, icon('clock'), h('span', { text: App.t('units.time') + ': ' }), els.time, els.done)); + els.reason = h('p', { class: 'reason', 'aria-live': 'polite' }); + els.btn = h('button', { class: 'btn primary wide', type: 'button', onclick: go }, icon('units'), h('span', { text: App.t('units.trainBtn') })); + body.appendChild(els.reason); body.appendChild(els.btn); + + function live() { + const p = plan(); + if (!p) return; + const cur = App.resourcesNow(); + clear(els.costs); + for (const r of D.RESOURCES) { + const short = cur && cur.amounts[r] + 1e-6 < p.cost[r]; + els.costs.appendChild(h('span', { class: 'cost ' + r + (short ? ' short' : '') }, icon(r), h('b', { text: num(p.cost[r]) }), cur ? h('small', { text: App.t('sheet.have', { n: num(cur.amounts[r]) }) }) : null)); + } + els.time.textContent = App.fmt.dur(p.durationMs); + els.done.textContent = ' · ' + App.t('units.readyAt', { t: mil().clockTime(p.dueAt) }); + let reason = ''; + if (!p.ok) { + reason = App.t('err.' + p.code); + if (p.code === 'requirements_not_met' && p.missing && p.missing.length) reason += ' ' + p.missing.map((x) => App.buildingName(x.type) + ' ' + App.t('pop.level', { n: x.level })).join(', '); + } + els.reason.textContent = reason; els.reason.hidden = !reason; + els.btn.disabled = !p.ok || busy; + } + async function go() { + if (busy) return; + busy = true; els.btn.disabled = true; + const t = td(); + try { + await App.api.post('/towns/' + t.id + '/train', { unit, count }, { intent: 'train:' + t.id + ':' + unit + ':' + count }); + toast(App.t('units.queued', { n: num(count), unit: mil().unitName(unit) }), 'ok'); + ctl.close(); + await App.refreshTown(); + } catch (e) { + toast(App.errMsg(e), 'error'); + busy = false; + App.refreshTown().catch(() => {}); + live(); + } + } + off = App.onTick(() => { if (!busy) live(); }); + live(); + } + + // ------------------------------------------------------------------ research + function researchCard(m) { + const levels = m.research.levels; + const q = m.research.queue; + const head = h('div', { class: 'card-head' }, h('h2', null, icon('flask'), App.t('units.research')), + m.research.speedBonus > 0 ? h('span', { class: 'pill green', text: App.t('units.research.speed', { p: Math.round(m.research.speedBonus * 100) }) }) : null); + const busy = q ? h('div', { class: 'detail-queue' }, + h('div', { class: 'row' }, h('span', { text: App.t('units.research.busy', { unit: mil().unitName(q.unit), stat: App.t('stat.' + q.stat), level: q.toLevel }) }), mil().countdown(q.dueAt)), + h('div', { class: 'bar' }, h('i', { dataset: { rs: '1' } }))) : null; + const rows = D.UNIT_ORDER.filter((u) => D.UNITS[u].attack > 0 || D.UNITS[u].defence > 0).map((u) => { + const a = levels[R.researchKey(u, 'attack')] || 0, d = levels[R.researchKey(u, 'defence')] || 0; + return h('li', null, h('button', { class: 'row-btn', type: 'button', onclick: () => openResearch(u) }, + h('span', { class: 'row-ic' }, mil().unitIcon(u)), + h('span', { class: 'row-main' }, h('span', { class: 'row-title' }, h('b', { text: mil().unitName(u) })), + h('span', { class: 'row-sub wrap', text: App.t('stat.attack') + ' ' + a + ' · ' + App.t('stat.defence') + ' ' + d })), + h('span', { class: 'pill', text: '+' + Math.round((a + d) * D.MILITARY.researchPerLevel * 100) + '%' }))); + }); + return h('section', { class: 'card' }, head, busy, h('ul', { class: 'mil-list' }, rows)); + } + + function openResearch(unit) { + const body = h('div', { class: 'detail' }); + let off = null; + const ctl = openSheet({ title: mil().unitName(unit), icon: 'flask', closeLabel: App.t('common.close'), body, onClose: () => { if (off) off(); } }); + let busy = false; + const def = D.UNITS[unit]; + const parts = {}; + + function build() { + clear(body); + const m = mi(); + body.appendChild(h('p', { class: 'detail-desc', text: App.t('units.research.hint', { p: Math.round(D.MILITARY.researchPerLevel * 100), max: D.RESEARCH.maxLevel }) })); + for (const stat of D.RESEARCH.stats) { + if (!(def[stat] > 0)) continue; + const level = m.research.levels[R.researchKey(unit, stat)] || 0; + const sec = h('section', { class: 'card inner' }); + sec.appendChild(h('div', { class: 'card-head' }, h('h2', { text: App.t('stat.' + stat) }), + h('span', { class: 'pill', text: App.t('units.research.level', { n: level, max: D.RESEARCH.maxLevel }) }))); + if (level >= D.RESEARCH.maxLevel) { sec.appendChild(h('p', { class: 'empty', text: App.t('sheet.maxed') })); body.appendChild(sec); continue; } + const costs = h('div', { class: 'costs' }), reason = h('p', { class: 'reason', 'aria-live': 'polite' }), time = h('b'); + const btn = h('button', { class: 'btn primary wide', type: 'button', onclick: () => go(stat, btn) }, icon('flask'), h('span', { text: App.t('units.research.start', { n: level + 1 }) })); + sec.appendChild(h('p', { class: 'preview', text: App.t('units.research.effect', { a: val(def[stat] * R.researchMult(level)), b: val(def[stat] * R.researchMult(level + 1)) }) })); + sec.appendChild(costs); + sec.appendChild(h('div', { class: 'row meta' }, icon('clock'), h('span', { text: App.t('units.research.time') + ': ' }), time)); + sec.appendChild(reason); sec.appendChild(btn); + parts[stat] = { level, costs, reason, time, btn }; + body.appendChild(sec); + } + live(); + } + function live() { + const m = mi(), rt = App.rulesTown(); + if (!m || !rt) return; + const cur = App.resourcesNow(); + for (const stat of Object.keys(parts)) { + const p = parts[stat]; + const plan = R.researchPlan(rt, unit, stat, p.level, !!m.research.queue, App.now(), m.research.speedBonus); + clear(p.costs); + for (const r of D.RESOURCES) p.costs.appendChild(h('span', { class: 'cost ' + r + (cur && cur.amounts[r] + 1e-6 < plan.cost[r] ? ' short' : '') }, icon(r), h('b', { text: num(plan.cost[r]) }))); + p.time.textContent = App.fmt.dur(plan.durationMs); + let reason = ''; + if (!plan.ok) { + reason = App.t('err.' + plan.code); + if (plan.code === 'requirements_not_met' && plan.missing && plan.missing.length) reason += ' ' + plan.missing.map((x) => App.buildingName(x.type) + ' ' + App.t('pop.level', { n: x.level })).join(', '); + } + p.reason.textContent = reason; p.reason.hidden = !reason; + p.btn.disabled = !plan.ok || busy; + } + } + async function go(stat, btn) { + if (busy) return; + busy = true; btn.disabled = true; + const t = td(); + try { + await App.api.post('/towns/' + t.id + '/research', { unit, stat }, { intent: 'research:' + t.id + ':' + unit + ':' + stat }); + toast(App.t('units.research.queued'), 'ok'); + ctl.close(); + await App.refreshTown(); + } catch (e) { + toast(App.errMsg(e), 'error'); + busy = false; + App.refreshTown().then(() => build()).catch(() => {}); + } + } + build(); + off = App.onTick(live); + } + + // ------------------------------------------------------------------ screen + function head() { + return h('div', { class: 'card-head page-head units-head' }, h('h1', { text: App.t('screen.units') }), + h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('common.retry'), onclick: () => App.refreshTown().catch((e) => toast(App.errMsg(e), 'error')) }, icon('refresh'))); + } + + function draw() { + dirty = false; + clear(bodyEl); + const t = td(), m = mi(); + if (!App.state.townId) { bodyEl.appendChild(h('p', { class: 'empty pad', text: App.t('pop.noTown') })); return; } + if (!t || !m) { bodyEl.appendChild(h('div', { class: 'boot' }, h('div', { class: 'spinner', 'aria-hidden': 'true' }), h('p', { text: App.t('common.loading') }))); return; } + bodyEl.appendChild(head()); + bodyEl.appendChild(h('div', { class: 'cols' }, + h('div', { class: 'col' }, statusCard(m), homeCard(m), stationedCards(m)), + h('div', { class: 'col' }, trainingCard(m), researchCard(m)))); + tick(App.now()); + } + + function tick(now) { + const m = mi(); + if (!m || !bodyEl) return; + for (const li of bodyEl.querySelectorAll('li.batch')) { + const b = li._b; + if (!b) continue; + li._bar.style.setProperty('--p', String(Math.max(0, Math.min(1, (now - b.startAt) / Math.max(1, b.dueAt - b.startAt))))); + } + const rs = bodyEl.querySelector('[data-rs]'); + if (rs && m.research.queue) rs.style.setProperty('--p', String(Math.max(0, Math.min(1, (now - m.research.queue.startedAt) / Math.max(1, m.research.queue.dueAt - m.research.queue.startedAt))))); + // something came due: refetch (with a gentle retry, like the build queue) + const items = m.training.map((b) => ({ id: 't' + b.id, due: b.dueAt })).concat(m.research.queue ? [{ id: 'r' + m.research.queue.id, due: m.research.queue.dueAt }] : []); + for (const it of items) { + if (now - it.due < 300) continue; + const tries = refetch.get(it.id) || { n: 0, at: 0 }; + if (Date.now() >= tries.at) { refetch.set(it.id, { n: tries.n + 1, at: Date.now() + Math.min(10000, 1500 * (tries.n + 1)) }); App.refreshTown().catch(() => {}); } + } + } + + App.registerScreen({ + id: 'units', titleKey: 'screen.units', navKey: 'nav.units', icon: 'units', hud: true, + render(container) { + box = container; + bodyEl = h('div', { class: 'units-body' }); + box.appendChild(bodyEl); + App.on('town', () => { if (visible) draw(); else dirty = true; }); + App.on('townchange', () => { dirty = true; if (visible) draw(); }); + App.on('session', () => { dirty = true; refetch.clear(); }); + App.on('towns', () => { if (visible) draw(); else dirty = true; }); + }, + onShow() { + visible = true; + draw(); + if (offTick) offTick(); + offTick = App.onTick(tick); + if (td() && Date.now() - App.state.townFetchedAt > 15000) App.refreshTown().catch(() => {}); + }, + onHide() { visible = false; if (offTick) offTick(); offTick = null; closeSheet(); }, + }); +}()); diff --git a/public/js/social.js b/public/js/social.js new file mode 100644 index 0000000..c443c6c --- /dev/null +++ b/public/js/social.js @@ -0,0 +1,111 @@ +'use strict'; +/* + * Pure client logic of the social screens (alliance, messages, rankings): no DOM, no I/O, no clocks. Loads as a browser + * script (window.UpstreamSocial) and as a Node module (test/client-social.test.js). Permissions and diplomacy moves are + * never re-implemented here: they come from rules.js (allianceCan, outranks, diplomacyMove) over the tables in data.js, so + * the buttons the screens show are exactly the ones the server would accept. The server still checks everything. + */ +(function (root, factory) { + if (typeof module === 'object' && module.exports) module.exports = factory(require('./rules.js'), require('./data.js')); + else root.UpstreamSocial = factory(root.UpstreamRules, root.UpstreamData); +}(typeof self !== 'undefined' ? self : this, function (R, D) { + const S = D.SOCIAL; + + // What the viewer may do in their own alliance (role from GET /alliances/mine). `memberCount` decides whether a leader + // can simply leave (alone: the alliance is disbanded) or must hand over leadership first. + function selfActions(role, memberCount) { + const can = (a) => !!role && R.allianceCan(role, a); + return { + invite: can('invite'), viewInvites: can('viewInvites'), cancelInvite: can('cancelInvite'), + editNotes: can('editNotes'), diplomacy: can('diplomacy'), broadcast: can('broadcast'), + disband: can('disband'), transfer: can('transfer'), setRole: can('setRole'), + leave: !!role, leaveNeedsTransfer: role === 'leader' && memberCount > 1, + }; + } + + // What the viewer may do to one listed member. `kick` needs the permission AND a strictly higher rank; roles are set by the + // leader to diplomat/officer/member only (leadership moves through `transfer`). + function memberActions(myRole, member, myOperatorId) { + const self = member.operatorId === myOperatorId; + const settable = S.roles.filter((r) => r !== 'leader'); + return { + self, + message: !self, + kick: !self && !!myRole && R.allianceCan(myRole, 'kick') && R.outranks(myRole, member.role), + roles: !self && !!myRole && R.allianceCan(myRole, 'setRole') && member.role !== 'leader' ? settable.filter((r) => r !== member.role) : [], + transfer: !self && !!myRole && R.allianceCan(myRole, 'transfer'), + }; + } + + // Relation of the own alliance to another: `relations` is the list of GET /alliances/:id/diplomacy. No row = neutral. + function relationTo(relations, otherId) { + const r = (relations || []).find((x) => x.other && x.other.id === otherId); + return r ? { state: r.state, since: r.since, pending: r.pending || null } : { state: 'neutral', since: null, pending: null }; + } + + // Moves offered from the current state: [{ state, kind: 'immediate' | 'proposal' | 'delayed' }]. A pair with a scheduled + // change is locked (the server answers diplomacy_pending), so nothing is offered. + function diplomacyOptions(current, pending) { + if (pending) return []; + return S.diplomacyStates.filter((s) => s !== current && R.diplomacyMove(current, s)).map((s) => ({ state: s, kind: R.diplomacyMove(current, s) })); + } + + // Milliseconds until a scheduled pact change takes effect (never negative). + const pendingRemaining = (pending, now) => (pending ? Math.max(0, pending.effectiveAt - now) : 0); + + // Characters as the server counts them (code points, CRLF folded to LF). The server also strips control characters, so the + // counter can only over-count, never let through something the server then refuses for length. + function charCount(text) { return Array.from(String(text == null ? '' : text).replace(/\r\n?/g, '\n')).length; } + + function composeState(text, max) { + max = max || S.messageMax; + const n = charCount(text); + return { n, left: max - n, over: n > max, empty: !String(text == null ? '' : text).trim(), max }; + } + + // Seconds to show for a rate_limited error (details.retryAfter / Retry-After, already parsed into err.retryAfter). + const retrySeconds = (err) => Math.max(1, Math.ceil((err && err.retryAfter) || 1)); + + // Messages are listed newest first with `after` = the last id, so the next page holds OLDER ids. Merge without duplicates, + // keep newest first. + function mergeMessages(existing, incoming) { + const seen = new Set(existing.map((m) => m.id)); + return existing.concat(incoming.filter((m) => !seen.has(m.id))).sort((a, b) => b.id - a.id); + } + + // A conversation reads oldest to newest. + const chronological = (items) => items.slice().sort((a, b) => a.id - b.id); + + // The other party of a direct message from the viewer's side. + const peerOf = (m) => (m.direction === 'out' ? m.to : m.from); + + // Received, not yet read direct or broadcast messages among `items`. + const unreadIds = (items) => items.filter((m) => m.direction === 'in' && !m.readAt).map((m) => m.id); + + // Rankings page by rank offset: the cursor is the number of ranks already seen. Merge by rank so a refetch does not duplicate. + function mergeRanks(existing, incoming) { + const seen = new Set(existing.map((r) => r.rank)); + return existing.concat(incoming.filter((r) => !seen.has(r.rank))).sort((a, b) => a.rank - b.rank); + } + + // Is this ranking row the viewer's own (kind: 'operators' | 'alliances' | 'battles')? + function isYou(kind, row, you) { + if (!you || !row) return false; + return kind === 'alliances' ? row.allianceId === you.allianceId : row.operatorId === you.operatorId; + } + + // Battle ranking value for the tab (attack, defense or total). + const battlePoints = (row, by) => (by === 'defense' ? row.defensePoints : by === 'total' ? row.attackPoints + row.defensePoints : row.attackPoints); + + // Where to put a number-or-null "last online": ms since, or null when unknown. + const sinceMs = (at, now) => (at ? Math.max(0, now - at) : null); + + // Operator names may be typed or pasted: trim and collapse so " Bob " matches. The server looks names up case-insensitively. + const cleanName = (s) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim(); + + return { + selfActions, memberActions, relationTo, diplomacyOptions, pendingRemaining, + charCount, composeState, retrySeconds, mergeMessages, chronological, peerOf, unreadIds, + mergeRanks, isYou, battlePoints, sinceMs, cleanName, + }; +})); diff --git a/public/js/strings/README.md b/public/js/strings/README.md new file mode 100644 index 0000000..e4cd63c --- /dev/null +++ b/public/js/strings/README.md @@ -0,0 +1,13 @@ +Per-area string files. Each is a browser script AND a Node module: + +```js +'use strict'; +(function (root, factory) { + if (typeof module === 'object' && module.exports) factory(require('../i18n.js')); + else factory(root.UpstreamI18n); +}(typeof self !== 'undefined' ? self : this, function (I) { + I.extend({ en: { 'units.title': 'Units' }, nb: { 'units.title': 'Enheter' } }); +})); +``` + +Load it from index.html after i18n.js. test/client-i18n.test.js requires every .js here and enforces en/nb key parity. diff --git a/public/js/strings/military.js b/public/js/strings/military.js new file mode 100644 index 0000000..7ef5c3b --- /dev/null +++ b/public/js/strings/military.js @@ -0,0 +1,251 @@ +'use strict'; +/* Strings of the military / expansion screens (units, movements, reports, send dialog, expansion) in en + nb. */ +(function (root, factory) { + if (typeof module === 'object' && module.exports) factory(require('../i18n.js')); + else factory(root.UpstreamI18n); +}(typeof self !== 'undefined' ? self : this, function (I) { + I.extend({ + en: { + 'nav.more': 'More', 'nav.units': 'Units', 'nav.movements': 'Moves', 'nav.reports': 'Reports', + 'screen.units': 'Units', 'screen.movements': 'Movements', 'screen.reports': 'Reports', + + // ---- unit names and descriptions (ids are generic, names live here) + 'unit.port_scanner.name': 'Port scanner', 'unit.port_scanner.desc': 'Quiet little probes. Scout a POP before you commit anything expensive.', + 'unit.soc_analyst.name': 'SOC analyst', 'unit.soc_analyst.desc': 'Staring at dashboards so you do not have to. Cheap, steady defence.', + 'unit.blue_team.name': 'Blue team', 'unit.blue_team.desc': 'Incident response with proper coffee. Strong defenders.', + 'unit.honeypot.name': 'Honeypot', 'unit.honeypot.desc': 'A very attractive, very fake server. Defends in place and never leaves.', + 'unit.script_crew.name': 'Script crew', 'unit.script_crew.desc': 'Cheap, fast raiders that carry some loot home.', + 'unit.botnet.name': 'Botnet', 'unit.botnet.desc': 'Many small machines with one bad idea. Strong, fast, carries a lot.', + 'unit.ddos_rig.name': 'DDoS rig', 'unit.ddos_rig.desc': 'Floods the firewall. Every 10 rigs lower the target firewall by one level.', + 'unit.exploit_kit.name': 'Exploit kit', 'unit.exploit_kit.desc': 'Finds the one unpatched thing. Damages a chosen building when you win.', + 'unit.rollout_crew.name': 'Rollout crew', 'unit.rollout_crew.desc': 'Trenches, ducts and optimism. Three of them found a new POP.', + 'unit.ma_team.name': 'M&A team', 'unit.ma_team.desc': 'Suits with a term sheet. Wears down customer loyalty until the POP changes hands.', + 'unit.stats': 'ATK {a} · DEF {d} · {s} tiles/h · carries {c}', 'unit.fixed': 'stays in place', 'unit.draw': 'Power draw {n}/h', + 'stat.attack': 'Attack', 'stat.defence': 'Defence', + + 'move.type.scan': 'Scan', 'move.type.raid': 'Phishing raid', 'move.type.attack': 'Attack', 'move.type.takeover': 'Hostile takeover', + 'move.type.reinforce': 'Peering support', 'move.type.settle': 'Found a POP', 'move.type.transport': 'Transport', 'move.type.return': 'Returning home', 'move.type.unknown': 'Unknown', + 'report.type.raid': 'Phishing raid', 'report.type.attack': 'Attack', 'report.type.takeover': 'Hostile takeover', 'report.type.scan': 'Scan', + 'report.type.scan_detected': 'Scan detected', 'report.type.incumbent': 'Incumbent site', 'report.type.settle': 'New POP', 'report.type.reinforce': 'Reinforcements', + 'report.type.movement_failed': 'Movement failed', + + 'mil.showOnMap': 'Show {x}, {y} on the map', + + // ---- units screen + 'units.status': 'Status', 'units.online': 'Online', 'units.powerNet': 'Net power {n}/h', + 'units.offline.title': 'Units offline', 'units.offline.body': 'The battery is empty, so your units are switched off and cannot be sent. Add power (Substation) or get rid of draw.', + 'units.offline.decom': 'Units are decommissioned in', + 'units.home': 'At home', 'units.home.empty': 'No units here yet. Train some below.', + 'units.hosted': 'Reinforcements here', 'units.away': 'Your units elsewhere', + 'units.sendHome': 'Send home', 'units.callBack': 'Call back', 'units.withdrawn': 'On their way home.', + 'units.training': 'Training', 'units.training.empty': 'Nothing in training.', 'units.train': 'Train units', + 'units.needs': 'Needs', 'units.perUnit': '{t} each', 'units.count': 'Number of units', 'units.max': 'As many as I can afford', + 'units.trainBtn': 'Train', 'units.time': 'Training time', 'units.research.time': 'Research time', 'units.readyAt': 'ready {t}', 'units.queued': 'Queued {n} × {unit}.', + 'units.research': 'Research', 'units.research.speed': '+{p}% research speed', + 'units.research.busy': 'Researching {unit}: {stat} level {level}', + 'units.research.hint': 'Each level gives +{p}% attack or defence for this unit type, up to level {max}. One research at a time per POP.', + 'units.research.level': 'Level {n} / {max}', 'units.research.effect': 'Per unit: {a} → {b}', 'units.research.start': 'Research level {n}', 'units.research.queued': 'Research started.', + + // ---- movements screen + POP banner + push + 'mov.send': 'Send', 'mov.empty': 'Nothing on the wire. Pick a target on the map and send something.', + 'mov.incoming.head': 'Incoming movements ({n})', 'mov.incoming.title': 'Heading for {town}', + 'mov.incoming.from': 'From {operator}', 'mov.incoming.hint': 'Type and size are hidden. Treat it as hostile: raise defence or bring reinforcements.', + 'mov.outgoing.head': 'Your movements', 'mov.target': 'Target building: {name}', + 'mov.recall': 'Recall', 'mov.recalled': 'Recalled. They are turning around.', + 'mov.allied.head': 'Heading for allied POPs', 'mov.allied.title': '{operator}: {town}', + 'mov.banner.title': 'Incoming movement ({n})', 'mov.banner.next': 'Next one heads for {town}, from {operator}.', 'mov.banner.in': 'Arrives in', 'mov.banner.details': 'Details', + 'push.incoming': 'Incoming movement spotted!', + + // ---- send dialog + 'send.title': 'Send', 'send.open': 'Send units here', 'send.target': 'Target', 'send.lookup': 'Look up', 'send.from': 'Send from', + 'send.what': 'What to do', 'send.nothing': 'There is nothing to send to this tile.', 'send.units': 'Units', 'send.all': 'All', + 'send.cargo': 'Cargo', 'send.cargo.cap': 'Up to {n} per transport. {free} of {links} transport links free.', + 'send.tilesPerHour': 'tiles/h', 'send.pickSome': 'Pick some units to see latency and arrival.', + 'send.distance': 'Distance', 'send.latency': 'Latency', 'send.arrives': 'Arrives about', 'send.slowest': 'Slowest unit', 'send.carry': 'Carries loot', + 'send.go': 'Send', 'send.sent': '{type} sent. Latency {t}.', + 'send.reason.no_units': 'no suitable units at home', 'send.reason.target_protected': 'target is under beginner protection', + 'send.reason.not_allied': 'not in your alliance', 'send.reason.no_link': 'needs an Internet exchange', 'send.reason.links_busy': 'all transport links are busy', + 'send.reason.needs_ma_team': 'needs at least one M&A team', 'send.reason.needs_crews': 'needs three Rollout crews at home', + 'send.reason.footprint': 'footprint {have} is below the {need} needed', 'send.reason.range': 'must be within {n} tiles of one of your POPs', 'send.reason.cannotSettle': 'only empty land can be settled', + 'send.settle.title': 'New POP', 'send.settle.crews': '{n} × {unit} will go and are used up.', + 'send.settle.footprint': 'Footprint {have}, {need} needed. Within {n} tiles of one of your POPs.', 'send.settle.wild': 'Wild field {n}', + 'send.protection.title': 'This ends your beginner protection.', 'send.protection.body': 'You are protected until {t}. Attacking gives that up for good. Tick to confirm.', 'send.protection.need': 'Confirm that you give up your beginner protection.', + 'send.siege': 'Exploit kits: building to damage', 'send.siege.none': 'No preference', 'send.siege.hint': 'Needs at least {n} kits left after the fight to damage anything.', + 'send.takeover.hint': 'An M&A team lowers customer loyalty on every win. At zero the POP is yours. Capitals and last POPs cannot be taken.', + 'send.raid.hint': 'A raid steals Capital, Fiber and Hardware up to what the survivors carry. Both sides lose fewer units than in an attack.', + 'send.scan.hint': 'Scanners come back if they survive. More scanners than the defender gets you more detail.', + 'send.reinforce.own': 'Units move into that POP and defend it. Pull them back from the Units screen.', + 'send.hostile.hint': 'The target is warned that something is coming, but not what.', + 'send.invalid.own_town': 'You cannot target yourself.', 'send.invalid.nothing_there': 'There is nothing there to target.', 'send.invalid.pact': 'A pact prevents that.', + 'send.invalid.not_allied': 'Only alliance members and confederates can be reinforced.', 'send.invalid.no_town': 'No POP there.', 'send.invalid.occupied': 'That tile is taken.', + 'send.invalid.not_empty_land': 'Only empty land can be settled.', 'send.invalid.outside_map': 'That is off the map.', 'send.invalid.same_town': 'Pick a different POP.', + 'send.invalid.incumbent_scan_or_attack_only': 'Incumbent sites can only be scanned or attacked.', + + // ---- reports + 'rep.empty': 'No reports yet.', 'rep.markAll': 'Mark all read', 'rep.older': 'Older reports', + 'rep.victory': 'Victory', 'rep.defeat': 'Defeat', 'rep.captured': 'POP captured', + 'rep.sub.you_vs': 'You vs {name}', 'rep.sub.by': 'By {name}', + 'rep.scan.title': 'Scan of {where}', 'rep.scan.ok': 'Scan succeeded', 'rep.scan.failed': 'Scan failed', 'rep.scan.noIntel': 'The defender spotted your scanners before they learned anything.', + 'rep.scan.strength': 'Scan strength (you vs them)', + 'rep.detected.title': 'Scan detected at {town}', 'rep.detected.unknown': 'Somebody scanned this POP. Your scanners could not tell who.', + 'rep.incumbent.title': 'Incumbent site {x}, {y}', 'rep.incumbent.bonus': 'First win here pays {n} Hardware.', 'rep.incumbent.taken': 'You already took this site.', 'rep.incumbent.reward': 'Reward', + 'rep.settle.title': 'New POP: {name}', 'rep.settle.wild': 'Wild fields', 'rep.settle.open': 'Open the new POP', 'rep.settle.hint': 'It starts with a little Fiber, Hardware and Capital and no infrastructure. Build it up.', + 'rep.reinforce.sender': 'Reinforcements arrived at {town}', 'rep.reinforce.target': 'Reinforcements arrived at {town}', + 'rep.failed.title': '{type} failed', 'rep.failed.home': 'Units and cargo are on their way home.', + 'rep.reason.invalid_target': 'The target is no longer valid.', 'rep.reason.not_allied': 'The target is no longer an ally.', 'rep.reason.own_town': 'The POP changed hands and is yours now.', + 'rep.reason.pact': 'A pact with the target now prevents this.', 'rep.reason.protected': 'The target is under beginner protection.', 'rep.reason.target_gone': 'The target is gone.', + 'rep.reason.out_of_range': 'The site is out of range.', 'rep.reason.footprint_too_low': 'Your footprint was too low.', + 'rep.role.attacker': 'You attacked', 'rep.role.defender': 'You were attacked', 'rep.role.reinforcer': 'Your reinforcements were there', 'rep.role.sender': 'You sent', 'rep.role.target': 'You were the target', + 'rep.expires': 'kept until {t}', 'rep.arrived': 'Arrived {t}', + 'rep.attacker': 'Attacker', 'rep.defender': 'Defender', 'rep.target': 'Target', 'rep.from': 'From', 'rep.host': 'Host', 'rep.site': 'Site', 'rep.scannedBy': 'Scanned by', + 'rep.power': 'Strength', 'rep.power.attack': 'Attack', 'rep.power.defence': 'Defence', 'rep.power.firewall': 'Firewall level', + 'rep.attackerUnits': 'Attacking units', 'rep.defenderUnits': 'Defending units', 'rep.units': 'Units', 'rep.scanners': 'Scanners', + 'rep.sent': 'Sent', 'rep.lost': 'Lost', 'rep.left': 'Left', 'rep.noUnits': 'No units.', + 'rep.group.home': 'Home defence', 'rep.group.reinf': 'Reinforcements from {town}', 'rep.group.offline': 'offline, no defence', + 'rep.loot': 'Loot', 'rep.cache': '{p}% of the stock was hidden in the Rack hall.', 'rep.siege': 'Siege', 'rep.siege.line': '{name} damaged: level {a} → {b}', + 'rep.takeover': 'Takeover', 'rep.takeover.loyalty': 'Customer loyalty', 'rep.takeover.capital': 'A capital cannot change hands, it can only be drained.', 'rep.takeover.captured': 'The POP is now under new ownership.', + 'rep.takeover.blocked.last_pop': 'The target\'s last POP cannot be taken.', 'rep.takeover.blocked.footprint': 'Your footprint is too low to hold another POP.', + 'rep.intel': 'Intel', 'rep.intel.resources': 'Resources in stock', 'rep.intel.units': 'Units', 'rep.intel.offline': 'Their units are offline.', 'rep.intel.buildings': 'Buildings', 'rep.intel.outgoing': 'Their movements', + + // ---- notification feed + 'alerts.incoming': 'Incoming movement', 'alerts.incoming.at': 'Heading for {town}, arrives {time}', + 'alerts.report': 'New report: {type}', 'alerts.train_done': '{n} × {unit} trained', 'alerts.research_done': '{unit}: {stat} level {level} researched', + 'alerts.movement_returned': 'Units are home', 'alerts.movement_lost': 'A movement lost its way home', + 'alerts.transport_arrived': 'Cargo arrived at {town}', 'alerts.transport_delivered': 'Your cargo was delivered', + 'alerts.units_offline': 'Units went offline: battery empty', 'alerts.units_decommissioned': 'Units decommissioned after too long without power', + 'alerts.town_lost': '{name} was taken over', 'alerts.town_lost.by': 'By {name}', 'alerts.town_gained': '{name} is now yours', 'alerts.reinforcements_home': 'Reinforcements sent home', + + // ---- expansion + 'exp.title': 'Expansion', 'exp.count': '{n} POPs', 'exp.crews': 'Rollout crews at home', 'exp.footprint': 'Footprint (this POP / needed in total)', 'exp.footprint.v': '{have} / {need}', + 'exp.range': 'Range from your POPs', 'exp.hint': 'Three Rollout crews found a POP on empty land. A new POP also needs enough total footprint.', + 'exp.found': 'Pick a site on the map', 'exp.pick': 'Tap an empty tile and choose Send units here.', 'exp.train': 'Train Rollout crews', 'exp.needCrews': 'Train {n} more {unit}.', + 'exp.needDepot': 'Needs a Rollout depot (Core router level 10).', 'exp.pops': 'Your POPs', 'exp.current': 'Viewing', 'exp.open': 'Switch to', + 'map.legend.out': 'Your movement', 'map.legend.in': 'Incoming', + + // ---- errors of the military routes + 'err.not_enough_units': 'Not enough of those units at home.', 'err.units_offline': 'Your units are offline: the battery is empty.', + 'err.invalid_target': 'That target does not work.', 'err.target_protected': 'The target is under beginner protection.', + 'err.protection_active': 'You are under beginner protection. Confirm that attacking ends it.', 'err.out_of_range': 'That is too far from your POPs.', + 'err.footprint_too_low': 'Your footprint is too low for another POP.', 'err.cannot_takeover': 'That POP cannot be taken over.', + 'err.capacity_exceeded': 'That is more than one transport can carry.', 'err.no_transport_link': 'No free transport link: build or wait for an Internet exchange.', + 'err.unknown_unit': 'No such unit.', 'err.not_researchable': 'That cannot be researched.', 'err.recall_expired': 'Too late to recall: the first 90 seconds are over.', + }, + nb: { + 'nav.more': 'Mer', 'nav.units': 'Enheter', 'nav.movements': 'Ferd', 'nav.reports': 'Rapporter', + 'screen.units': 'Enheter', 'screen.movements': 'Bevegelser', 'screen.reports': 'Rapporter', + + 'unit.port_scanner.name': 'Portskanner', 'unit.port_scanner.desc': 'Stille små sonder. Speid en POP før du satser noe dyrt.', + 'unit.soc_analyst.name': 'SOC-analytiker', 'unit.soc_analyst.desc': 'Stirrer på dashbord så du slipper. Billig og stødig forsvar.', + 'unit.blue_team.name': 'Blått lag', 'unit.blue_team.desc': 'Hendelseshåndtering med skikkelig kaffe. Sterke forsvarere.', + 'unit.honeypot.name': 'Honeypot', 'unit.honeypot.desc': 'En svært fristende og svært falsk server. Forsvarer på stedet og går aldri noe sted.', + 'unit.script_crew.name': 'Skriptmannskap', 'unit.script_crew.desc': 'Billige, raske raidere som bærer med seg litt bytte hjem.', + 'unit.botnet.name': 'Botnett', 'unit.botnet.desc': 'Mange små maskiner med én dårlig idé. Sterkt, raskt og bærer mye.', + 'unit.ddos_rig.name': 'DDoS-rigg', 'unit.ddos_rig.desc': 'Flommer brannmuren. Hver 10. rigg senker målets brannmur ett nivå.', + 'unit.exploit_kit.name': 'Exploit-sett', 'unit.exploit_kit.desc': 'Finner den ene upatchede tingen. Skader en valgt bygning når du vinner.', + 'unit.rollout_crew.name': 'Utrullingslag', 'unit.rollout_crew.desc': 'Grøfter, rør og optimisme. Tre av dem etablerer en ny POP.', + 'unit.ma_team.name': 'Oppkjøpsteam', 'unit.ma_team.desc': 'Dress og en intensjonsavtale. Sliter ned kundelojaliteten til POP-en skifter eier.', + 'unit.stats': 'ANG {a} · FOR {d} · {s} ruter/t · bærer {c}', 'unit.fixed': 'blir stående', 'unit.draw': 'Strømtrekk {n}/t', + 'stat.attack': 'Angrep', 'stat.defence': 'Forsvar', + + 'move.type.scan': 'Skanning', 'move.type.raid': 'Phishing-raid', 'move.type.attack': 'Angrep', 'move.type.takeover': 'Fiendtlig oppkjøp', + 'move.type.reinforce': 'Peering-støtte', 'move.type.settle': 'Etabler POP', 'move.type.transport': 'Transport', 'move.type.return': 'På vei hjem', 'move.type.unknown': 'Ukjent', + 'report.type.raid': 'Phishing-raid', 'report.type.attack': 'Angrep', 'report.type.takeover': 'Fiendtlig oppkjøp', 'report.type.scan': 'Skanning', + 'report.type.scan_detected': 'Skanning oppdaget', 'report.type.incumbent': 'Gammeloperatørens anlegg', 'report.type.settle': 'Ny POP', 'report.type.reinforce': 'Forsterkninger', + 'report.type.movement_failed': 'Bevegelse mislyktes', + + 'mil.showOnMap': 'Vis {x}, {y} på kartet', + + 'units.status': 'Status', 'units.online': 'Online', 'units.powerNet': 'Netto strøm {n}/t', + 'units.offline.title': 'Enheter offline', 'units.offline.body': 'Batteriet er tomt, så enhetene er slått av og kan ikke sendes. Legg til strøm (Transformatorstasjon) eller kutt trekk.', + 'units.offline.decom': 'Enhetene avvikles om', + 'units.home': 'Hjemme', 'units.home.empty': 'Ingen enheter her ennå. Tren noen under.', + 'units.hosted': 'Forsterkninger her', 'units.away': 'Dine enheter andre steder', + 'units.sendHome': 'Send hjem', 'units.callBack': 'Kall tilbake', 'units.withdrawn': 'På vei hjem.', + 'units.training': 'Trening', 'units.training.empty': 'Ingenting under trening.', 'units.train': 'Tren enheter', + 'units.needs': 'Krever', 'units.perUnit': '{t} per stk.', 'units.count': 'Antall enheter', 'units.max': 'Så mange jeg har råd til', + 'units.trainBtn': 'Tren', 'units.time': 'Treningstid', 'units.research.time': 'Forskningstid', 'units.readyAt': 'ferdig {t}', 'units.queued': 'Satt i kø: {n} × {unit}.', + 'units.research': 'Forskning', 'units.research.speed': '+{p} % forskningsfart', + 'units.research.busy': 'Forsker på {unit}: {stat} nivå {level}', + 'units.research.hint': 'Hvert nivå gir +{p} % angrep eller forsvar for denne enhetstypen, opptil nivå {max}. Én forskning om gangen per POP.', + 'units.research.level': 'Nivå {n} / {max}', 'units.research.effect': 'Per enhet: {a} → {b}', 'units.research.start': 'Forsk nivå {n}', 'units.research.queued': 'Forskning startet.', + + 'mov.send': 'Send', 'mov.empty': 'Ingenting på vei. Velg et mål på kartet og send noe.', + 'mov.incoming.head': 'Innkommende bevegelser ({n})', 'mov.incoming.title': 'På vei mot {town}', + 'mov.incoming.from': 'Fra {operator}', 'mov.incoming.hint': 'Type og størrelse er skjult. Anta at det er fiendtlig: styrk forsvaret eller hent forsterkninger.', + 'mov.outgoing.head': 'Dine bevegelser', 'mov.target': 'Målbygning: {name}', + 'mov.recall': 'Kall tilbake', 'mov.recalled': 'Kalt tilbake. De snur.', + 'mov.allied.head': 'På vei mot allierte POP-er', 'mov.allied.title': '{operator}: {town}', + 'mov.banner.title': 'Innkommende bevegelse ({n})', 'mov.banner.next': 'Den neste går mot {town}, fra {operator}.', 'mov.banner.in': 'Ankommer om', 'mov.banner.details': 'Detaljer', + 'push.incoming': 'Innkommende bevegelse oppdaget!', + + 'send.title': 'Send', 'send.open': 'Send enheter hit', 'send.target': 'Mål', 'send.lookup': 'Slå opp', 'send.from': 'Send fra', + 'send.what': 'Hva skal skje', 'send.nothing': 'Det er ingenting å sende til denne ruta.', 'send.units': 'Enheter', 'send.all': 'Alle', + 'send.cargo': 'Last', 'send.cargo.cap': 'Opptil {n} per transport. {free} av {links} transportlenker er ledige.', + 'send.tilesPerHour': 'ruter/t', 'send.pickSome': 'Velg noen enheter for å se latens og ankomst.', + 'send.distance': 'Avstand', 'send.latency': 'Latens', 'send.arrives': 'Ankommer ca.', 'send.slowest': 'Tregeste enhet', 'send.carry': 'Bærer bytte', + 'send.go': 'Send', 'send.sent': '{type} sendt. Latens {t}.', + 'send.reason.no_units': 'ingen egnede enheter hjemme', 'send.reason.target_protected': 'målet har nybegynnerbeskyttelse', + 'send.reason.not_allied': 'ikke i din allianse', 'send.reason.no_link': 'krever et Internettknutepunkt', 'send.reason.links_busy': 'alle transportlenker er opptatt', + 'send.reason.needs_ma_team': 'krever minst ett oppkjøpsteam', 'send.reason.needs_crews': 'krever tre utrullingslag hjemme', + 'send.reason.footprint': 'fotavtrykket {have} er lavere enn de {need} som kreves', 'send.reason.range': 'må ligge innenfor {n} ruter fra en av dine POP-er', 'send.reason.cannotSettle': 'bare tomt land kan bebygges', + 'send.settle.title': 'Ny POP', 'send.settle.crews': '{n} × {unit} drar av gårde og brukes opp.', + 'send.settle.footprint': 'Fotavtrykk {have}, {need} kreves. Innenfor {n} ruter fra en av dine POP-er.', 'send.settle.wild': 'Fritt felt {n}', + 'send.protection.title': 'Dette avslutter nybegynnerbeskyttelsen din.', 'send.protection.body': 'Du er beskyttet til {t}. Et angrep gir den fra seg for godt. Kryss av for å bekrefte.', 'send.protection.need': 'Bekreft at du gir fra deg nybegynnerbeskyttelsen.', + 'send.siege': 'Exploit-sett: bygning som skal skades', 'send.siege.none': 'Ingen preferanse', 'send.siege.hint': 'Trenger minst {n} sett igjen etter kampen for å skade noe.', + 'send.takeover.hint': 'Et oppkjøpsteam senker kundelojaliteten for hver seier. Ved null er POP-en din. Hovedsteder og siste POP kan ikke tas.', + 'send.raid.hint': 'En raid stjeler Kapital, Fiber og Maskinvare opptil det de overlevende bærer. Begge sider mister færre enheter enn i et angrep.', + 'send.scan.hint': 'Skannerne kommer tilbake hvis de overlever. Flere skannere enn forsvareren gir flere detaljer.', + 'send.reinforce.own': 'Enhetene flytter inn i den POP-en og forsvarer den. Hent dem tilbake fra Enheter-skjermen.', + 'send.hostile.hint': 'Målet blir varslet om at noe er på vei, men ikke hva.', + 'send.invalid.own_town': 'Du kan ikke velge deg selv.', 'send.invalid.nothing_there': 'Det er ingenting der å angripe.', 'send.invalid.pact': 'En avtale hindrer det.', + 'send.invalid.not_allied': 'Bare alliansemedlemmer og konfødererte kan få forsterkninger.', 'send.invalid.no_town': 'Ingen POP der.', 'send.invalid.occupied': 'Den ruta er tatt.', + 'send.invalid.not_empty_land': 'Bare tomt land kan bebygges.', 'send.invalid.outside_map': 'Det er utenfor kartet.', 'send.invalid.same_town': 'Velg en annen POP.', + 'send.invalid.incumbent_scan_or_attack_only': 'Gammeloperatørens anlegg kan bare skannes eller angripes.', + + 'rep.empty': 'Ingen rapporter ennå.', 'rep.markAll': 'Merk alle som lest', 'rep.older': 'Eldre rapporter', + 'rep.victory': 'Seier', 'rep.defeat': 'Nederlag', 'rep.captured': 'POP overtatt', + 'rep.sub.you_vs': 'Du mot {name}', 'rep.sub.by': 'Av {name}', + 'rep.scan.title': 'Skanning av {where}', 'rep.scan.ok': 'Skanningen lyktes', 'rep.scan.failed': 'Skanningen mislyktes', 'rep.scan.noIntel': 'Forsvareren oppdaget skannerne dine før de fikk vite noe.', + 'rep.scan.strength': 'Skannestyrke (du mot dem)', + 'rep.detected.title': 'Skanning oppdaget ved {town}', 'rep.detected.unknown': 'Noen skannet denne POP-en. Skannerne dine kunne ikke si hvem.', + 'rep.incumbent.title': 'Gammeloperatørens anlegg {x}, {y}', 'rep.incumbent.bonus': 'Første seier her gir {n} Maskinvare.', 'rep.incumbent.taken': 'Du har allerede tatt dette anlegget.', 'rep.incumbent.reward': 'Belønning', + 'rep.settle.title': 'Ny POP: {name}', 'rep.settle.wild': 'Frie felt', 'rep.settle.open': 'Åpne den nye POP-en', 'rep.settle.hint': 'Den starter med litt Fiber, Maskinvare og Kapital og ingen infrastruktur. Bygg den opp.', + 'rep.reinforce.sender': 'Forsterkninger kom frem til {town}', 'rep.reinforce.target': 'Forsterkninger kom frem til {town}', + 'rep.failed.title': '{type} mislyktes', 'rep.failed.home': 'Enheter og last er på vei hjem.', + 'rep.reason.invalid_target': 'Målet er ikke gyldig lenger.', 'rep.reason.not_allied': 'Målet er ikke lenger alliert.', 'rep.reason.own_town': 'POP-en skiftet eier og er din nå.', + 'rep.reason.pact': 'En avtale med målet hindrer dette nå.', 'rep.reason.protected': 'Målet har nybegynnerbeskyttelse.', 'rep.reason.target_gone': 'Målet finnes ikke lenger.', + 'rep.reason.out_of_range': 'Stedet er utenfor rekkevidde.', 'rep.reason.footprint_too_low': 'Fotavtrykket ditt var for lavt.', + 'rep.role.attacker': 'Du angrep', 'rep.role.defender': 'Du ble angrepet', 'rep.role.reinforcer': 'Forsterkningene dine var der', 'rep.role.sender': 'Du sendte', 'rep.role.target': 'Du var målet', + 'rep.expires': 'lagres til {t}', 'rep.arrived': 'Ankom {t}', + 'rep.attacker': 'Angriper', 'rep.defender': 'Forsvarer', 'rep.target': 'Mål', 'rep.from': 'Fra', 'rep.host': 'Vert', 'rep.site': 'Sted', 'rep.scannedBy': 'Skannet av', + 'rep.power': 'Styrke', 'rep.power.attack': 'Angrep', 'rep.power.defence': 'Forsvar', 'rep.power.firewall': 'Brannmurnivå', + 'rep.attackerUnits': 'Angripende enheter', 'rep.defenderUnits': 'Forsvarende enheter', 'rep.units': 'Enheter', 'rep.scanners': 'Skannere', + 'rep.sent': 'Sendt', 'rep.lost': 'Tapt', 'rep.left': 'Igjen', 'rep.noUnits': 'Ingen enheter.', + 'rep.group.home': 'Hjemmeforsvar', 'rep.group.reinf': 'Forsterkninger fra {town}', 'rep.group.offline': 'offline, uten forsvar', + 'rep.loot': 'Bytte', 'rep.cache': '{p} % av lageret var skjult i Racksalen.', 'rep.siege': 'Beleiring', 'rep.siege.line': '{name} skadet: nivå {a} → {b}', + 'rep.takeover': 'Oppkjøp', 'rep.takeover.loyalty': 'Kundelojalitet', 'rep.takeover.capital': 'En hovedstad kan ikke skifte eier, bare tappes.', 'rep.takeover.captured': 'POP-en har nå ny eier.', + 'rep.takeover.blocked.last_pop': 'Målets siste POP kan ikke tas.', 'rep.takeover.blocked.footprint': 'Fotavtrykket ditt er for lavt til å holde enda en POP.', + 'rep.intel': 'Etterretning', 'rep.intel.resources': 'Ressurser på lager', 'rep.intel.units': 'Enheter', 'rep.intel.offline': 'Enhetene deres er offline.', 'rep.intel.buildings': 'Bygninger', 'rep.intel.outgoing': 'Bevegelsene deres', + + 'alerts.incoming': 'Innkommende bevegelse', 'alerts.incoming.at': 'På vei mot {town}, ankommer {time}', + 'alerts.report': 'Ny rapport: {type}', 'alerts.train_done': '{n} × {unit} ferdig trent', 'alerts.research_done': '{unit}: {stat} nivå {level} ferdig forsket', + 'alerts.movement_returned': 'Enhetene er hjemme', 'alerts.movement_lost': 'En bevegelse fant ikke veien hjem', + 'alerts.transport_arrived': 'Last kom frem til {town}', 'alerts.transport_delivered': 'Lasten din er levert', + 'alerts.units_offline': 'Enheter gikk offline: tomt batteri', 'alerts.units_decommissioned': 'Enheter avviklet etter for lenge uten strøm', + 'alerts.town_lost': '{name} ble overtatt', 'alerts.town_lost.by': 'Av {name}', 'alerts.town_gained': '{name} er nå din', 'alerts.reinforcements_home': 'Forsterkninger sendt hjem', + + 'exp.title': 'Ekspansjon', 'exp.count': '{n} POP-er', 'exp.crews': 'Utrullingslag hjemme', 'exp.footprint': 'Fotavtrykk (denne POP-en / kreves totalt)', 'exp.footprint.v': '{have} / {need}', + 'exp.range': 'Rekkevidde fra dine POP-er', 'exp.hint': 'Tre utrullingslag etablerer en POP på tomt land. En ny POP krever også nok totalt fotavtrykk.', + 'exp.found': 'Velg sted på kartet', 'exp.pick': 'Trykk på en tom rute og velg Send enheter hit.', 'exp.train': 'Tren utrullingslag', 'exp.needCrews': 'Tren {n} flere {unit}.', + 'exp.needDepot': 'Krever et Utrullingsdepot (Kjerneruter nivå 10).', 'exp.pops': 'Dine POP-er', 'exp.current': 'Vises nå', 'exp.open': 'Bytt til', + 'map.legend.out': 'Din bevegelse', 'map.legend.in': 'Innkommende', + + 'err.not_enough_units': 'Ikke nok av de enhetene hjemme.', 'err.units_offline': 'Enhetene dine er offline: batteriet er tomt.', + 'err.invalid_target': 'Det målet fungerer ikke.', 'err.target_protected': 'Målet har nybegynnerbeskyttelse.', + 'err.protection_active': 'Du har nybegynnerbeskyttelse. Bekreft at et angrep avslutter den.', 'err.out_of_range': 'Det er for langt fra POP-ene dine.', + 'err.footprint_too_low': 'Fotavtrykket ditt er for lavt for enda en POP.', 'err.cannot_takeover': 'Den POP-en kan ikke overtas.', + 'err.capacity_exceeded': 'Det er mer enn én transport kan bære.', 'err.no_transport_link': 'Ingen ledig transportlenke: bygg eller vent på et Internettknutepunkt.', + 'err.unknown_unit': 'Ingen slik enhet.', 'err.not_researchable': 'Det kan ikke forskes på.', 'err.recall_expired': 'For sent å kalle tilbake: de første 90 sekundene er over.', + }, + }); +})); diff --git a/public/js/strings/social.js b/public/js/strings/social.js new file mode 100644 index 0000000..389979c --- /dev/null +++ b/public/js/strings/social.js @@ -0,0 +1,232 @@ +'use strict'; +/* Strings of the social screens (alliance, messages, rankings). en + nb, key parity enforced by test/client-i18n.test.js. */ +(function (root, factory) { + if (typeof module === 'object' && module.exports) factory(require('../i18n.js')); + else factory(root.UpstreamI18n); +}(typeof self !== 'undefined' ? self : this, function (I) { + I.extend({ + en: { + 'nav.alliance': 'Alliance', 'nav.messages': 'Messages', 'nav.rankings': 'Rankings', + 'screen.alliance': 'Alliance', 'screen.messages': 'Messages', 'screen.rankings': 'Rankings', + + // errors the social routes can return (existing codes such as forbidden / not_found / rate_limited are translated elsewhere) + 'err.peering_office_required': 'You need a Peering office (level 1 or higher) to found or join an alliance.', + 'err.already_in_alliance': 'That operator is already in an alliance.', + 'err.not_in_alliance': 'You are not in an alliance.', + 'err.alliance_name_taken': 'That alliance name is taken.', + 'err.alliance_tag_taken': 'That alliance tag is taken.', + 'err.alliance_full': 'The alliance has no room for more members.', + 'err.invite_expired': 'The invitation has expired.', + 'err.leader_must_transfer': 'The leader must hand over leadership before leaving.', + 'err.notes_full': 'The pinned-note limit is reached. Remove one first.', + 'err.diplomacy_invalid': 'That diplomatic move is not possible from the current state.', + 'err.diplomacy_pending': 'A change between these alliances is already scheduled.', + 'err.proposal_exists': 'They already proposed this. Accept their proposal instead.', + 'err.proposal_expired': 'The proposal has expired.', + + 'soc.you': 'You', 'soc.more': 'Load more', 'soc.tab.label': 'Sections', + 'soc.tab.overview': 'Overview', 'soc.tab.members': 'Members', 'soc.tab.diplomacy': 'Diplomacy', + 'soc.role.leader': 'Leader', 'soc.role.diplomat': 'Diplomat', 'soc.role.officer': 'Officer', 'soc.role.member': 'Member', + 'soc.state.war': 'War', 'soc.state.neutral': 'Neutral', 'soc.state.nap': 'Non-aggression', 'soc.state.confed': 'Confederation', + 'soc.relation.same': 'Your alliance', + 'soc.members': 'Members', 'soc.leader': 'Leader', 'soc.footprint': 'Footprint', 'soc.founded': 'Founded', 'soc.profile': 'Alliance', + 'soc.size': '{n}/{cap} members', 'soc.leaderIs': 'Leader: {name}', + 'soc.rate': 'You are sending too fast. Try again in {t}.', + + // not in an alliance + 'soc.create.title': 'Found an alliance', + 'soc.create.intro': 'Rival operators are easier to outlast with friends. Found an alliance and invite others, or accept an invitation below.', + 'soc.create.name': 'Name', 'soc.create.tag': 'Tag', + 'soc.create.nameHint': '{a}-{b} characters: letters, digits, spaces, . _ \' -', + 'soc.create.tagHint': '{a}-{b} letters or digits, shown in brackets next to names', + 'soc.create.go': 'Found alliance', 'soc.create.done': 'Alliance founded.', + 'soc.create.needOffice': 'Build a {building} (level {n}) in one of your POPs first.', + 'soc.create.invalid': 'Name: {n1}-{n2} characters. Tag: {t1}-{t2} letters or digits.', + 'soc.invites.title': 'Invitations', 'soc.invites.none': 'No open invitations.', + 'soc.invites.needOffice': 'Accepting needs a {building} too.', + 'soc.invites.from': 'from {name}', 'soc.invites.expires': 'expires in {t}', + 'soc.invites.accept': 'Accept', 'soc.invites.decline': 'Decline', + 'soc.invites.accepted': 'You joined the alliance.', 'soc.invites.declined': 'Invitation declined.', + + // overview + 'soc.notes.title': 'Pinned notes', 'soc.notes.none': 'No pinned notes yet.', 'soc.notes.add': 'Pin note', 'soc.notes.remove': 'Remove note', + 'soc.notes.placeholder': 'Rally points, rules, targets...', + 'soc.manage.title': 'Membership', + 'soc.leave.go': 'Leave alliance', 'soc.leave.done': 'You left the alliance.', + 'soc.leave.confirm': 'Leave {name}? You can be invited again.', + 'soc.leave.confirmAlone': 'You are the only member of {name}. Leaving disbands it.', + 'soc.leave.mustTransfer': 'You are the leader. Hand over leadership to a member before you can leave.', + 'soc.leave.goTransfer': 'Choose a successor', + 'soc.disband.go': 'Disband alliance', 'soc.disband.done': 'Alliance disbanded.', + 'soc.disband.confirm': 'Disband {name} for everyone? This cannot be undone.', + + // members + 'soc.member.stats': 'POPs {towns} · footprint {fp}', 'soc.member.online': 'online {t}', 'soc.member.never': 'never online', + 'soc.member.pops': 'POPs', 'soc.member.lastOnline': 'Last online', 'soc.member.joined': 'Joined', + 'soc.member.message': 'Send message', 'soc.member.setRole': 'Set role', + 'soc.member.roleHint': 'Officers invite and remove members, diplomats handle other alliances.', + 'soc.member.roleSet': '{name} is now {role}.', + 'soc.transfer.go': 'Make leader', 'soc.transfer.confirm': 'Hand leadership to {name}? You become an officer.', 'soc.transfer.done': '{name} is the new leader.', + 'soc.kick.go': 'Remove from alliance', 'soc.kick.confirm': 'Remove {name} from the alliance?', 'soc.kick.done': '{name} was removed.', + 'soc.invite.title': 'Invite an operator', 'soc.invite.name': 'Operator name', 'soc.invite.go': 'Invite', + 'soc.invite.sent': 'Invitation sent to {name}.', 'soc.invite.already': '{name} already has an open invitation.', + 'soc.invite.unknown': 'No operator called {name} in this world.', + 'soc.invite.pending': 'Open invitations', 'soc.invite.none': 'None pending.', 'soc.invite.cancel': 'Cancel invitation', + + // diplomacy + 'soc.dip.title': 'Diplomacy', 'soc.dip.new': 'New move', 'soc.dip.relations': 'Relations', 'soc.dip.none': 'Neutral with everyone.', + 'soc.dip.readOnly': 'Only leaders and diplomats change diplomatic relations.', + 'soc.dip.incoming': 'Proposals to you', 'soc.dip.outgoing': 'Your proposals', + 'soc.dip.accept': 'Accept', 'soc.dip.decline': 'Decline', 'soc.dip.withdraw': 'Withdraw', 'soc.dip.revoke': 'Take back', + 'soc.dip.revoked': 'Scheduled change cancelled.', + 'soc.dip.expires': 'expires in {t}', 'soc.dip.in': 'in {t}', 'soc.dip.applying': 'applying...', + 'soc.dip.byUs': 'started by you', 'soc.dip.byThem': 'started by them', + 'soc.dip.pick': 'Choose an alliance', 'soc.dip.search': 'Search name or tag', 'soc.dip.noResults': 'No other alliances found.', + 'soc.dip.current': 'Now: {state}', 'soc.dip.locked': 'A change is already scheduled for this pair.', 'soc.dip.noMoves': 'No move is possible from here.', + 'soc.dip.result.applied': 'Now {state} with {name}.', + 'soc.dip.result.proposed': 'Proposal sent: {state} with {name}.', + 'soc.dip.result.scheduled': 'Change to {state} with {name} scheduled.', + 'soc.kind.immediate': 'Takes effect at once', 'soc.kind.immediate.hint': 'No consent needed.', + 'soc.kind.proposal': 'Needs their consent', 'soc.kind.proposal.hint': 'They get a proposal and must accept it.', + 'soc.kind.delayed': 'Cancels after a delay', 'soc.kind.delayed.hint': 'Leaving a pact takes {t}, so a partner is never surprised.', + + // messages + 'soc.msg.tab.inbox': 'Inbox', 'soc.msg.tab.sent': 'Sent', 'soc.msg.tab.alliance': 'Alliance', 'soc.msg.tab.blocked': 'Blocked', + 'soc.msg.new.go': 'New', 'soc.msg.new.title': 'New message', 'soc.msg.new': 'New', + 'soc.msg.recipient': 'To (operator name)', 'soc.msg.nameHint': 'Names are not case sensitive.', + 'soc.msg.text': 'Message', 'soc.msg.send': 'Send', 'soc.msg.sent': 'Message sent.', 'soc.msg.counter': '{n} of {max} characters', + 'soc.msg.to': 'Message to {name}', 'soc.msg.toShort': 'To {name}', 'soc.msg.toAlliance': 'Message to your alliance', + 'soc.msg.unknown': 'No operator called {name} in this world.', + 'soc.msg.reply': 'Write a reply...', 'soc.msg.older': 'Older messages', + 'soc.msg.thread.empty': 'No messages with {name} yet.', + 'soc.msg.allianceFeed': 'Alliance broadcast', + 'soc.msg.broadcast': 'Broadcast', 'soc.msg.broadcastPlaceholder': 'Tell everyone in the alliance...', + 'soc.msg.broadcastHint': 'Everyone currently in {tag} gets this message.', + 'soc.msg.unreadOnly': 'Unread only', 'soc.msg.markAll': 'Mark all read', + 'soc.msg.delete': 'Delete my copy', 'soc.msg.deleted': 'Deleted. The other side keeps their copy.', + 'soc.msg.empty.inbox': 'Nothing in your inbox.', 'soc.msg.empty.sent': 'You have not sent anything.', 'soc.msg.empty.alliance': 'No alliance broadcasts yet.', + 'soc.block.go': 'Block', 'soc.block.unblock': 'Unblock', 'soc.block.blocked': '{name} is blocked.', 'soc.block.unblocked': '{name} is unblocked.', + 'soc.block.hint': 'Blocked operators cannot reach you and are not told.', 'soc.block.none': 'You have not blocked anyone.', + 'soc.block.since': 'blocked {t}', 'soc.block.threadHint': 'You blocked this operator. Their messages are not delivered to you.', + + // rankings + 'soc.rank.tab.operators': 'Operators', 'soc.rank.tab.alliances': 'Alliances', 'soc.rank.tab.battles': 'Battles', + 'soc.rank.by': 'Battle ranking by', 'soc.rank.by.attack': 'Attack', 'soc.rank.by.defense': 'Defense', 'soc.rank.by.total': 'Total', + 'soc.rank.yours': 'Your rank', 'soc.rank.of': 'of {n}', 'soc.rank.notShown': 'below the loaded list', + 'soc.rank.pops': 'POPs {n}', 'soc.rank.members': '{n} members', 'soc.rank.att': 'attack {n}', 'soc.rank.def': 'defense {n}', + 'soc.rank.attack': 'Attack points', 'soc.rank.defense': 'Defense points', 'soc.rank.viewAlliance': 'View alliance', + 'soc.rank.empty': 'Nobody is ranked yet.', 'soc.rank.noBattles': 'Nobody has battle points yet.', + 'soc.rank.unavailable': 'Battle rankings are not recorded yet.', + 'soc.rank.noAlliance': 'You are not in an alliance, so you are not ranked here.', + 'soc.rank.noPoints': 'You have no battle points yet.', + }, + nb: { + 'nav.alliance': 'Allianse', 'nav.messages': 'Meldinger', 'nav.rankings': 'Rangering', + 'screen.alliance': 'Allianse', 'screen.messages': 'Meldinger', 'screen.rankings': 'Rangering', + + 'err.peering_office_required': 'Du trenger et peeringkontor (nivå 1 eller høyere) for å stifte eller bli med i en allianse.', + 'err.already_in_alliance': 'Den operatøren er allerede i en allianse.', + 'err.not_in_alliance': 'Du er ikke i en allianse.', + 'err.alliance_name_taken': 'Det alliansenavnet er opptatt.', + 'err.alliance_tag_taken': 'Den alliansetaggen er opptatt.', + 'err.alliance_full': 'Alliansen har ikke plass til flere medlemmer.', + 'err.invite_expired': 'Invitasjonen har utløpt.', + 'err.leader_must_transfer': 'Lederen må gi fra seg ledelsen før hen kan forlate alliansen.', + 'err.notes_full': 'Grensen for festede notater er nådd. Fjern ett først.', + 'err.diplomacy_invalid': 'Det diplomatiske trekket er ikke mulig fra nåværende tilstand.', + 'err.diplomacy_pending': 'En endring mellom disse alliansene er allerede planlagt.', + 'err.proposal_exists': 'De har allerede foreslått dette. Godta forslaget deres i stedet.', + 'err.proposal_expired': 'Forslaget har utløpt.', + + 'soc.you': 'Du', 'soc.more': 'Last flere', 'soc.tab.label': 'Seksjoner', + 'soc.tab.overview': 'Oversikt', 'soc.tab.members': 'Medlemmer', 'soc.tab.diplomacy': 'Diplomati', + 'soc.role.leader': 'Leder', 'soc.role.diplomat': 'Diplomat', 'soc.role.officer': 'Offiser', 'soc.role.member': 'Medlem', + 'soc.state.war': 'Krig', 'soc.state.neutral': 'Nøytral', 'soc.state.nap': 'Ikke-angrep', 'soc.state.confed': 'Konføderasjon', + 'soc.relation.same': 'Din allianse', + 'soc.members': 'Medlemmer', 'soc.leader': 'Leder', 'soc.footprint': 'Fotavtrykk', 'soc.founded': 'Stiftet', 'soc.profile': 'Allianse', + 'soc.size': '{n}/{cap} medlemmer', 'soc.leaderIs': 'Leder: {name}', + 'soc.rate': 'Du sender for fort. Prøv igjen om {t}.', + + 'soc.create.title': 'Stift en allianse', + 'soc.create.intro': 'Rivaliserende operatører er lettere å overleve med venner. Stift en allianse og inviter andre, eller godta en invitasjon under.', + 'soc.create.name': 'Navn', 'soc.create.tag': 'Tagg', + 'soc.create.nameHint': '{a}-{b} tegn: bokstaver, tall, mellomrom, . _ \' -', + 'soc.create.tagHint': '{a}-{b} bokstaver eller tall, vises i klammer ved siden av navn', + 'soc.create.go': 'Stift allianse', 'soc.create.done': 'Alliansen er stiftet.', + 'soc.create.needOffice': 'Bygg først et {building} (nivå {n}) i en av POP-ene dine.', + 'soc.create.invalid': 'Navn: {n1}-{n2} tegn. Tagg: {t1}-{t2} bokstaver eller tall.', + 'soc.invites.title': 'Invitasjoner', 'soc.invites.none': 'Ingen åpne invitasjoner.', + 'soc.invites.needOffice': 'For å godta trenger du også et {building}.', + 'soc.invites.from': 'fra {name}', 'soc.invites.expires': 'utløper om {t}', + 'soc.invites.accept': 'Godta', 'soc.invites.decline': 'Avslå', + 'soc.invites.accepted': 'Du ble med i alliansen.', 'soc.invites.declined': 'Invitasjonen er avslått.', + + 'soc.notes.title': 'Festede notater', 'soc.notes.none': 'Ingen festede notater ennå.', 'soc.notes.add': 'Fest notat', 'soc.notes.remove': 'Fjern notat', + 'soc.notes.placeholder': 'Samlingspunkter, regler, mål...', + 'soc.manage.title': 'Medlemskap', + 'soc.leave.go': 'Forlat alliansen', 'soc.leave.done': 'Du forlot alliansen.', + 'soc.leave.confirm': 'Forlate {name}? Du kan bli invitert igjen.', + 'soc.leave.confirmAlone': 'Du er eneste medlem av {name}. Hvis du forlater den, oppløses den.', + 'soc.leave.mustTransfer': 'Du er leder. Gi ledelsen til et medlem før du kan forlate alliansen.', + 'soc.leave.goTransfer': 'Velg etterfølger', + 'soc.disband.go': 'Oppløs alliansen', 'soc.disband.done': 'Alliansen er oppløst.', + 'soc.disband.confirm': 'Oppløse {name} for alle? Dette kan ikke angres.', + + 'soc.member.stats': 'POP-er {towns} · fotavtrykk {fp}', 'soc.member.online': 'pålogget {t}', 'soc.member.never': 'aldri pålogget', + 'soc.member.pops': 'POP-er', 'soc.member.lastOnline': 'Sist pålogget', 'soc.member.joined': 'Ble med', + 'soc.member.message': 'Send melding', 'soc.member.setRole': 'Sett rolle', + 'soc.member.roleHint': 'Offiserer inviterer og fjerner medlemmer, diplomater tar seg av andre allianser.', + 'soc.member.roleSet': '{name} er nå {role}.', + 'soc.transfer.go': 'Gjør til leder', 'soc.transfer.confirm': 'Gi ledelsen til {name}? Du blir offiser.', 'soc.transfer.done': '{name} er ny leder.', + 'soc.kick.go': 'Fjern fra alliansen', 'soc.kick.confirm': 'Fjerne {name} fra alliansen?', 'soc.kick.done': '{name} ble fjernet.', + 'soc.invite.title': 'Inviter en operatør', 'soc.invite.name': 'Operatørnavn', 'soc.invite.go': 'Inviter', + 'soc.invite.sent': 'Invitasjon sendt til {name}.', 'soc.invite.already': '{name} har allerede en åpen invitasjon.', + 'soc.invite.unknown': 'Ingen operatør heter {name} i denne verdenen.', + 'soc.invite.pending': 'Åpne invitasjoner', 'soc.invite.none': 'Ingen ventende.', 'soc.invite.cancel': 'Trekk tilbake invitasjon', + + 'soc.dip.title': 'Diplomati', 'soc.dip.new': 'Nytt trekk', 'soc.dip.relations': 'Forhold', 'soc.dip.none': 'Nøytral til alle.', + 'soc.dip.readOnly': 'Bare ledere og diplomater endrer diplomatiske forhold.', + 'soc.dip.incoming': 'Forslag til deg', 'soc.dip.outgoing': 'Dine forslag', + 'soc.dip.accept': 'Godta', 'soc.dip.decline': 'Avslå', 'soc.dip.withdraw': 'Trekk tilbake', 'soc.dip.revoke': 'Angre', + 'soc.dip.revoked': 'Planlagt endring avbrutt.', + 'soc.dip.expires': 'utløper om {t}', 'soc.dip.in': 'om {t}', 'soc.dip.applying': 'trer i kraft...', + 'soc.dip.byUs': 'startet av dere', 'soc.dip.byThem': 'startet av dem', + 'soc.dip.pick': 'Velg en allianse', 'soc.dip.search': 'Søk etter navn eller tagg', 'soc.dip.noResults': 'Fant ingen andre allianser.', + 'soc.dip.current': 'Nå: {state}', 'soc.dip.locked': 'En endring er allerede planlagt for dette paret.', 'soc.dip.noMoves': 'Ingen trekk er mulige herfra.', + 'soc.dip.result.applied': 'Nå {state} med {name}.', + 'soc.dip.result.proposed': 'Forslag sendt: {state} med {name}.', + 'soc.dip.result.scheduled': 'Endring til {state} med {name} er planlagt.', + 'soc.kind.immediate': 'Trer i kraft med en gang', 'soc.kind.immediate.hint': 'Trenger ikke samtykke.', + 'soc.kind.proposal': 'Trenger deres samtykke', 'soc.kind.proposal.hint': 'De får et forslag og må godta det.', + 'soc.kind.delayed': 'Sies opp med frist', 'soc.kind.delayed.hint': 'Å forlate en avtale tar {t}, så en partner aldri overraskes.', + + 'soc.msg.tab.inbox': 'Innboks', 'soc.msg.tab.sent': 'Sendt', 'soc.msg.tab.alliance': 'Allianse', 'soc.msg.tab.blocked': 'Blokkert', + 'soc.msg.new.go': 'Ny', 'soc.msg.new.title': 'Ny melding', 'soc.msg.new': 'Ny', + 'soc.msg.recipient': 'Til (operatørnavn)', 'soc.msg.nameHint': 'Store og små bokstaver spiller ingen rolle.', + 'soc.msg.text': 'Melding', 'soc.msg.send': 'Send', 'soc.msg.sent': 'Melding sendt.', 'soc.msg.counter': '{n} av {max} tegn', + 'soc.msg.to': 'Melding til {name}', 'soc.msg.toShort': 'Til {name}', 'soc.msg.toAlliance': 'Melding til alliansen din', + 'soc.msg.unknown': 'Ingen operatør heter {name} i denne verdenen.', + 'soc.msg.reply': 'Skriv et svar...', 'soc.msg.older': 'Eldre meldinger', + 'soc.msg.thread.empty': 'Ingen meldinger med {name} ennå.', + 'soc.msg.allianceFeed': 'Alliansemelding', + 'soc.msg.broadcast': 'Send til alle', 'soc.msg.broadcastPlaceholder': 'Si det til alle i alliansen...', + 'soc.msg.broadcastHint': 'Alle som er i {tag} nå får denne meldingen.', + 'soc.msg.unreadOnly': 'Bare uleste', 'soc.msg.markAll': 'Merk alle som lest', + 'soc.msg.delete': 'Slett min kopi', 'soc.msg.deleted': 'Slettet. Den andre siden beholder sin kopi.', + 'soc.msg.empty.inbox': 'Ingenting i innboksen.', 'soc.msg.empty.sent': 'Du har ikke sendt noe.', 'soc.msg.empty.alliance': 'Ingen alliansemeldinger ennå.', + 'soc.block.go': 'Blokker', 'soc.block.unblock': 'Opphev blokkering', 'soc.block.blocked': '{name} er blokkert.', 'soc.block.unblocked': 'Blokkeringen av {name} er opphevet.', + 'soc.block.hint': 'Blokkerte operatører når ikke fram til deg og får ikke beskjed.', 'soc.block.none': 'Du har ikke blokkert noen.', + 'soc.block.since': 'blokkert {t}', 'soc.block.threadHint': 'Du har blokkert denne operatøren. Meldingene deres leveres ikke til deg.', + + 'soc.rank.tab.operators': 'Operatører', 'soc.rank.tab.alliances': 'Allianser', 'soc.rank.tab.battles': 'Kamper', + 'soc.rank.by': 'Kamprangering etter', 'soc.rank.by.attack': 'Angrep', 'soc.rank.by.defense': 'Forsvar', 'soc.rank.by.total': 'Totalt', + 'soc.rank.yours': 'Din plassering', 'soc.rank.of': 'av {n}', 'soc.rank.notShown': 'under den lastede lista', + 'soc.rank.pops': 'POP-er {n}', 'soc.rank.members': '{n} medlemmer', 'soc.rank.att': 'angrep {n}', 'soc.rank.def': 'forsvar {n}', + 'soc.rank.attack': 'Angrepspoeng', 'soc.rank.defense': 'Forsvarspoeng', 'soc.rank.viewAlliance': 'Vis allianse', + 'soc.rank.empty': 'Ingen er rangert ennå.', 'soc.rank.noBattles': 'Ingen har kamppoeng ennå.', + 'soc.rank.unavailable': 'Kamprangering registreres ikke ennå.', + 'soc.rank.noAlliance': 'Du er ikke i en allianse og er derfor ikke rangert her.', + 'soc.rank.noPoints': 'Du har ingen kamppoeng ennå.', + }, + }); +})); diff --git a/public/js/ws.js b/public/js/ws.js new file mode 100644 index 0000000..2f96ab4 --- /dev/null +++ b/public/js/ws.js @@ -0,0 +1,174 @@ +'use strict'; +/* + * WebSocket push client (docs/PROTOCOL.md). Push is only a HINT: the game is fully playable with the socket down, so + * every failure here is silent (no toasts, no thrown errors) and a slow REST poll runs as the fallback. + * + * connect to ws(s):///ws; first message {"type":"auth","token":"..."}; server answers {"type":"ready","serverTime"} + * server pushes {"type":"town","townId"} {"type":"incoming","townId","arriveAt"} {"type":"notification","id","kind"} + * {"type":"report","id"} {"type":"message","id"} + * client pings {"type":"ping"} every ~25 s and expects {"type":"pong"} within a few seconds, else it reconnects + * reconnect: exponential backoff from 1 s to 60 s with jitter, reset by a successful "ready" + * + * createSocketClient() is pure plumbing with everything injected (WebSocket constructor, timers, token), so + * test/client-ws.test.js can drive it. The browser wiring (bind) feeds pushes into api.emit('push', msg) and refetches + * the affected screens. The token is never logged and never put in the URL. + */ +(function (root, factory) { + if (typeof module === 'object' && module.exports) module.exports = factory(require('./milcore.js')); + else root.UpstreamWs = factory(root.UpstreamMil); +}(typeof self !== 'undefined' ? self : this, function (Mil) { + function createSocketClient(o) { + const WS = o.WebSocket; + const setT = o.setTimeout || setTimeout, clearT = o.clearTimeout || clearTimeout; + const pingMs = o.pingMs || 25000, pongMs = o.pongTimeoutMs || 8000; + const rnd = o.random || Math.random; + let sock = null, state = 'idle', attempt = 0, wanted = false, hadReady = false; + let retryTimer = null, pingTimer = null, pongTimer = null; + + function setState(s) { if (s !== state) { state = s; if (o.onState) o.onState(s); } } + function clearTimers() { clearT(retryTimer); clearT(pingTimer); clearT(pongTimer); retryTimer = pingTimer = pongTimer = null; } + + function schedule(minWait) { + if (!wanted || retryTimer) return; + const wait = Math.max(minWait || 0, Mil.backoffMs(attempt, rnd())); + attempt++; + retryTimer = setT(() => { retryTimer = null; connect(); }, wait); + } + + function startPing() { + clearT(pingTimer); + pingTimer = setT(() => { + if (!sock || state !== 'open') return; + try { sock.send('{"type":"ping"}'); } catch (e) { drop(); return; } + clearT(pongTimer); + pongTimer = setT(() => drop(), pongMs); // no pong: the connection is dead although nobody told us + startPing(); + }, pingMs); + } + + function drop(minWait) { + const s = sock; + sock = null; + clearT(pingTimer); clearT(pongTimer); pingTimer = pongTimer = null; + if (s) { try { s.onopen = s.onmessage = s.onclose = s.onerror = null; s.close(); } catch (e) { /* already gone */ } } + setState(wanted ? 'closed' : 'idle'); + schedule(minWait); + } + + // Close codes of docs/PROTOCOL.md: 4401 (token refused), 4400 and 1009 (a client bug) must not be retried in a loop; + // 4429 (rate limited) waits at least 30 s; everything else is a plain reconnect. + function onClosed(ev) { + const code = ev && ev.code; + if (code === 4401 || code === 4400 || code === 1009) { + wanted = false; clearTimers(); sock = null; setState('idle'); + if (o.onFatal) o.onFatal(code); + return; + } + drop(code === 4429 ? 30000 : 0); + } + + function connect() { + if (!wanted || sock) return; + const token = o.token(); + if (!token || !WS) return; + let s; + try { s = new WS(o.url()); } catch (e) { setState('closed'); schedule(); return; } + sock = s; + setState('connecting'); + s.onopen = () => { try { s.send(JSON.stringify({ type: 'auth', token })); } catch (e) { drop(); } }; + s.onmessage = (ev) => { + let msg = null; + try { msg = JSON.parse(ev.data); } catch (e) { return; } + if (!msg || typeof msg.type !== 'string') return; + if (msg.type === 'ready') { attempt = 0; const again = hadReady; hadReady = true; setState('open'); startPing(); if (o.onReady) o.onReady(msg, again); return; } + if (msg.type === 'pong') { clearT(pongTimer); pongTimer = null; return; } + if (o.onMessage) o.onMessage(msg); + }; + s.onclose = (ev) => { if (sock === s) onClosed(ev); }; + s.onerror = () => { /* the close event follows; stay quiet */ }; + } + + return { + start() { if (wanted) return; wanted = true; attempt = 0; hadReady = false; connect(); }, + stop() { wanted = false; clearTimers(); const s = sock; sock = null; if (s) { try { s.onopen = s.onmessage = s.onclose = s.onerror = null; s.close(); } catch (e) { /* ignore */ } } setState('idle'); }, + // Try now (back online, tab visible again): skips the backoff wait. + kick() { if (!wanted || sock) return; clearT(retryTimer); retryTimer = null; attempt = 0; connect(); }, + get state() { return state; }, + get open() { return state === 'open'; }, + get attempts() { return attempt; }, + }; + } + + // ------------------------------------------------------------------ browser wiring + function bind(App, UI, windowRef) { + const api = App.api; + const wsUrl = () => (windowRef.location.protocol === 'https:' ? 'wss://' : 'ws://') + windowRef.location.host + '/ws'; + const client = createSocketClient({ + WebSocket: windowRef.WebSocket, + url: wsUrl, + token: () => api.getToken(), + onMessage: (msg) => api.emit('push', msg), + // after every ready that follows a gap, refetch what is on screen (PROTOCOL.md): hints sent while we were away are lost + onReady: (msg, again) => { poll(true); if (again && App.state.user) { App.refreshTown().catch(() => {}); App.refreshTowns().catch(() => {}); } }, + onFatal: () => { /* token refused or a client bug: stay quiet, the REST layer reports a dead token itself */ }, + }); + App.ws = client; + + const timers = {}; + function debounce(key, fn, ms) { clearTimeout(timers[key]); timers[key] = setTimeout(fn, ms); } + + // ---- what a push means for the screens (everything is a refetch over REST) + api.on('push', (msg) => { + if (!App.state.user) return; + switch (msg.type) { + case 'town': + if (msg.townId === App.state.townId) debounce('town', () => App.refreshTown().catch(() => {}), 250); + break; + case 'incoming': + debounce('moves', () => App.refreshMovements().catch(() => {}), 150); + UI.toast(App.t('push.incoming'), 'error'); + break; + case 'report': + App.refreshReportsUnread().catch(() => {}); + debounce('towns', () => App.refreshTowns().catch(() => {}), 500); // a settle / takeover report changes the POP list + App.emit('report', msg); + break; + case 'notification': + App.checkAlerts(); + if (msg.kind === 'town_gained' || msg.kind === 'town_lost') App.refreshTowns().catch(() => {}); + if (/^(train_done|research_done|movement_returned|reinforcements_sent_home|units_offline|units_decommissioned|transport_arrived|town_gained|town_lost)$/.test(msg.kind || '')) { + debounce('town', () => App.refreshTown().catch(() => {}), 400); + debounce('moves', () => App.refreshMovements().catch(() => {}), 400); + } + break; + default: break; // 'message' etc. belong to other screens (api.on('push') there) + } + }); + + // ---- REST fallback: slow when the socket is open (it only backs the hints up), faster when it is down + let lastPoll = 0; + function poll(force) { + if (!App.state.user || windowRef.document.hidden) return; + const gap = client.open ? 180000 : 45000; + if (!force && Date.now() - lastPoll < gap) return; + lastPoll = Date.now(); + App.refreshMovements().catch(() => {}); + App.refreshReportsUnread().catch(() => {}); + App.refreshTowns().catch(() => {}); + App.checkAlerts(); + } + setInterval(() => poll(false), 15000); + + // ---- lifecycle + App.on('session', (st) => { + if (st && st.user) { client.start(); poll(true); } else client.stop(); + }); + api.on('unauthorized', () => client.stop()); + api.on('online', () => client.kick()); + windowRef.document.addEventListener('visibilitychange', () => { if (!windowRef.document.hidden && App.state.user) { client.kick(); poll(false); } }); + } + + if (typeof window !== 'undefined' && window.App && window.UI) bind(window.App, window.UI, window); + + return { createSocketClient, bind }; +})); diff --git a/server/alliances.js b/server/alliances.js index c79b7f9..e4a3115 100644 --- a/server/alliances.js +++ b/server/alliances.js @@ -127,6 +127,7 @@ function dissolve(ctx, allianceId, reason) { db.run('DELETE FROM alliance_notes WHERE alliance_id = ?', a.id); const ids = db.all('SELECT operator_id FROM alliance_members WHERE alliance_id = ?', a.id); for (const m of ids) removeMember(db, m.operator_id); + require('./endgame').onAllianceDissolved(ctx, a.id); // its backbone landing sites are the incumbent's again db.run('DELETE FROM alliances WHERE id = ?', a.id); } @@ -172,9 +173,19 @@ const confederated = (db, opA, opB) => { const r = operatorRelation(db, opA, opB // May not attack each other: same alliance, NAP or confederation. const pactPartners = (db, opA, opB) => { const r = operatorRelation(db, opA, opB); return r === 'nap' || r === 'confed' || r === 'same_alliance'; }; +// Every other operator for whom `confederated(db, operatorId, x)` holds: the rest of the own alliance plus the members of +// alliances in a confederation with it. [] without an alliance. +function confederatedOperators(db, operatorId) { + const me = db.get('SELECT alliance_id FROM operators WHERE id = ?', operatorId); + if (!me || !me.alliance_id) return []; + const ids = [me.alliance_id]; + for (const r of db.all("SELECT a_id, b_id FROM alliance_relations WHERE state = 'confed' AND (a_id = ? OR b_id = ?)", me.alliance_id, me.alliance_id)) ids.push(r.a_id === me.alliance_id ? r.b_id : r.a_id); + return db.all('SELECT id FROM operators WHERE alliance_id IN (' + ids.map(() => '?').join(',') + ') AND id != ? ORDER BY id', ...ids, operatorId).map((r) => r.id); +} + module.exports = { S, HOUR, operatorOf, peeringLevel, membership, getAlliance, memberCount, leaderOf, allianceBrief, effectiveCap, refreshCap, addMember, removeMember, requireRole, userOfOperator, notifyOperator, notifyAlliance, dissolve, pairOf, getRelation, setRelation, withdrawProposals, - relationBetween, operatorRelation, atWar, confederated, pactPartners, + relationBetween, operatorRelation, atWar, confederated, pactPartners, confederatedOperators, }; diff --git a/server/commands/backboneBuild.js b/server/commands/backboneBuild.js new file mode 100644 index 0000000..b73b56d --- /dev/null +++ b/server/commands/backboneBuild.js @@ -0,0 +1,40 @@ +'use strict'; +/* + * POST /backbone/:id/build: start the next Backbone node level on a landing site your alliance holds. The level's cost comes out + * of the site's stockpile (shipped in by the holders, see backboneShip) at once; one level at a time; the level lands when the + * `backboneDone` event runs. Needs the `backboneBuild` permission. + */ +const R = require('../../public/js/rules.js'); +const { GameError } = require('../errors'); +const { loadWorld } = require('../state'); +const A = require('../alliances'); +const E = require('../endgame'); +const ctxOf = require('../military/ctx'); + +// The site, the caller's operator in its world, and proof that the caller's alliance holds it. Shared with backboneShip. +function holderContext(db, userId, siteId, now) { + const site = E.siteRow(db, siteId); + if (!site) throw new GameError('not_found', { what: 'landing site' }); + const world = loadWorld(db, site.world_id); + const op = db.get('SELECT * FROM operators WHERE user_id = ? AND world_id = ?', userId, site.world_id); + if (!op) throw new GameError('not_found', { what: 'landing site' }); + if (!E.isOpen(world, now)) throw new GameError('backbone_closed', { opensAtDay: require('../../public/js/data.js').ENDGAME.openDay }); + const m = A.membership(db, op.id); + if (!site.holder_alliance_id || !m || m.alliance_id !== site.holder_alliance_id) throw new GameError('forbidden', { need: 'holder' }); + return { site, world, op, member: m }; +} + +module.exports = function backboneBuild(ctx0, { userId, siteId }) { + const ctx = ctxOf(ctx0); + const { db, now } = ctx; + const { site, world, op, member } = holderContext(db, userId, siteId, now); + if (!R.allianceCan(member.role, 'backboneBuild')) throw new GameError('forbidden', { need: 'backboneBuild', role: member.role }); + const plan = R.backbonePlan({ level: site.level, build: site.build_to ? { to: site.build_to } : null, pool: { fiber: site.fiber, hardware: site.hardware, capital: site.capital } }, world.speed); + if (!plan.ok) throw new GameError(plan.code, { siteId: site.id, toLevel: plan.toLevel, cost: plan.cost, have: { fiber: site.fiber, hardware: site.hardware, capital: site.capital } }); + const dueAt = now + plan.durationMs; + const ev = ctx.enqueue({ worldId: site.world_id, dueAt, type: 'backboneDone', payload: { siteId: site.id, toLevel: plan.toLevel, by: op.id } }); + db.run(`UPDATE landing_sites SET fiber = fiber - ?, hardware = hardware - ?, capital = capital - ?, build_to = ?, build_event_id = ?, build_started_at = ?, build_due_at = ?, build_cost = ? WHERE id = ?`, + plan.cost.fiber, plan.cost.hardware, plan.cost.capital, plan.toLevel, ev, now, dueAt, JSON.stringify(plan.cost), site.id); + return { siteId: site.id, eventId: ev, toLevel: plan.toLevel, startedAt: now, dueAt, cost: plan.cost }; +}; +module.exports.holderContext = holderContext; diff --git a/server/commands/backboneShip.js b/server/commands/backboneShip.js new file mode 100644 index 0000000..6c396fc --- /dev/null +++ b/server/commands/backboneShip.js @@ -0,0 +1,23 @@ +'use strict'; +/* + * POST /backbone/:id/ship {fromTownId, cargo}: send resources from one of your POPs to a landing site your alliance holds, to + * feed its stockpile. A normal transport (same links, 500 per link, 12 tiles/h) whose target is the site's tile; on arrival it is + * added to the stockpile if the sender's alliance still holds the site, otherwise it rides home. + */ +const { GameError } = require('../errors'); +const { settle } = require('../state'); +const { ownedTown } = require('./build'); +const { launchTransport } = require('./sendTransport'); +const { holderContext } = require('./backboneBuild'); +const ctxOf = require('../military/ctx'); + +module.exports = function backboneShip(ctx0, { userId, siteId, fromTownId, cargo }) { + const ctx = ctxOf(ctx0); + const { db, now } = ctx; + const { site } = holderContext(db, userId, siteId, now); + const from = ownedTown(db, userId, fromTownId); + if (from.worldId !== site.world_id) throw new GameError('not_found', { what: 'town' }); + settle(db, from, now); + const mv = launchTransport(ctx, from, { x: site.x, y: site.y }, cargo || {}, { siteId: site.id }); + return { movementId: mv.id, type: 'transport', siteId: site.id, fromTownId: from.id, toTownId: null, to: { x: site.x, y: site.y }, cargo: mv.cargo, departAt: mv.departAt, arriveAt: mv.arriveAt }; +}; diff --git a/server/commands/index.js b/server/commands/index.js index f017bd4..cafd32a 100644 --- a/server/commands/index.js +++ b/server/commands/index.js @@ -40,19 +40,35 @@ const handlers = { messageDelete: require('./messageDelete'), messageBlock: require('./messageBlock').messageBlock, messageUnblock: require('./messageBlock').messageUnblock, + // trade, end game, shared reports + reportShare: require('./reportShare').reportShare, + reportUnshare: require('./reportShare').reportUnshare, + tradeOffer: require('./tradeOffer'), + tradeCancel: require('./tradeCancel'), + tradeAccept: require('./tradeAccept'), + backboneBuild: require('./backboneBuild'), + backboneShip: require('./backboneShip'), }; function createCommands({ db, clock, scheduler }) { + // hooks.onCommand(name, args, out): optional, called after a command committed (stage 6 push). Never throws into the caller. + const hooks = { onCommand: null }; function run(name, args) { const fn = handlers[name]; if (!fn) throw new Error('unknown command ' + name); scheduler.runDue(); + require('../endgame').guard(db, name, args); // an ended world refuses every command except reading state and chatting const now = clock.now(); - const out = db.tx(() => fn({ db, clock, now, scheduler }, args)); + const mark = scheduler.outboxMark(); + let out; + try { out = db.tx(() => fn({ db, clock, now, scheduler }, args)); } + catch (err) { scheduler.outboxRollback(mark); throw err; } + scheduler.flushOutbox(); // notifications written by the command go out now that it is committed + if (hooks.onCommand) { try { hooks.onCommand(name, args, out); } catch (e) { if (scheduler.log) scheduler.log('onCommand hook failed: ' + e.message); } } scheduler.arm(); return out; } - return { run, handlers }; + return { run, handlers, hooks }; } module.exports = { createCommands }; diff --git a/server/commands/reportShare.js b/server/commands/reportShare.js new file mode 100644 index 0000000..c981c0a --- /dev/null +++ b/server/commands/reportShare.js @@ -0,0 +1,51 @@ +'use strict'; +/* + * The alliance's shared report folder. Two commands in one file (registered separately in commands/index.js): + * reportShare { userId, reportId } put one of YOUR reports into your alliance's folder (needs `shareReport`) + * reportUnshare { userId, reportId } take it out again: whoever shared it, or `unshareReport` (leader, officer) + * The alliance is the caller's alliance in the report's world. Sharing an already shared report changes nothing + * ({ changed: false }). A shared report lives at least reportRetentionMs from the moment it was shared (the expiry is pushed + * out; it is one row for everybody, so the participants keep it that long too) and is deleted with the report. + */ +const R = require('../../public/js/rules.js'); +const D = require('../../public/js/data.js'); +const { GameError } = require('../errors'); +const A = require('../alliances'); +const { ensureCleanup } = require('../military/reports'); + +function context(db, userId, reportId) { + const rep = db.get(`SELECT r.id, r.world_id, r.expires_at FROM reports r JOIN report_recipients rr ON rr.report_id = r.id AND rr.user_id = ? WHERE r.id = ?`, userId, reportId); + if (!rep) throw new GameError('not_found', { what: 'report' }); // not yours: never reveal it exists + const op = db.get('SELECT * FROM operators WHERE user_id = ? AND world_id = ?', userId, rep.world_id); + if (!op) throw new GameError('not_found', { what: 'report' }); + const m = A.membership(db, op.id); + if (!m) throw new GameError('not_in_alliance'); + return { rep, op, member: m }; +} + +function reportShare(ctx, { userId, reportId }) { + const { db, now } = ctx; + const { rep, op, member } = context(db, userId, reportId); + if (!R.allianceCan(member.role, 'shareReport')) throw new GameError('forbidden', { need: 'shareReport', role: member.role }); + const r = db.run('INSERT OR IGNORE INTO report_shares (report_id, alliance_id, shared_by, created_at) VALUES (?, ?, ?, ?)', rep.id, member.alliance_id, op.id, now); + if (!r.changes) return { changed: false, reportId: rep.id, allianceId: member.alliance_id }; + const until = now + D.MILITARY.reportRetentionMs; + if (rep.expires_at < until) db.run('UPDATE reports SET expires_at = ? WHERE id = ?', until, rep.id); + ensureCleanup(ctx, rep.world_id, now); + return { changed: true, reportId: rep.id, allianceId: member.alliance_id }; +} + +function reportUnshare(ctx, { userId, reportId }) { + const { db } = ctx; + // the report may no longer list the caller as a recipient (it is only theirs through the alliance): look the share up directly + const share = db.get(`SELECT s.*, r.world_id FROM report_shares s JOIN reports r ON r.id = s.report_id WHERE s.report_id = ? + AND s.alliance_id IN (SELECT m.alliance_id FROM alliance_members m JOIN operators o ON o.id = m.operator_id WHERE o.user_id = ?)`, reportId, userId); + if (!share) throw new GameError('not_found', { what: 'shared report' }); + const op = db.get('SELECT * FROM operators WHERE user_id = ? AND world_id = ?', userId, share.world_id); + const member = A.membership(db, op.id); + if (op.id !== share.shared_by && !R.allianceCan(member.role, 'unshareReport')) throw new GameError('forbidden', { need: 'unshareReport', role: member.role }); + db.run('DELETE FROM report_shares WHERE report_id = ? AND alliance_id = ?', share.report_id, share.alliance_id); + return { changed: true, reportId: share.report_id, allianceId: share.alliance_id }; +} + +module.exports = { reportShare, reportUnshare }; diff --git a/server/commands/sendMovement.js b/server/commands/sendMovement.js index e2d5d22..384cfa6 100644 --- a/server/commands/sendMovement.js +++ b/server/commands/sendMovement.js @@ -18,7 +18,7 @@ const TYPES = ['scan', 'raid', 'attack', 'takeover', 'reinforce', 'settle']; const HOSTILE = ['raid', 'attack', 'takeover']; // The target of a movement: a POP (by id or by tile) or a bare tile. -> { town: row|null, x, y, tile } -function resolveTarget(db, world, args) { +function resolveTarget(db, world, args, now) { let town = null, x, y; if (args.toTownId !== undefined && args.toTownId !== null) { town = db.get('SELECT * FROM towns WHERE id = ? AND world_id = ?', args.toTownId, world.id); @@ -30,7 +30,7 @@ function resolveTarget(db, world, args) { } else { throw new GameError('validation_failed', { errors: [{ path: 'toTownId', message: 'give toTownId or x and y' }] }); } - const tile = R.tileAt(world.seed, world.map_radius, x, y); + const tile = R.tileAt(world.seed, world.map_radius, x, y, R.worldAgeDays(world.start_at, now, world.speed)); if (tile.type === 'void') throw new GameError('invalid_target', { reason: 'outside_map' }); return { town, x, y, tile }; } @@ -52,7 +52,7 @@ module.exports = function sendMovement(ctx0, args) { for (const k of Object.keys(units)) if ((home[k] || 0) < units[k]) throw new GameError('not_enough_units', { unit: k, have: home[k] || 0, want: units[k] }); if (!P.online(from, now)) throw new GameError('units_offline', { townId: from.id }); - const tgt = resolveTarget(db, world, args); + const tgt = resolveTarget(db, world, args, now); if (tgt.town && tgt.town.id === from.id) throw new GameError('invalid_target', { reason: 'same_town' }); const dist = R.distance(from.x, from.y, tgt.x, tgt.y); const arriveAt = now + R.movementMs(dist, units, world.speed); @@ -81,6 +81,10 @@ module.exports = function sendMovement(ctx0, args) { } } else if (tgt.tile.type === 'incumbent') { if (type !== 'scan' && type !== 'attack') throw new GameError('invalid_target', { reason: 'incumbent_scan_or_attack_only' }); + } else if (tgt.tile.type === 'backbone') { + require('../endgame').checkLandingTarget(db, world, op, tgt, type, now, ctx); // scan or attack only, alliance members, no pact partners + } else if (R.isBackboneSite(world.seed, world.map_radius, tgt.x, tgt.y)) { + throw new GameError('backbone_closed', { opensAtDay: D.ENDGAME.openDay }); // the landing site is not there yet } else { throw new GameError('invalid_target', { reason: 'nothing_there' }); } @@ -98,7 +102,7 @@ module.exports = function sendMovement(ctx0, args) { const own = U.operatorTowns(db, op.id); let nearest = Infinity; for (const t of own) nearest = Math.min(nearest, R.distance(t.x, t.y, tgt.x, tgt.y)); - const chk2 = R.settleCheck({ tileType: tgt.tile.type, occupied: !!tgt.town, nearestOwnDist: nearest, ownedCount: own.length, footprint: U.operatorFootprint(db, op.id, now) }); + const chk2 = R.settleCheck({ tileType: tgt.tile.type, backbone: R.isBackboneSite(world.seed, world.map_radius, tgt.x, tgt.y), occupied: !!tgt.town, nearestOwnDist: nearest, ownedCount: own.length, footprint: U.operatorFootprint(db, op.id, now) }); if (!chk2.ok) throw new GameError(chk2.code, chk2); extra.wild = R.cleanWild(args.wild); } diff --git a/server/commands/tradeAccept.js b/server/commands/tradeAccept.js new file mode 100644 index 0000000..74cc06c --- /dev/null +++ b/server/commands/tradeAccept.js @@ -0,0 +1,54 @@ +'use strict'; +/* + * POST /trade/offers/:id/accept {townId}: take an open offer with one of your POPs. In ONE transaction: + * - the payment (the wanted resource) leaves the acceptor's POP as a transport to the poster's POP (needs a free link there, + * the usual transport rules: capacity, resources), + * - the poster's escrow leaves as a transport to the acceptor's POP (on the link the open offer held in reserve), + * - the offer becomes `accepted`; it is `completed` when both transports have been delivered (see server/trade.js). + * Any failure rolls everything back. Not your own offer; the acceptor's POP needs an Internet exchange and must be in range + * (the offer's max distance and the exchange's reach). + */ +const R = require('../../public/js/rules.js'); +const { GameError } = require('../errors'); +const { settle, loadWorld } = require('../state'); +const { ownedTown } = require('./build'); +const { launchTransport } = require('./sendTransport'); +const ctxOf = require('../military/ctx'); +const M = require('../military/movements'); +const T = require('../trade'); + +module.exports = function tradeAccept(ctx0, { userId, offerId, townId }) { + const ctx = ctxOf(ctx0); + const { db, now } = ctx; + const o = T.getOffer(db, offerId); + const mine = ownedTown(db, userId, townId); + if (!o || o.world_id !== mine.worldId) throw new GameError('not_found', { what: 'offer' }); + if (o.status !== 'open') throw new GameError('offer_closed', { status: o.status }); + if (mine.ownerId === o.operator_id) throw new GameError('own_offer'); + const poster = db.get('SELECT * FROM towns WHERE id = ?', o.town_id); + if (!poster || poster.owner_id !== o.operator_id) throw new GameError('offer_closed', { status: 'void' }); + const level = R.transportLinks(mine); + const dist = R.distance(mine.x, mine.y, poster.x, poster.y); + if (level < 1) throw new GameError('no_transport_link', { links: 0, active: 0 }); + if (!R.tradeInRange(dist, o.max_distance, level)) throw new GameError('trade_out_of_range', { distance: dist, maxDistance: o.max_distance, reach: R.tradeReach(level) }); + settle(db, mine, now); + + // acceptor -> poster: the wanted resource (validates links, capacity and resources, deducts, inserts the movement) + const pay = launchTransport(ctx, mine, poster, { [o.want_res]: o.want_amount }, { tradeId: o.id, role: 'payment' }); + // poster -> acceptor: the escrow + const world = loadWorld(db, o.world_id); + const goods = M.insertMovement(ctx, { + worldId: o.world_id, ownerId: o.operator_id, type: 'transport', fromTownId: poster.id, toTownId: mine.id, + from: { x: poster.x, y: poster.y }, to: { x: mine.x, y: mine.y }, units: {}, cargo: { [o.give_res]: o.give_amount }, + departAt: now, arriveAt: now + R.transportMs(dist, world.speed), extra: { tradeId: o.id, role: 'goods' }, + }); + db.run("UPDATE trade_offers SET status = 'accepted', accepted_by_operator = ?, accepted_town_id = ?, accepted_at = ?, goods_movement_id = ?, payment_movement_id = ? WHERE id = ?", + mine.ownerId, mine.id, now, goods.id, pay.id, o.id); + if (o.expire_event_id) db.run("UPDATE events SET status = 'cancelled', done_at = ? WHERE id = ? AND status = 'pending'", now, o.expire_event_id); + const posterUser = T.userOfOperator(db, o.operator_id); + if (posterUser) ctx.notify(posterUser, o.world_id, 'trade_accepted', { offerId: o.id, townId: poster.id, byTownId: mine.id, give: { resource: o.give_res, amount: o.give_amount }, want: { resource: o.want_res, amount: o.want_amount } }); + return { + offerId: o.id, status: 'accepted', goodsMovementId: goods.id, paymentMovementId: pay.id, distance: dist, + arriveAt: goods.arriveAt, give: { resource: o.give_res, amount: o.give_amount }, want: { resource: o.want_res, amount: o.want_amount }, + }; +}; diff --git a/server/commands/tradeCancel.js b/server/commands/tradeCancel.js new file mode 100644 index 0000000..02fe5d0 --- /dev/null +++ b/server/commands/tradeCancel.js @@ -0,0 +1,15 @@ +'use strict'; +/* DELETE /trade/offers/:id: take your open offer back; the escrow returns to the POP. */ +const { GameError } = require('../errors'); +const ctxOf = require('../military/ctx'); +const T = require('../trade'); + +module.exports = function tradeCancel(ctx0, { userId, offerId }) { + const ctx = ctxOf(ctx0); + const { db, now } = ctx; + const o = T.getOffer(db, offerId); + if (!o || T.userOfOperator(db, o.operator_id) !== userId) throw new GameError('not_found', { what: 'offer' }); + if (o.status !== 'open') throw new GameError('offer_closed', { status: o.status }); + T.closeOffer(ctx, o, 'cancelled', now); + return { offerId: o.id, status: 'cancelled', returned: { resource: o.give_res, amount: o.give_amount } }; +}; diff --git a/server/commands/tradeOffer.js b/server/commands/tradeOffer.js new file mode 100644 index 0000000..78fd2fe --- /dev/null +++ b/server/commands/tradeOffer.js @@ -0,0 +1,33 @@ +'use strict'; +/* + * POST /trade/offers: "give X of A for Y of B, max distance Z" from one of your POPs with an Internet exchange. The offered + * amount leaves the POP now (escrow), one transport link stays reserved for it, and the offer expires after TRADE.ttlHours + * (divided by world speed). Both amounts must fit one transport link and differ by at most 1:2. + */ +const R = require('../../public/js/rules.js'); +const D = require('../../public/js/data.js'); +const { GameError } = require('../errors'); +const { settle, spend } = require('../state'); +const { ownedTown } = require('./build'); +const M = require('../military/movements'); +const T = require('../trade'); + +module.exports = function tradeOffer(ctx, { userId, townId, giveRes, giveAmount, wantRes, wantAmount, maxDistance }) { + const { db, now, scheduler } = ctx; + const town = ownedTown(db, userId, townId); + const terms = R.tradeTermsCheck({ giveRes, giveAmount, wantRes, wantAmount, maxDistance }); + if (!terms.ok) throw new GameError(terms.code, terms); + const links = R.transportLinks(town); + const inUse = M.activeLinks(db, town.id); + if (links < 1 || inUse >= links) throw new GameError('no_transport_link', { links, active: inUse }); + settle(db, town, now); + if (R.resourcesAt(town, now).amounts[giveRes] + 1e-6 < giveAmount) throw new GameError('not_enough_resources', { resource: giveRes, want: giveAmount }); + spend(db, town, { [giveRes]: giveAmount }); + const expiresAt = now + T.expiryMs(town.speed); + const id = Number(db.run(`INSERT INTO trade_offers (world_id, town_id, operator_id, give_res, give_amount, want_res, want_amount, max_distance, status, created_at, expires_at) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'open', ?, ?)`, town.worldId, town.id, town.ownerId, giveRes, giveAmount, wantRes, wantAmount, maxDistance, now, expiresAt).lastInsertRowid); + const ev = scheduler.enqueue({ worldId: town.worldId, dueAt: expiresAt, type: 'tradeExpire', townId: town.id, payload: { offerId: id } }); + db.run('UPDATE trade_offers SET expire_event_id = ? WHERE id = ?', ev, id); + const o = T.getOffer(db, id); + return { offer: T.offerView(db, o, new Map([[town.id, town]])) }; +}; diff --git a/server/endgame.js b/server/endgame.js new file mode 100644 index 0000000..6f5126c --- /dev/null +++ b/server/endgame.js @@ -0,0 +1,192 @@ +'use strict'; +/* + * End game: backbone landing sites, the Backbone node race, the winner, the end of the world. + * + * Representation (DECISIONS.md E1): a landing site is NOT a POP. It is a row of `landing_sites` (position from the world seed, + * holder alliance, node level, stockpile, build in progress). The tile reads 'backbone' (rules.tileAt with the world age) from + * D.ENDGAME.openDay on; before that it is plain land that nobody may settle or spawn on. A site is defended by a static value + * only (rules.backboneDefence: incumbent defence x defenceMult, + a bonus per node level), so there are no reinforcements at a + * site. Holders keep the level when the site is taken; the stockpile and a running build stay with the site as well. + * + * Time: world age is in world days (real days x speed). Everything here takes `now` (ms) from the caller. + */ +const R = require('../public/js/rules.js'); +const D = require('../public/js/data.js'); +const { GameError } = require('./errors'); +const { loadWorld } = require('./state'); + +const DAY = 24 * D.HOUR_MS; +const E = D.ENDGAME; + +const ageDays = (world, now) => R.worldAgeDays(world.start_at, now, world.speed); +const phase = (world, now) => R.worldPhase(world.status, ageDays(world, now)); +const isOpen = (world, now) => ageDays(world, now) >= E.openDay; + +// ---------------------------------------------------------------- site rows + +// Create the site rows (idempotent). Writers call this; reads use `siteStates`, which never writes. The first call that really +// creates them (whatever touches a site first once the world is old enough) tells every operator, when it was given a `ctx` +// with notify. There is no timer event for this on purpose: nothing is pending in a quiet world. +function ensureSites(db, world, now, ctx) { + if (!isOpen(world, now)) return []; + let created = 0; + for (const s of R.backboneSites(world.seed, world.map_radius)) created += Number(db.run('INSERT OR IGNORE INTO landing_sites (world_id, idx, x, y) VALUES (?, ?, ?, ?)', world.id, s.index, s.x, s.y).changes); + const rows = db.all('SELECT * FROM landing_sites WHERE world_id = ? ORDER BY idx', world.id); + if (created && ctx && ctx.notify) notifyWorld(ctx, world.id, 'backbone_open', { sites: rows.map((r) => ({ siteId: r.id, index: r.idx, x: r.x, y: r.y })) }); + return rows; +} +const siteRow = (db, id) => db.get('SELECT * FROM landing_sites WHERE id = ?', id) || null; +const siteAt = (db, worldId, idx) => db.get('SELECT * FROM landing_sites WHERE world_id = ? AND idx = ?', worldId, idx) || null; + +// Every site of the world as { site: {index,x,y}, row: landing_sites row | null } (no row = never touched: still the incumbent's). +function siteStates(db, world, now) { + if (!isOpen(world, now)) return []; + const rows = new Map(db.all('SELECT * FROM landing_sites WHERE world_id = ?', world.id).map((r) => [r.idx, r])); + return R.backboneSites(world.seed, world.map_radius).map((s) => ({ site: s, row: rows.get(s.index) || null })); +} + +function allianceInfo(db, id) { + if (!id) return null; + const a = db.get('SELECT id, tag, name FROM alliances WHERE id = ?', id); + return a ? { allianceId: a.id, tag: a.tag, name: a.name } : null; +} +const opBrief = (db, id) => { const o = id ? db.get('SELECT id, name FROM operators WHERE id = ?', id) : null; return o ? { operatorId: o.id, name: o.name } : null; }; + +// Public view of one site. `row` may be null (untouched). +function siteView(db, world, s, row) { + const level = row ? row.level : 0; + const pool = { fiber: row ? row.fiber : 0, hardware: row ? row.hardware : 0, capital: row ? row.capital : 0 }; + const build = row && row.build_to ? { toLevel: row.build_to, startedAt: row.build_started_at, dueAt: row.build_due_at } : null; + return { + id: row ? row.id : null, index: s.index, x: s.x, y: s.y, + holder: row ? allianceInfo(db, row.holder_alliance_id) : null, + takenBy: row ? opBrief(db, row.holder_operator_id) : null, takenAt: row ? row.taken_at : null, + level, maxLevel: E.maxLevel, progress: level / E.maxLevel, pool, build, + next: level < E.maxLevel ? { toLevel: level + 1, cost: R.backboneCost(level + 1), durationMs: R.backboneTimeMs(level + 1, world.speed) } : null, + }; +} + +function winnerView(w) { + return w.winner_alliance_id || w.winner_name ? { allianceId: w.winner_alliance_id, name: w.winner_name, tag: w.winner_tag, siteId: w.winner_site_id, wonAt: w.won_at } : null; +} + +// GET /worlds/:id/status +function statusView(db, world, now) { + const age = ageDays(world, now); + return { + worldId: world.id, name: world.name, speed: world.speed, status: world.status, phase: phase(world, now), + ageDays: age, openDay: E.openDay, opensAt: world.start_at + Math.round(E.openDay * DAY / world.speed), + sites: siteStates(db, world, now).map(({ site, row }) => siteView(db, world, site, row)), + winner: winnerView(world), endsAt: world.status === 'ended' ? world.end_at : (world.won_at ? world.end_at : null), endedAt: world.status === 'ended' ? world.end_at : null, + }; +} + +// ---------------------------------------------------------------- the ended-world gate + +// Commands that stay possible after the world ended (reading state, chatting): everything else is refused with `world_ended`. +const WHEN_ENDED = new Set(['markReportRead', 'messageSend', 'messageRead', 'messageDelete', 'messageBlock', 'messageUnblock']); +const PROBES = [ + ['townId', 'SELECT world_id AS w FROM towns WHERE id = ?'], ['fromTownId', 'SELECT world_id AS w FROM towns WHERE id = ?'], ['hostTownId', 'SELECT world_id AS w FROM towns WHERE id = ?'], + ['allianceId', 'SELECT world_id AS w FROM alliances WHERE id = ?'], ['movementId', 'SELECT world_id AS w FROM movements WHERE id = ?'], + ['inviteId', 'SELECT a.world_id AS w FROM alliance_invites i JOIN alliances a ON a.id = i.alliance_id WHERE i.id = ?'], + ['proposalId', 'SELECT world_id AS w FROM alliance_proposals WHERE id = ?'], ['offerId', 'SELECT world_id AS w FROM trade_offers WHERE id = ?'], + ['siteId', 'SELECT world_id AS w FROM landing_sites WHERE id = ?'], ['reportId', 'SELECT world_id AS w FROM reports WHERE id = ?'], +]; +// The world a command acts in: an explicit worldId, else the world of whatever it points at, else the caller's default operator's. +function worldOfCommand(db, args) { + if (args.worldId) return args.worldId; + for (const [key, sql] of PROBES) { + if (args[key]) { const r = db.get(sql, args[key]); if (r) return r.w; } + } + if (args.userId) { const r = db.get('SELECT world_id AS w FROM operators WHERE user_id = ? ORDER BY id LIMIT 1', args.userId); if (r) return r.w; } + return null; +} +// Called by commands.run before every command. Throws world_ended when the world of the command has ended. +function guard(db, name, args) { + if (WHEN_ENDED.has(name) || !args) return; + const w = worldOfCommand(db, args); + if (!w) return; + const row = db.get('SELECT status FROM worlds WHERE id = ?', w); + if (row && row.status === 'ended') throw new GameError('world_ended', { worldId: w }); +} + +// ---------------------------------------------------------------- notifications + +function notifyAlliance(ctx, allianceId, type, payload) { + for (const m of ctx.db.all('SELECT o.user_id AS uid, o.world_id AS wid FROM alliance_members am JOIN operators o ON o.id = am.operator_id WHERE am.alliance_id = ?', allianceId)) ctx.notify(m.uid, m.wid, type, payload); +} +function notifyWorld(ctx, worldId, type, payload) { + for (const o of ctx.db.all('SELECT user_id FROM operators WHERE world_id = ?', worldId)) ctx.notify(o.user_id, worldId, type, payload); +} + +// ---------------------------------------------------------------- taking a site, winning, the end + +// Sending checks (sendMovement): landing sites can be scanned and attacked, nothing else. Attacking needs an alliance; you cannot +// attack a site your own alliance or a pact partner holds. +function checkLandingTarget(db, world, op, tgt, type, now, ctx) { + if (type !== 'scan' && type !== 'attack') throw new GameError('invalid_target', { reason: 'landing_scan_or_attack_only' }); + if (type !== 'attack') return; + if (!op.alliance_id) throw new GameError('invalid_target', { reason: 'no_alliance' }); + const row = ensureSites(db, world, now, ctx).find((r) => r.idx === tgt.tile.site); + denyIfFriendly(db, op, row); +} +function denyIfFriendly(db, op, row) { + if (!row || !row.holder_alliance_id) return; + if (row.holder_alliance_id === op.alliance_id) throw new GameError('invalid_target', { reason: 'own_site' }); + const rel = require('./alliances').relationBetween(db, op.alliance_id, row.holder_alliance_id); + if (rel === 'nap' || rel === 'confed') throw new GameError('invalid_target', { reason: 'pact' }); +} + +// The site changes hands: the attacking operator's alliance holds it now. Level, stockpile and a running build stay. +function transferSite(ctx, site, attackerOp, now) { + const { db } = ctx; + const old = site.holder_alliance_id; + db.run('UPDATE landing_sites SET holder_alliance_id = ?, holder_operator_id = ?, taken_at = ? WHERE id = ?', attackerOp.alliance_id, attackerOp.id, now, site.id); + const body = { siteId: site.id, index: site.idx, x: site.x, y: site.y, level: site.level, by: allianceInfo(db, attackerOp.alliance_id), from: allianceInfo(db, old) }; + if (old) notifyAlliance(ctx, old, 'backbone_lost', body); + notifyAlliance(ctx, attackerOp.alliance_id, 'backbone_taken', body); + maybeWin(ctx, siteRow(db, site.id), now); // a finished node taken while nobody held it completes for the new holder +} + +// The holder of a node at maxLevel wins, once per world. Called when a level completes and when such a site changes hands. +function maybeWin(ctx, site, now) { + const { db } = ctx; + if (!site || site.level < E.maxLevel || !site.holder_alliance_id) return false; + const world = loadWorld(db, site.world_id); + if (!world || world.status === 'ended' || world.winner_alliance_id) return false; + const a = allianceInfo(db, site.holder_alliance_id); + const endsAt = now + Math.round(E.graceDays * DAY / world.speed); + db.run('UPDATE worlds SET winner_alliance_id = ?, winner_name = ?, winner_tag = ?, winner_site_id = ?, won_at = ?, end_at = ? WHERE id = ?', a.allianceId, a.name, a.tag, site.id, now, endsAt, world.id); + ctx.enqueue({ worldId: world.id, dueAt: endsAt, type: 'worldEnd', payload: { reason: 'backbone', siteId: site.id } }); + notifyWorld(ctx, world.id, 'backbone_won', { allianceId: a.allianceId, name: a.name, tag: a.tag, siteId: site.id, endsAt }); + return true; +} + +// An alliance is gone: its sites are the incumbent's again (the level stays with the site). +function onAllianceDissolved(ctx, allianceId) { + ctx.db.run('UPDATE landing_sites SET holder_alliance_id = NULL WHERE holder_alliance_id = ?', allianceId); +} + +// A shipment of resources reached a landing site (called from military/arrivals.arriveTransport). Only the holder alliance's +// members may feed the stockpile: if the site changed hands on the way the cargo rides home. -> true when it was stored +function deliverShipment(ctx, mv, now) { + const { db } = ctx; + const site = siteRow(db, mv.extra.siteId); + const sender = db.get('SELECT * FROM operators WHERE id = ?', mv.ownerId); + const uid = sender ? sender.user_id : null; + if (!site || !site.holder_alliance_id || !sender || sender.alliance_id !== site.holder_alliance_id) { + if (uid) ctx.notify(uid, mv.worldId, 'backbone_ship_bounced', { movementId: mv.id, siteId: mv.extra.siteId, cargo: mv.cargo }); + return false; + } + const c = { fiber: mv.cargo.fiber || 0, hardware: mv.cargo.hardware || 0, capital: mv.cargo.capital || 0 }; + db.run('UPDATE landing_sites SET fiber = fiber + ?, hardware = hardware + ?, capital = capital + ? WHERE id = ?', c.fiber, c.hardware, c.capital, site.id); + db.run(`INSERT INTO landing_contributions (site_id, operator_id, fiber, hardware, capital) VALUES (?, ?, ?, ?, ?) + ON CONFLICT (site_id, operator_id) DO UPDATE SET fiber = fiber + excluded.fiber, hardware = hardware + excluded.hardware, capital = capital + excluded.capital`, site.id, sender.id, c.fiber, c.hardware, c.capital); + if (uid) ctx.notify(uid, mv.worldId, 'backbone_delivered', { movementId: mv.id, siteId: site.id, cargo: c }); + return true; +} + +module.exports = { + DAY, ageDays, phase, isOpen, ensureSites, siteRow, siteAt, siteStates, siteView, allianceInfo, opBrief, winnerView, statusView, + guard, worldOfCommand, notifyAlliance, notifyWorld, checkLandingTarget, denyIfFriendly, transferSite, maybeWin, onAllianceDissolved, deliverShipment, +}; diff --git a/server/endgameQueries.js b/server/endgameQueries.js new file mode 100644 index 0000000..7f0c931 --- /dev/null +++ b/server/endgameQueries.js @@ -0,0 +1,50 @@ +'use strict'; +/* Read models of the end game: world status (the race), the final results, one landing site. Reads catch the event queue up first + * and never write (an untouched site has no row yet and shows as the incumbent's, level 0). */ +const R = require('../public/js/rules.js'); +const D = require('../public/js/data.js'); +const { GameError } = require('./errors'); +const { loadWorld } = require('./state'); +const A = require('./alliances'); +const E = require('./endgame'); + +function createEndgameQueries({ db, clock, scheduler }) { + const fresh = () => { scheduler.runDue(); return clock.now(); }; + const world = (id) => { const w = loadWorld(db, id); if (!w) throw new GameError('not_found', { what: 'world' }); return w; }; + + function status(userId, worldId) { + const now = fresh(); + return Object.assign({ serverTime: now }, E.statusView(db, world(worldId), now)); + } + + function results(userId, worldId) { + const now = fresh(); + const w = world(worldId); + const row = db.get('SELECT created_at, data FROM world_rankings WHERE world_id = ?', w.id); + if (!row) return { serverTime: now, available: false, status: w.status, winner: E.winnerView(w), endsAt: w.won_at ? w.end_at : null, results: null }; + return { serverTime: now, available: true, status: w.status, winner: E.winnerView(w), endsAt: w.end_at, results: JSON.parse(row.data) }; + } + + // One site. Holders (members of the holding alliance) also get the contribution ledger and what they may do. + function site(userId, siteId) { + const now = fresh(); + const row = E.siteRow(db, siteId); + const w = row ? world(row.world_id) : null; + const op = w ? db.get('SELECT * FROM operators WHERE user_id = ? AND world_id = ?', userId, w.id) : null; + if (!row || !op || !E.isOpen(w, now)) throw new GameError('not_found', { what: 'landing site' }); + const s = R.backboneSites(w.seed, w.map_radius).find((x) => x.index === row.idx); + const m = A.membership(db, op.id); + const holder = !!(m && row.holder_alliance_id && m.alliance_id === row.holder_alliance_id); + const out = { serverTime: now, site: E.siteView(db, w, s, row), you: { holder, canBuild: holder && R.allianceCan(m.role, 'backboneBuild'), canShip: holder, canAttack: !!op.alliance_id && !(holder) } }; + if (holder) { + out.contributions = db.all(`SELECT c.operator_id AS oid, o.name AS name, c.fiber, c.hardware, c.capital FROM landing_contributions c JOIN operators o ON o.id = c.operator_id + WHERE c.site_id = ? ORDER BY (c.fiber + c.hardware + c.capital) DESC, c.operator_id`, row.id) + .map((c) => ({ operatorId: c.oid, name: c.name, fiber: c.fiber, hardware: c.hardware, capital: c.capital })); + } + return out; + } + + return { status, results, site }; +} + +module.exports = { createEndgameQueries }; diff --git a/server/errors.js b/server/errors.js index fc9dfd5..02f2612 100644 --- a/server/errors.js +++ b/server/errors.js @@ -56,6 +56,13 @@ const CODES = { recall_expired: [409, 'The recall window (first 90 seconds) has passed.'], capacity_exceeded: [409, 'More than one transport link can carry.'], no_transport_link: [409, 'All transport links are busy (or there is no Internet exchange).'], + // trade and end game + trade_ratio: [409, 'The offered and the wanted amount may differ by at most 1:2.'], + offer_closed: [409, 'That offer is not open any more.'], + own_offer: [409, 'You cannot accept your own offer.'], + trade_out_of_range: [409, 'That POP is too far from the offer (its max distance or your Internet exchange reach).'], + world_ended: [409, 'This world has ended: it can still be read, but nothing can be changed.'], + backbone_closed: [409, 'The backbone landing sites have not appeared yet.'], }; class GameError extends Error { diff --git a/server/events/backboneDone.js b/server/events/backboneDone.js new file mode 100644 index 0000000..e9ea90f --- /dev/null +++ b/server/events/backboneDone.js @@ -0,0 +1,22 @@ +'use strict'; +/* A Backbone node level finished. Payload { siteId, toLevel, by }. Idempotent: only acts while the site's build points at THIS + * event. The level lands on the SITE (a capture during the build does not stop it); level maxLevel makes the holder alliance the + * winner (once per world) and schedules the end of the world. */ +const D = require('../../public/js/data.js'); +const { loadWorld } = require('../state'); +const E = require('../endgame'); + +module.exports = function backboneDone(ctx, ev) { + const { db } = ctx; + const site = E.siteRow(db, ev.payload.siteId); + if (!site || site.build_event_id !== ev.id) return; + const world = loadWorld(db, site.world_id); + if (!world || world.status === 'ended') return; + const level = site.build_to; + db.run('UPDATE landing_sites SET level = ?, build_to = NULL, build_event_id = NULL, build_started_at = NULL, build_due_at = NULL, build_cost = NULL WHERE id = ?', level, site.id); + const fresh = E.siteRow(db, site.id); + if (fresh.holder_alliance_id && (level % D.ENDGAME.notifyEvery === 0 || level >= D.ENDGAME.maxLevel)) { + E.notifyAlliance(ctx, fresh.holder_alliance_id, 'backbone_level', { siteId: site.id, index: site.idx, level }); + } + E.maybeWin(ctx, fresh, ev.dueAt); +}; diff --git a/server/events/buildDone.js b/server/events/buildDone.js index 0a4c24b..d705e9a 100644 --- a/server/events/buildDone.js +++ b/server/events/buildDone.js @@ -1,5 +1,8 @@ 'use strict'; -/* A building level finished. Payload: { key, type, toLevel, userId }. Idempotent: a level never goes down. */ +/* A building level finished. Payload: { key, type, toLevel, userId }. Each build event adds exactly ONE level to what the + * building is at the moment it finishes (relative, not absolute): exploit kits may have knocked the building down while the + * upgrade was in flight, and the finished level must not undo that. Never lowers a level; `toLevel` is the level the + * upgrade was queued for and is only an upper bound. Events run once (status), so +1 is safe. */ const { loadTown, settle } = require('../state'); module.exports = function buildDone(ctx, ev) { @@ -9,8 +12,12 @@ module.exports = function buildDone(ctx, ev) { if (!town) return; settle(db, town, ev.dueAt); // values up to the moment of completion, at the OLD rates const cur = town.buildings[key]; - if (!cur) db.run('INSERT INTO buildings (town_id, key, type, level) VALUES (?, ?, ?, ?)', town.id, key, type, toLevel); - else if (cur.level < toLevel) db.run('UPDATE buildings SET level = ? WHERE town_id = ? AND key = ?', toLevel, town.id, key); + let level; + if (!cur) { level = 1; db.run('INSERT INTO buildings (town_id, key, type, level) VALUES (?, ?, ?, ?)', town.id, key, type, level); } + else { + level = cur.level < toLevel ? cur.level + 1 : cur.level; + if (level !== cur.level) db.run('UPDATE buildings SET level = ? WHERE town_id = ? AND key = ?', level, town.id, key); + } require('../military/power').reschedule(ctx, town.id, ev.dueAt); // building draw / battery cap changed: units' power check - if (userId) ctx.notify(userId, ev.worldId, 'build_done', { townId: town.id, key, type, level: toLevel }); + if (userId) ctx.notify(userId, ev.worldId, 'build_done', { townId: town.id, key, type, level }); }; diff --git a/server/events/index.js b/server/events/index.js index a17c393..4d3f3a3 100644 --- a/server/events/index.js +++ b/server/events/index.js @@ -10,4 +10,8 @@ module.exports = { reportCleanup: require('./reportCleanup'), buildDone: require('./buildDone'), diploChange: require('./diploChange'), + // trade and end game + tradeExpire: require('./tradeExpire'), + backboneDone: require('./backboneDone'), + worldEnd: require('./worldEnd'), }; diff --git a/server/events/tradeExpire.js b/server/events/tradeExpire.js new file mode 100644 index 0000000..81e6e7d --- /dev/null +++ b/server/events/tradeExpire.js @@ -0,0 +1,12 @@ +'use strict'; +/* An open Internet exchange offer ran out of time: the escrow goes back to the POP. Payload { offerId }. Idempotent: acts only + * while the offer is still open (accepted/cancelled offers cancel their own expiry event, this is the second line of defence). */ +const T = require('../trade'); + +module.exports = function tradeExpire(ctx, ev) { + const o = T.getOffer(ctx.db, ev.payload.offerId); + if (!o || o.status !== 'open') return; + T.closeOffer(ctx, o, 'expired', ev.dueAt); + const uid = T.userOfOperator(ctx.db, o.operator_id); + if (uid) ctx.notify(uid, o.world_id, 'trade_expired', { offerId: o.id, townId: o.town_id, returned: { resource: o.give_res, amount: o.give_amount } }); +}; diff --git a/server/events/worldEnd.js b/server/events/worldEnd.js new file mode 100644 index 0000000..4667925 --- /dev/null +++ b/server/events/worldEnd.js @@ -0,0 +1,20 @@ +'use strict'; +/* The world ends (two world days after a node reached the last level; payload { reason, siteId }). Stores the final ranking + * snapshot, sets status 'ended', gives the escrow of open trade offers back to its POPs, cancels everything still pending in this world (the world is frozen: no arrival, training or + * trade changes anything any more; reads keep working) and tells every operator. Idempotent: an ended world is left alone. */ +const { loadWorld } = require('../state'); +const E = require('../endgame'); +const T = require('../trade'); +const { finalRanking } = require('../finalRanking'); + +module.exports = function worldEnd(ctx, ev) { + const { db } = ctx; + const world = loadWorld(db, ev.worldId); + if (!world || world.status === 'ended') return; + const snapshot = finalRanking(db, world, ev.dueAt); + db.run('INSERT OR REPLACE INTO world_rankings (world_id, created_at, data) VALUES (?, ?, ?)', world.id, ev.dueAt, JSON.stringify(snapshot)); + db.run("UPDATE worlds SET status = 'ended', end_at = ? WHERE id = ?", ev.dueAt, world.id); + for (const o of db.all("SELECT * FROM trade_offers WHERE world_id = ? AND status = 'open'", world.id)) T.closeOffer(ctx, o, 'expired', ev.dueAt); // escrow back in its POP: every unit stays accounted for + db.run("UPDATE events SET status = 'cancelled', done_at = ? WHERE world_id = ? AND status = 'pending' AND id != ?", ev.dueAt, world.id, ev.id); + E.notifyWorld(ctx, world.id, 'world_ended', { winner: snapshot.winner, endedAt: ev.dueAt }); +}; diff --git a/server/finalRanking.js b/server/finalRanking.js new file mode 100644 index 0000000..057899c --- /dev/null +++ b/server/finalRanking.js @@ -0,0 +1,49 @@ +'use strict'; +/* + * The final ranking snapshot written when a world ends (events/worldEnd.js) and served by GET /worlds/:id/results: + * operators by footprint, alliances by the sum over their members, top attackers and defenders by battle points, the winner. + * Same footprint numbers as /rankings (socialQueries.footprints), computed at the end time. Top D.ENDGAME.rankingTop per list. + */ +const D = require('../public/js/data.js'); +const { createSocialQueries } = require('./socialQueries'); +const E = require('./endgame'); + +const round2 = (v) => Math.round(v * 100) / 100; + +function finalRanking(db, world, at) { + const social = createSocialQueries({ db, clock: { now: () => at }, scheduler: { runDue() {} } }); + const fp = social.footprints(world.id, at); + const top = D.ENDGAME.rankingTop; + const ranked = (rows) => rows.slice(0, top).map((r, i) => Object.assign({ rank: i + 1 }, r)); + + const ops = db.all('SELECT o.id AS id, o.name AS name, o.as_number AS asn, a.id AS aid, a.tag AS tag FROM operators o LEFT JOIN alliances a ON a.id = o.alliance_id WHERE o.world_id = ?', world.id) + .map((o) => { const f = fp.get(o.id) || { footprint: 0, towns: 0 }; return { operatorId: o.id, name: o.name, asNumber: o.asn, allianceId: o.aid, allianceTag: o.tag, towns: f.towns, footprint: round2(f.footprint) }; }) + .sort((x, y) => y.footprint - x.footprint || x.operatorId - y.operatorId); + + const byAlliance = new Map(); + for (const o of ops) { + if (!o.allianceId) continue; + const c = byAlliance.get(o.allianceId) || { footprint: 0, members: 0, towns: 0 }; + c.footprint += o.footprint; c.members += 1; c.towns += o.towns; + byAlliance.set(o.allianceId, c); + } + const alliances = db.all('SELECT id, name, tag FROM alliances WHERE world_id = ?', world.id) + .map((a) => { const c = byAlliance.get(a.id) || { footprint: 0, members: 0, towns: 0 }; return { allianceId: a.id, name: a.name, tag: a.tag, members: c.members, towns: c.towns, footprint: round2(c.footprint) }; }) + .sort((x, y) => y.footprint - x.footprint || x.allianceId - y.allianceId); + + const stats = db.all(`SELECT o.id AS id, o.name AS name, a.tag AS tag, s.attack_points AS att, s.defense_points AS def FROM operator_stats s + JOIN operators o ON o.id = s.operator_id LEFT JOIN alliances a ON a.id = o.alliance_id WHERE o.world_id = ?`, world.id) + .map((r) => ({ operatorId: r.id, name: r.name, allianceTag: r.tag, attackPoints: round2(r.att || 0), defensePoints: round2(r.def || 0) })); + const attackers = stats.filter((r) => r.attackPoints > 0).sort((x, y) => y.attackPoints - x.attackPoints || x.operatorId - y.operatorId); + const defenders = stats.filter((r) => r.defensePoints > 0).sort((x, y) => y.defensePoints - x.defensePoints || x.operatorId - y.operatorId); + + const winner = E.winnerView(db.get('SELECT * FROM worlds WHERE id = ?', world.id)); + const sites = E.siteStates(db, world, at).map(({ site, row }) => E.siteView(db, world, site, row)); + return { + worldId: world.id, at, winner, sites, + totals: { operators: ops.length, alliances: alliances.length }, + operators: ranked(ops), alliances: ranked(alliances), attackers: ranked(attackers), defenders: ranked(defenders), + }; +} + +module.exports = { finalRanking }; diff --git a/server/http.js b/server/http.js index 61edef7..6a0254f 100644 --- a/server/http.js +++ b/server/http.js @@ -17,7 +17,7 @@ const { TokenBucket, clientIp } = require('./net'); const { applySecurityHeaders } = require('./static'); const MAX_BODY = 32 * 1024; -const INT_PARAMS = new Set(['id', 'townId', 'eventId', 'tokenId', 'inviteId', 'noteId', 'proposalId', 'otherId', 'operatorId']); +const INT_PARAMS = new Set(['id', 'townId', 'eventId', 'tokenId', 'inviteId', 'noteId', 'proposalId', 'otherId', 'operatorId', 'reportId']); // Per-key token buckets (per IP, per token). Idle full buckets are pruned so the map cannot grow without bound. class Limiter { diff --git a/server/index.js b/server/index.js index 8e21327..2e48e68 100644 --- a/server/index.js +++ b/server/index.js @@ -22,6 +22,8 @@ const routes = require('./routes'); const eventHandlers = require('./events'); const { createStaticHandler, applySecurityHeaders } = require('./static'); const { parseTrustProxy, parseTrustedProxies, listenDual, listUrls } = require('./net'); +const { createPush } = require('./push'); +const { bindGame, pushDeps } = require('./pushHooks'); function defaultLog(msg) { console.log(new Date().toISOString() + ' ' + msg); } @@ -55,6 +57,11 @@ async function createServer(userOpts) { routes.register(api.router, services); api.services = services; + // WebSocket push on /ws (docs/PROTOCOL.md): hints only, the REST API stays the source of truth and works without it + const push = createPush(Object.assign({ clock, authenticate: auth.authenticate, opts: o, log }, pushDeps(db))); + bindGame({ push, db, scheduler, commands }); + services.push = push; + const serveStatic = createStaticHandler(o.publicDir); const server = http.createServer((req, res) => { const url = req.url || '/'; @@ -66,6 +73,7 @@ async function createServer(userOpts) { if (url.startsWith('/api/')) return api.handle(req, res); return serveStatic(req, res).catch((err) => { log('static error: ' + (err && err.message)); if (!res.headersSent) res.writeHead(500); res.end(); }); }); + server.on('upgrade', push.onUpgrade); server.headersTimeout = 20000; server.requestTimeout = 30000; server.keepAliveTimeout = 5000; const sockets = new Set(); server.on('connection', (s) => { sockets.add(s); s.on('close', () => sockets.delete(s)); }); @@ -81,6 +89,7 @@ async function createServer(userOpts) { if (closePromise) return closePromise; closePromise = (async () => { scheduler.stop(); clearInterval(idemTimer); + await push.close(); // 1001 to every socket, so server.close() below is not held up await new Promise((r) => { server.close(() => r()); if (server.closeIdleConnections) server.closeIdleConnections(); setTimeout(() => { for (const s of sockets) s.destroy(); }, 1000).unref(); }); db.close(); })(); diff --git a/server/migrations/004_trade_endgame.sql b/server/migrations/004_trade_endgame.sql new file mode 100644 index 0000000..828d304 --- /dev/null +++ b/server/migrations/004_trade_endgame.sql @@ -0,0 +1,90 @@ +-- Trade (Internet exchange offers), shared report folder, end game (backbone landing sites, winner, final ranking). +-- Times are integer ms since the epoch (UTC). Every game row carries world_id. + +-- An offer "give X of A for Y of B, max distance Z". The offered amount is ESCROWED: it left the POP when the offer was +-- created and lives in this row until the offer is accepted (it then travels as a transport), cancelled or expired (it goes +-- back to the POP). status: open | accepted | completed | cancelled | expired | void (the POP changed hands). +CREATE TABLE trade_offers ( + id INTEGER PRIMARY KEY, + world_id INTEGER NOT NULL REFERENCES worlds(id), + town_id INTEGER NOT NULL REFERENCES towns(id), -- the POP that posted it (the escrow came from there) + operator_id INTEGER NOT NULL REFERENCES operators(id), + give_res TEXT NOT NULL, + give_amount INTEGER NOT NULL CHECK (give_amount > 0), + want_res TEXT NOT NULL, + want_amount INTEGER NOT NULL CHECK (want_amount > 0), + max_distance INTEGER NOT NULL, + status TEXT NOT NULL DEFAULT 'open', + created_at INTEGER NOT NULL, + expires_at INTEGER NOT NULL, + expire_event_id INTEGER, + accepted_by_operator INTEGER REFERENCES operators(id), + accepted_town_id INTEGER REFERENCES towns(id), + accepted_at INTEGER, + goods_movement_id INTEGER, -- transport poster -> acceptor (the escrow) + payment_movement_id INTEGER, -- transport acceptor -> poster + legs_done INTEGER NOT NULL DEFAULT 0, + closed_at INTEGER +); +CREATE INDEX trade_offers_open ON trade_offers(world_id, status, id); +CREATE INDEX trade_offers_town ON trade_offers(town_id, status); +CREATE INDEX trade_offers_operator ON trade_offers(operator_id, id); + +-- Reports shared to an alliance (the shared report folder). Gone with the report (cleanup) or the alliance. +CREATE TABLE report_shares ( + report_id INTEGER NOT NULL REFERENCES reports(id) ON DELETE CASCADE, + alliance_id INTEGER NOT NULL REFERENCES alliances(id) ON DELETE CASCADE, + shared_by INTEGER NOT NULL REFERENCES operators(id), + created_at INTEGER NOT NULL, + PRIMARY KEY (report_id, alliance_id) +); +CREATE INDEX report_shares_alliance ON report_shares(alliance_id, report_id); + +-- Backbone landing sites (end game). Positions are a pure function of the world seed (rules.backboneSites); a row is +-- created lazily by whatever touches a site first once the world is at day D.ENDGAME.openDay (no timer event). holder_alliance_id NULL = still held by the incumbent +-- (or the holder disbanded: the level stays with the site). `fiber/hardware/capital` is the stockpile shipped in by the holders +-- for the next level. build_* describe the level being built (one at a time). +CREATE TABLE landing_sites ( + id INTEGER PRIMARY KEY, + world_id INTEGER NOT NULL REFERENCES worlds(id), + idx INTEGER NOT NULL, + x INTEGER NOT NULL, + y INTEGER NOT NULL, + holder_alliance_id INTEGER REFERENCES alliances(id) ON DELETE SET NULL, + holder_operator_id INTEGER REFERENCES operators(id), -- who took it + taken_at INTEGER, + level INTEGER NOT NULL DEFAULT 0, + fiber INTEGER NOT NULL DEFAULT 0, + hardware INTEGER NOT NULL DEFAULT 0, + capital INTEGER NOT NULL DEFAULT 0, + build_to INTEGER, + build_event_id INTEGER, + build_started_at INTEGER, + build_due_at INTEGER, + build_cost TEXT, + UNIQUE (world_id, idx), + UNIQUE (world_id, x, y) +); + +-- What each operator shipped into a site's stockpile (kept when the site changes hands: it is a ledger, not a balance). +CREATE TABLE landing_contributions ( + site_id INTEGER NOT NULL REFERENCES landing_sites(id), + operator_id INTEGER NOT NULL REFERENCES operators(id), + fiber INTEGER NOT NULL DEFAULT 0, + hardware INTEGER NOT NULL DEFAULT 0, + capital INTEGER NOT NULL DEFAULT 0, + PRIMARY KEY (site_id, operator_id) +); + +-- The winner and the end of the world. The ranking snapshot is written once, when the world enters status 'ended'. +ALTER TABLE worlds ADD COLUMN winner_alliance_id INTEGER; +ALTER TABLE worlds ADD COLUMN winner_name TEXT; +ALTER TABLE worlds ADD COLUMN winner_tag TEXT; +ALTER TABLE worlds ADD COLUMN winner_site_id INTEGER; +ALTER TABLE worlds ADD COLUMN won_at INTEGER; + +CREATE TABLE world_rankings ( + world_id INTEGER PRIMARY KEY REFERENCES worlds(id), + created_at INTEGER NOT NULL, + data TEXT NOT NULL +); diff --git a/server/military/arrivals.js b/server/military/arrivals.js index b6abf4c..942d32e 100644 --- a/server/military/arrivals.js +++ b/server/military/arrivals.js @@ -72,6 +72,8 @@ function arriveReinforce(ctx, mv, ev) { function arriveTransport(ctx, mv, ev) { const { db } = ctx; const now = ev.dueAt; + // A shipment to a backbone landing site (extra.siteId) feeds the site's stockpile; refused ones ride home like any undeliverable cargo. + const siteDelivered = !!(mv.extra && mv.extra.siteId) && require('../endgame').deliverShipment(ctx, mv, now); const target = mv.toTownId ? loadTown(db, mv.toTownId) : null; let lost = {}; if (target) { @@ -82,7 +84,7 @@ function arriveTransport(ctx, mv, ev) { if (sender && sender !== receiver) ctx.notify(sender, mv.worldId, 'transport_delivered', { movementId: mv.id, toTownId: target.id, cargo: mv.cargo, cargoLost: lost }); for (const fn of M.hooks.transportArrived) fn(ctx, mv, { added: mv.cargo, lost }); } - const cargoBack = target ? {} : mv.cargo; // no such POP any more: the cargo rides home with the carriers + const cargoBack = target || siteDelivered ? {} : mv.cargo; // no such POP any more: the cargo rides home with the carriers // The empty carriers drive back; the link is busy until they are home. const dest = U.homeTownFor(db, mv.ownerId, mv.fromTownId); if (dest) { @@ -99,12 +101,12 @@ function arriveSettle(ctx, mv, ev) { const world = loadWorld(db, mv.worldId); const op = U.getOperator(db, mv.ownerId); const { x, y } = mv.to; - const tile = R.tileAt(world.seed, world.map_radius, x, y); + const tile = R.tileAt(world.seed, world.map_radius, x, y, R.worldAgeDays(world.start_at, now, world.speed)); const occupied = !!db.get('SELECT 1 AS x FROM towns WHERE world_id = ? AND x = ? AND y = ?', world.id, x, y); const own = U.operatorTowns(db, op.id); let nearest = Infinity; for (const t of own) nearest = Math.min(nearest, R.distance(t.x, t.y, x, y)); - const chk = R.settleCheck({ tileType: tile.type, occupied, nearestOwnDist: nearest, ownedCount: own.length, footprint: U.operatorFootprint(db, op.id, now) }); + const chk = R.settleCheck({ tileType: tile.type, backbone: R.isBackboneSite(world.seed, world.map_radius, x, y), occupied, nearestOwnDist: nearest, ownedCount: own.length, footprint: U.operatorFootprint(db, op.id, now) }); if (!chk.ok) return bounce(ctx, mv, now, chk.code, chk); const wild = R.cleanWild(mv.extra.wild); const name = op.name + ' POP ' + (own.length + 1); diff --git a/server/military/combat.js b/server/military/combat.js index 3c0b1bf..dd7f05c 100644 --- a/server/military/combat.js +++ b/server/military/combat.js @@ -211,7 +211,8 @@ function resolveScanOnTown(ctx, mv, now, s) { function arriveSite(ctx, mv, now, world) { const { db } = ctx; const { x, y } = mv.to; - const tile = R.tileAt(world.seed, world.map_radius, x, y); + const tile = R.tileAt(world.seed, world.map_radius, x, y, R.worldAgeDays(world.start_at, now, world.speed)); + if (tile.type === 'backbone') return require('./landing')(ctx, mv, now, world, tile); // end game: backbone landing site if (tile.type !== 'incumbent' || (mv.type !== 'scan' && mv.type !== 'attack')) return bounce(ctx, mv, now, 'invalid_target'); const attackerOp = U.getOperator(db, mv.ownerId); const ageDays = Math.max(0, (now - world.start_at) / DAY * world.speed); @@ -274,6 +275,7 @@ function transferTown(ctx, town, newOp, oldOp, now) { if (home.id === g.hostTownId) U.addHome(db, home.id, g.units); else U.addStationed(db, g.hostTownId, home.id, g.units); } db.run('DELETE FROM town_power WHERE town_id = ?', town.id); + require('../trade').onTownTransferred(ctx, town.id, now); // open Internet exchange offers of the old owner end, the escrow stays in the POP const oldUser = U.userOfOperator(db, oldOp.id), newUser = U.userOfOperator(db, newOp.id); if (oldUser) ctx.notify(oldUser, town.worldId, 'town_lost', { townId: town.id, name: town.name, by: opBrief(newOp) }); if (newUser) ctx.notify(newUser, town.worldId, 'town_gained', { townId: town.id, name: town.name }); diff --git a/server/military/landing.js b/server/military/landing.js new file mode 100644 index 0000000..d0cfc44 --- /dev/null +++ b/server/military/landing.js @@ -0,0 +1,67 @@ +'use strict'; +/* + * Arrival of a scan or an attack at a backbone landing site (hooked from combat.arriveSite, runs inside the `arrive` event). + * A site is defended by a static value only: rules.backboneDefence(seed, x, y, world age, node level). Beating it as a member + * of an alliance makes that alliance the holder (level, stockpile and a running build stay with the site). The site never + * loses anything, so there is no loot and no raid; survivors drive home. Re-validates at arrival like every movement. + */ +const R = require('../../public/js/rules.js'); +const D = require('../../public/js/data.js'); +const U = require('./units'); +const M = require('./movements'); +const E = require('../endgame'); +const { createReport } = require('./reports'); +const { bounce, townBrief, opBrief } = require('./arrivals'); + +const SCAN_STRENGTH = D.ENDGAME.scanStrength; // a landing site counts as this many defending scanners + +function sendHome(ctx, mv, survivors) { + if (U.isEmpty(survivors)) return null; + const dest = U.homeTownFor(ctx.db, mv.ownerId, mv.fromTownId); + if (!dest) return null; + return M.launchReturn(ctx, { worldId: mv.worldId, ownerId: mv.ownerId, fromTownId: null, at: mv.to, to: dest, units: survivors, cargo: {}, parentId: mv.id, extra: {} }); +} + +module.exports = function arriveLanding(ctx, mv, now, world, tile) { + const { db } = ctx; + if (mv.type !== 'scan' && mv.type !== 'attack') return bounce(ctx, mv, now, 'invalid_target'); + const rows = E.ensureSites(db, world, now, ctx); + const site = rows.find((r) => r.idx === tile.site); + const attackerOp = U.getOperator(db, mv.ownerId); + const origin = mv.fromTownId ? db.get('SELECT * FROM towns WHERE id = ?', mv.fromTownId) : null; + const uid = U.userOfOperator(db, attackerOp.id); + const where = { x: site.x, y: site.y, index: site.idx, siteId: site.id, level: site.level, holder: E.allianceInfo(db, site.holder_alliance_id) }; + const staticDef = R.backboneDefence(world.seed, site.x, site.y, E.ageDays(world, now), site.level); + + if (mv.type === 'scan') { + const sa = R.scanStrength(mv.units.port_scanner || 0, mv.extra.research); + const res = R.resolveScan(sa, SCAN_STRENGTH); + const loss = R.applyLoss(mv.units, res.lossFraction); + const intel = res.success ? { defence: staticDef, level: site.level, holder: where.holder, build: site.build_to ? { toLevel: site.build_to, dueAt: site.build_due_at } : null } : null; + createReport(ctx, { + worldId: mv.worldId, type: 'scan', now, summary: { success: res.success, site: Object.assign({ type: 'backbone' }, where) }, + data: { success: res.success, detail: res.detail, site: Object.assign({ type: 'backbone' }, where), scanners: { sent: mv.units, lost: loss.lost, survivors: loss.survivors }, intel }, + recipients: [{ userId: uid, role: 'attacker' }], + }); + sendHome(ctx, mv, loss.survivors); + return; + } + + // attack: alliance members only, and not against the own alliance or a pact partner (the world may have changed since it left) + if (!attackerOp.alliance_id) return bounce(ctx, mv, now, 'no_alliance'); + try { E.denyIfFriendly(db, attackerOp, site); } catch (e) { return bounce(ctx, mv, now, e.details.reason || 'invalid_target'); } + + const b = R.resolveBattle({ kind: 'attack', attackers: { units: mv.units, research: mv.extra.research || {} }, defenders: [], firewall: 0, staticDefence: staticDef }); + const survivors = Object.assign({}, b.attacker.survivors); + const oldHolder = site.holder_alliance_id; + if (b.attackerWins) E.transferSite(ctx, site, attackerOp, now); + const ret = sendHome(ctx, mv, survivors); + const data = { + outcome: b.attackerWins ? 'attacker_won' : 'defender_won', arrivedAt: now, site: Object.assign({ type: 'backbone' }, where), origin: townBrief(origin), + attacker: { operator: opBrief({ id: attackerOp.id, name: attackerOp.name, as_number: attackerOp.as_number }), alliance: E.allianceInfo(db, attackerOp.alliance_id), units: { sent: mv.units, lost: b.attacker.lost, survivors } }, + power: { attack: b.A, defence: b.D }, taken: b.attackerWins, returnMovementId: ret ? ret.id : null, + }; + const recipients = [{ userId: uid, role: 'attacker' }]; + if (oldHolder) for (const m of db.all('SELECT o.user_id AS uid FROM alliance_members am JOIN operators o ON o.id = am.operator_id WHERE am.alliance_id = ?', oldHolder)) recipients.push({ userId: m.uid, role: 'defender' }); + createReport(ctx, { worldId: mv.worldId, type: 'landing', now, summary: { outcome: data.outcome, site: data.site, attacker: data.attacker.operator, taken: b.attackerWins }, data, recipients }); +}; diff --git a/server/military/movements.js b/server/military/movements.js index 088a758..d46ded7 100644 --- a/server/military/movements.js +++ b/server/military/movements.js @@ -46,10 +46,12 @@ function launchReturn(ctx, o) { }); } -// Transport links in use by a POP: transports it sent that are still out, plus the empty return legs of transports. +// Transport links in use by a POP: transports it sent that are still out, plus the empty return legs of transports, plus the +// open Internet exchange offers it posted (an open offer holds a link in reserve: accepting it sends the escrow on that link). function activeLinks(db, townId) { return db.get(`SELECT COUNT(*) AS n FROM movements WHERE status = 'out' AND - ((type = 'transport' AND from_town_id = ?) OR (type = 'return' AND to_town_id = ? AND json_extract(extra, '$.link') = 1))`, townId, townId).n; + ((type = 'transport' AND from_town_id = ?) OR (type = 'return' AND to_town_id = ? AND json_extract(extra, '$.link') = 1))`, townId, townId).n + + db.get("SELECT COUNT(*) AS n FROM trade_offers WHERE town_id = ? AND status = 'open'", townId).n; } // Hooks for later stages (trade): called after a transport has been delivered. fn(ctx, movement, { added, lost }). diff --git a/server/military/views.js b/server/military/views.js index c4c90fa..d17cfe0 100644 --- a/server/military/views.js +++ b/server/military/views.js @@ -32,7 +32,7 @@ function ownerView(m, names) { to: { townId: m.to_town_id, x: m.to_x, y: m.to_y, name: t ? t.name : null }, units: j(m.units), cargo: j(m.cargo), departAt: m.depart_at, arriveAt: m.arrive_at, recallableUntil: m.type === 'return' ? null : m.depart_at + D.MILITARY.recallWindowMs, - target: extra.target || null, parentId: m.parent_id, + target: extra.target || null, parentId: m.parent_id, siteId: extra.siteId || null, // siteId: a shipment to a backbone landing site }; } @@ -55,8 +55,27 @@ function movementLists(db, operatorId, townId) { const inc = db.all(`SELECT m.* FROM movements m JOIN towns t ON t.id = m.to_town_id WHERE t.owner_id = ? AND m.owner_id != ? AND m.status = 'out' AND m.type != 'return' ${townId ? 'AND m.to_town_id = ?' : ''} ORDER BY m.arrive_at, m.id LIMIT ?`, ...(townId ? [operatorId, operatorId, townId, D.MILITARY.maxLists] : [operatorId, operatorId, D.MILITARY.maxLists])); - const names = townNames(db, own.concat(inc).flatMap((m) => [m.from_town_id, m.to_town_id])); - return { outgoing: own.map((m) => ownerView(m, names)), incoming: inc.map((m) => incomingView(m, names)) }; + // Confederation members (own alliance included) see what is heading for each other's POPs: origin and ETA only, the type + // stays hidden. Movements of operators who are themselves partners of the target are friendly traffic and left out. + // Only in the whole-operator list, not in the per-POP lists. + let allied = []; + if (!townId) { + const partners = require('../alliances').confederatedOperators(db, operatorId); + if (partners.length) { + allied = db.all(`SELECT m.*, t.owner_id AS target_owner FROM movements m JOIN towns t ON t.id = m.to_town_id WHERE t.owner_id IN (${partners.map(() => '?').join(',')}) + AND m.owner_id != t.owner_id AND m.owner_id != ? AND m.status = 'out' AND m.type != 'return' ORDER BY m.arrive_at, m.id LIMIT ?`, ...partners, operatorId, D.MILITARY.maxLists) + .filter((m) => !U.pactBlocks(db, m.owner_id, m.target_owner)); + } + } + const names = townNames(db, own.concat(inc, allied).flatMap((m) => [m.from_town_id, m.to_town_id])); + const out = { outgoing: own.map((m) => ownerView(m, names)), incoming: inc.map((m) => incomingView(m, names)) }; + if (!townId) { + out.alliedIncoming = allied.map((m) => { + const o = db.get('SELECT id, name FROM operators WHERE id = ?', m.target_owner); + return Object.assign(incomingView(m, names), { ally: true, toOperator: { id: o.id, name: o.name } }); + }); + } + return out; } // The military part of GET /towns/:id (the town object is already loaded and belongs to the caller). @@ -127,7 +146,7 @@ function createMilitaryQueries({ db, clock, scheduler }) { const now = fresh(); const op = operatorFor(userId, worldId); const world = loadWorld(db, op.world_id); - const tile = R.tileAt(world.seed, world.map_radius, x, y); + const tile = R.tileAt(world.seed, world.map_radius, x, y, R.worldAgeDays(world.start_at, now, world.speed)); if (tile.type === 'void') throw new GameError('not_found', { what: 'tile' }); const row = db.get('SELECT * FROM towns WHERE world_id = ? AND x = ? AND y = ?', world.id, x, y); const mine = U.operatorTowns(db, op.id); @@ -140,11 +159,18 @@ function createMilitaryQueries({ db, clock, scheduler }) { const taken = !!db.get('SELECT 1 AS x FROM incumbent_takes WHERE world_id = ? AND x = ? AND y = ? AND operator_id = ?', world.id, x, y, op.id); out.incumbent = { takenByYou: taken, hardwareBonus: taken ? 0 : D.INCUMBENT.hardwareBonus }; } + if (tile.type === 'backbone') { // end game: who holds the site, its node level and stockpile, whether you could attack it + const E = require('../endgame'); + const st = E.siteStates(db, world, now).find((s) => s.site.index === tile.site); + const v = E.siteView(db, world, st.site, st.row); + const holds = !!(op.alliance_id && v.holder && v.holder.allianceId === op.alliance_id); + out.backbone = { siteId: v.id, index: v.index, holder: v.holder, level: v.level, maxLevel: v.maxLevel, pool: v.pool, build: v.build, mine: holds, canAttack: !!op.alliance_id && !holds }; + } const fp = U.operatorFootprint(db, op.id, now); const gate = R.footprintGate(mine.length, fp); let nearest = Infinity; for (const t of mine) nearest = Math.min(nearest, R.distance(t.x, t.y, x, y)); - const sc = R.settleCheck({ tileType: tile.type, occupied: !!row, nearestOwnDist: nearest, ownedCount: mine.length, footprint: fp }); + const sc = R.settleCheck({ tileType: tile.type, backbone: R.isBackboneSite(world.seed, world.map_radius, x, y), occupied: !!row, nearestOwnDist: nearest, ownedCount: mine.length, footprint: fp }); out.settle = { possible: sc.ok, code: sc.ok ? null : sc.code, footprint: fp, footprintNeeded: gate.need, maxDistance: D.EXPANSION.maxDistance }; return out; } diff --git a/server/push.js b/server/push.js new file mode 100644 index 0000000..e799a30 --- /dev/null +++ b/server/push.js @@ -0,0 +1,201 @@ +'use strict'; +/* + * WebSocket push (stage 6): transport and connection registry only, no game knowledge (that lives in pushHooks.js). + * Push is a HINT: small JSON messages saying "something changed, refetch over REST". See docs/PROTOCOL.md. + * + * const push = createPush({ clock, authenticate, tokenValid, townOwner, opts, log }); + * httpServer.on('upgrade', push.onUpgrade); + * push.toUser(userId, { type: 'town', townId: 7 }); // all sockets of that user + * push.toTown(7, { type: 'town', townId: 7 }); // the user who owns POP 7 right now + * await push.close(); // 1001 to everybody, resolves when the sockets are gone + * + * Deps: authenticate(header, now) -> { user, tokenId } | null (auth.authenticate), tokenValid(tokenId) -> bool (re-checked on + * every ping tick: revoked token or banned user), townOwner(townId) -> userId | null, opts (the createServer options: + * trustProxy, trustedProxies, allowedOrigins, maxConnPerIp, optional wsAuthTimeoutMs / wsPingMs / wsRate / wsBurst / wsBadBudget). + */ +const { WebSocketServer } = require('ws'); +const { originAllowed, clientIp, TokenBucket } = require('./net'); + +const CLOSE = { SHUTDOWN: 1001, BAD_MESSAGES: 4400, UNAUTHORIZED: 4401, AUTH_TIMEOUT: 4408, RATE_LIMITED: 4429 }; +const MAX_PAYLOAD = 1024; // bytes per client message +const MAX_BUFFERED = 1024 * 1024; // a client that does not read 1 MB of hints is dead weight + +function createPush(deps) { + const { clock, authenticate, tokenValid, townOwner, opts } = deps; + const log = deps.log || (() => {}); + const cfg = { + authTimeoutMs: opts.wsAuthTimeoutMs || 10000, pingMs: opts.wsPingMs || 30000, + rate: opts.wsRate || 5, burst: opts.wsBurst || 15, badBudget: opts.wsBadBudget || 5, + maxConnPerIp: opts.maxConnPerIp === undefined ? 40 : opts.maxConnPerIp, closeGraceMs: 1000, + }; + const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_PAYLOAD, perMessageDeflate: false, clientTracking: false }); + const conns = new Set(); + const byUser = new Map(); // userId -> Set (authenticated sockets) + const perIp = new Map(); // ip -> open sockets (also not yet authenticated ones) + let closing = false; + + // ------------------------------------------------------------ upgrade + function refuse(socket, status, text, why) { + log('refused ws ' + why); + try { socket.write('HTTP/1.1 ' + status + ' ' + text + '\r\nConnection: close\r\nContent-Length: 0\r\n\r\n'); } catch (e) { /* gone */ } + socket.destroy(); + } + + function onUpgrade(req, socket, head) { + socket.on('error', () => {}); // a reset during the handshake must not crash the process + let pathname = ''; + try { pathname = new URL(req.url || '/', 'http://x').pathname; } catch (e) { /* stays '' */ } + const ip = clientIp(req, opts.trustProxy, opts.trustedProxies); + if (pathname !== '/ws') return refuse(socket, 404, 'Not Found', 'path=' + JSON.stringify(pathname.slice(0, 60)) + ' ip=' + ip); + if (closing) return refuse(socket, 503, 'Service Unavailable', 'shutting down ip=' + ip); + if (!originAllowed(req, opts)) return refuse(socket, 403, 'Forbidden', 'origin=' + JSON.stringify(String(req.headers.origin).slice(0, 100)) + ' ip=' + ip); + if (cfg.maxConnPerIp > 0 && (perIp.get(ip) || 0) >= cfg.maxConnPerIp) return refuse(socket, 429, 'Too Many Requests', 'conn_cap ip=' + ip + ' max=' + cfg.maxConnPerIp); + // handleUpgrade calls back synchronously on success and not at all when the handshake is malformed, so the per-IP + // count is taken in the callback: nothing can leak it. + wss.handleUpgrade(req, socket, head, (ws) => accept(ws, ip)); + } + + // ------------------------------------------------------------ connections + function accept(ws, ip) { + perIp.set(ip, (perIp.get(ip) || 0) + 1); + const c = { + ws, ip, userId: null, tokenId: null, alive: true, bad: 0, bucket: new TokenBucket(cfg.rate, cfg.burst), + out: new Map(), flushing: false, authTimer: null, killTimer: null, gone: false, + }; + conns.add(c); + if (ws._socket && ws._socket.setNoDelay) ws._socket.setNoDelay(true); + c.authTimer = setTimeout(() => { log('ws closed auth_timeout ip=' + ip); closeConn(c, CLOSE.AUTH_TIMEOUT, 'auth_timeout'); }, cfg.authTimeoutMs); + ws.on('message', (data, isBinary) => onMessage(c, data, isBinary)); + ws.on('pong', () => { c.alive = true; }); + ws.on('error', (err) => { log('ws error ip=' + ip + ': ' + (err && err.message)); }); // 'close' follows + ws.on('close', () => drop(c)); + } + + function drop(c) { + if (c.gone) return; + c.gone = true; + clearTimeout(c.authTimer); clearTimeout(c.killTimer); + conns.delete(c); + const n = (perIp.get(c.ip) || 1) - 1; + if (n > 0) perIp.set(c.ip, n); else perIp.delete(c.ip); + if (c.userId !== null) { + const set = byUser.get(c.userId); + if (set) { set.delete(c); if (!set.size) byUser.delete(c.userId); } + } + } + + function closeConn(c, code, reason) { + if (c.gone || c.closing) return; + c.closing = true; + try { c.ws.close(code, reason); } catch (e) { try { c.ws.terminate(); } catch (e2) { /* gone */ } } + c.killTimer = setTimeout(() => { try { c.ws.terminate(); } catch (e) { /* gone */ } }, cfg.closeGraceMs); + if (c.killTimer.unref) c.killTimer.unref(); + } + + function sendNow(c, obj) { + if (c.gone || c.closing || c.ws.readyState !== 1) return false; + if (c.ws.bufferedAmount > MAX_BUFFERED) { log('ws terminated: client not reading ip=' + c.ip); c.ws.terminate(); return false; } + c.ws.send(JSON.stringify(obj)); + return true; + } + + // Hints are coalesced: identical messages produced in the same tick (many events of one catch-up) go out once. + function queue(c, msg) { + if (c.userId === null || c.gone || c.closing) return; + c.out.set(JSON.stringify(msg), true); + if (!c.flushing) { c.flushing = true; setImmediate(() => flush(c)); } + } + + function flush(c) { + c.flushing = false; + const items = c.out; c.out = new Map(); + if (c.gone || c.closing || c.ws.readyState !== 1) return; + for (const text of items.keys()) { + if (c.ws.bufferedAmount > MAX_BUFFERED) { log('ws terminated: client not reading ip=' + c.ip); c.ws.terminate(); return; } + c.ws.send(text); + } + } + + function bad(c, why) { + c.bad++; + log('ws bad message (' + why + ') ip=' + c.ip + ' user=' + c.userId + ' ' + c.bad + '/' + cfg.badBudget); + if (c.bad >= cfg.badBudget) closeConn(c, CLOSE.BAD_MESSAGES, 'too_many_bad_messages'); + } + + function onMessage(c, data, isBinary) { + if (c.gone || c.closing) return; + c.alive = true; + if (!c.bucket.take()) { log('refused ws rate_limited ip=' + c.ip + ' user=' + c.userId); return closeConn(c, CLOSE.RATE_LIMITED, 'rate_limited'); } + let m = null; + if (!isBinary) { try { m = JSON.parse(data.toString('utf8')); } catch (e) { m = null; } } + const ok = m && typeof m === 'object' && !Array.isArray(m) && typeof m.type === 'string'; + + if (c.userId === null) { // the FIRST message must authenticate; anything else is fatal + if (!ok || m.type !== 'auth') { log('refused ws unauthorized (first message is not auth) ip=' + c.ip); return closeConn(c, CLOSE.UNAUTHORIZED, 'auth_required'); } + const a = typeof m.token === 'string' && m.token.length <= 200 ? authenticate('Bearer ' + m.token, clock.now()) : null; + if (!a) { log('refused ws unauthorized (bad token) ip=' + c.ip); return closeConn(c, CLOSE.UNAUTHORIZED, 'invalid_token'); } + clearTimeout(c.authTimer); c.authTimer = null; + c.userId = a.user.id; c.tokenId = a.tokenId; + let set = byUser.get(c.userId); + if (!set) { set = new Set(); byUser.set(c.userId, set); } + set.add(c); + sendNow(c, { type: 'ready', serverTime: clock.now() }); + return; + } + if (!ok) return bad(c, isBinary ? 'binary' : 'not a JSON object with a type'); + if (m.type === 'ping') { sendNow(c, { type: 'pong', serverTime: clock.now() }); return; } + return bad(c, 'unknown type ' + JSON.stringify(m.type.slice(0, 20))); + } + + // ------------------------------------------------------------ keepalive + revocation + function tick() { + for (const c of conns) { + if (c.gone || c.closing) continue; + if (!c.alive) { log('ws dead, terminating ip=' + c.ip + ' user=' + c.userId); try { c.ws.terminate(); } catch (e) { /* gone */ } continue; } + if (c.tokenId !== null) { + let valid = true; + try { valid = tokenValid(c.tokenId); } catch (e) { log('ws token check failed: ' + e.message); } + if (!valid) { log('ws closed token_revoked user=' + c.userId); closeConn(c, CLOSE.UNAUTHORIZED, 'token_revoked'); continue; } + } + c.alive = false; + try { c.ws.ping(); } catch (e) { /* closing */ } + } + } + const timer = setInterval(tick, cfg.pingMs); + if (timer.unref) timer.unref(); + + // ------------------------------------------------------------ public API + function toUser(userId, msg) { + const set = byUser.get(userId); + if (set) for (const c of set) queue(c, msg); + } + + function toTown(townId, msg) { + if (!byUser.size) return; // nobody connected: no lookup + const owner = townOwner(townId); + if (owner) toUser(owner, msg); + } + + function close() { + if (closing) return closing_; + closing = true; + clearInterval(timer); + closing_ = new Promise((resolve) => { + for (const c of conns) { if (c.flushing) flush(c); closeConn(c, CLOSE.SHUTDOWN, 'shutdown'); } + const done = () => { wss.close(); resolve(); }; + if (!conns.size) return done(); + const wait = setInterval(() => { if (!conns.size) { clearInterval(wait); done(); } }, 10); + setTimeout(() => { for (const c of conns) { try { c.ws.terminate(); } catch (e) { /* gone */ } } }, cfg.closeGraceMs + 50).unref(); + }); + return closing_; + } + let closing_ = null; + + return { + onUpgrade, toUser, toTown, close, + stats: () => ({ connections: conns.size, users: byUser.size, ips: perIp.size }), + CLOSE, + }; +} + +module.exports = { createPush, CLOSE, MAX_PAYLOAD }; diff --git a/server/pushHooks.js b/server/pushHooks.js new file mode 100644 index 0000000..28170ef --- /dev/null +++ b/server/pushHooks.js @@ -0,0 +1,84 @@ +'use strict'; +/* + * The game-aware half of push: which hint goes to whom. push.js knows sockets; this file knows notifications, events and + * commands. Hooks fire only AFTER the transaction that caused them committed (scheduler outbox, commands.run). + * + * notification row (any kind) -> user: {type:'notification', id, kind} + * kind incoming -> user: {type:'incoming', townId, arriveAt} + * kind report -> user: {type:'report', id} + * kind message | alliance_message -> user: {type:'message', id} + * town_lost, town_gained, ... -> user: {type:'town', townId} (ownership changed: the old owner is not + * reachable through toTown any more) + * event done (build, train, research, arrive, return ...) -> owner of every POP it touched: {type:'town', townId} + * command done (build, train, send, ...) -> owner of every POP it touched: {type:'town', townId} + * (also the device that issued it: the client may ignore its own echo; other devices of the user learn from it) + * + * Not a hint source: reading (GET) never pushes. + */ + +const isId = (v) => Number.isInteger(v) && v > 0; + +// notification kind -> payload key holding a POP id whose state changed for THAT user (kinds whose event does not already +// carry the town in events.town_id, or whose owner changed) +const TOWN_KINDS = { + town_lost: 'townId', town_gained: 'townId', + transport_arrived: 'townId', transport_delivered: 'toTownId', + movement_returned: 'townId', reinforcements_sent_home: 'ownerTownId', +}; + +// Command args that name a POP the command changed (the receiving POP of a movement is NOT listed: the defender gets +// an 'incoming' hint, never a plain 'town' one that would give the launch away without its ETA). +const COMMAND_TOWN_KEYS = ['townId', 'fromTownId', 'hostTownId', 'ownerTownId']; + +// Deps for createPush that need the database. +function pushDeps(db) { + const owner = 'SELECT o.user_id AS uid FROM towns t JOIN operators o ON o.id = t.owner_id WHERE t.id = ?'; + const valid = 'SELECT 1 AS ok FROM tokens t JOIN users u ON u.id = t.user_id WHERE t.id = ? AND t.revoked_at IS NULL AND u.banned = 0'; + return { + townOwner: (townId) => { const r = db.get(owner, townId); return r ? r.uid : null; }, + tokenValid: (tokenId) => !!db.get(valid, tokenId), + }; +} + +function bindGame({ push, db, scheduler, commands, log }) { + const toTowns = (ids) => { for (const id of ids) push.toTown(id, { type: 'town', townId: id }); }; + + function movementTowns(movementId, ids) { + if (!isId(movementId)) return; + const mv = db.get('SELECT from_town_id AS f, to_town_id AS t FROM movements WHERE id = ?', movementId); + if (mv) { if (isId(mv.f)) ids.add(mv.f); if (isId(mv.t)) ids.add(mv.t); } + } + + // ---- notifications: written by events and commands via scheduler.notify + scheduler.onNotify = (n) => { + const p = n.payload || {}; + push.toUser(n.userId, { type: 'notification', id: n.id, kind: n.type }); + if (n.type === 'incoming' && isId(p.toTownId)) push.toUser(n.userId, { type: 'incoming', townId: p.toTownId, arriveAt: p.arriveAt }); + else if (n.type === 'report' && isId(p.reportId)) push.toUser(n.userId, { type: 'report', id: p.reportId }); + else if ((n.type === 'message' || n.type === 'alliance_message') && isId(p.messageId)) push.toUser(n.userId, { type: 'message', id: p.messageId }); + const key = TOWN_KINDS[n.type]; + if (key && isId(p[key])) push.toUser(n.userId, { type: 'town', townId: p[key] }); + }; + + // ---- events: the POPs an event touched (events.town_id, or both ends of a movement) + const prevOnEvent = scheduler.onEvent; + scheduler.onEvent = (ev) => { + if (prevOnEvent) prevOnEvent(ev); + const ids = new Set(); + if (isId(ev.townId)) ids.add(ev.townId); + if (ev.type === 'arrive' || ev.type === 'return') movementTowns(ev.payload && ev.payload.movementId, ids); + toTowns(ids); + }; + + // ---- commands + commands.hooks.onCommand = (name, args, out) => { + const ids = new Set(); + for (const k of COMMAND_TOWN_KEYS) if (args && isId(args[k])) ids.add(args[k]); + if (out && isId(out.townId)) ids.add(out.townId); // joinWorld: the new POP + if (name === 'recallMovement') movementTowns(args.movementId, ids); // also tells the target's owner the warning is gone + toTowns(ids); + }; + if (log) log('push hooks bound'); +} + +module.exports = { bindGame, pushDeps, TOWN_KINDS, COMMAND_TOWN_KEYS }; diff --git a/server/queries.js b/server/queries.js index 80135b3..d046a57 100644 --- a/server/queries.js +++ b/server/queries.js @@ -89,10 +89,16 @@ function createQueries({ db, clock, scheduler }) { r = Math.min(r, 40); const x0 = Math.max(-rad, x - r), x1 = Math.min(rad, x + r), y0 = Math.max(-rad, y - r), y1 = Math.min(rad, y + r); const specials = []; + const age = R.worldAgeDays(world.start_at, now, world.speed); + const sites = new Map(require('./endgame').siteStates(db, world, now).map(({ site, row }) => [site.index, require('./endgame').siteView(db, world, site, row)])); for (let yy = y0; yy <= y1; yy++) { for (let xx = x0; xx <= x1; xx++) { - const t = R.tileAt(world.seed, rad, xx, yy); + const t = R.tileAt(world.seed, rad, xx, yy, age); if (t.type === 'rural' || t.type === 'incumbent') specials.push({ x: xx, y: yy, type: t.type, bonus: t.bonus || null }); + else if (t.type === 'backbone') { // end game: landing site with its holder and node level + const v = sites.get(t.site); + specials.push({ x: xx, y: yy, type: 'backbone', bonus: null, site: { id: v.id, index: v.index, holder: v.holder, level: v.level, maxLevel: v.maxLevel } }); + } } } const towns = db.all(`SELECT t.id, t.name, t.x, t.y, t.is_capital, o.id AS oid, o.name AS oname, o.as_number AS asn, o.alliance_id AS ally, a.tag AS atag, a.name AS aname, o.protection_until AS prot diff --git a/server/routes/index.js b/server/routes/index.js index 42d1a62..deb1e61 100644 --- a/server/routes/index.js +++ b/server/routes/index.js @@ -1,6 +1,6 @@ 'use strict'; /* Registers every REST route. One file per resource; each exports register(router, services). */ -const files = [require('./auth'), require('./me'), require('./towns'), require('./map'), require('./alliances'), require('./messages'), require('./rankings'), require('./units'), require('./movements'), require('./reports')]; +const files = [require('./auth'), require('./me'), require('./towns'), require('./map'), require('./alliances'), require('./messages'), require('./rankings'), require('./units'), require('./movements'), require('./reports'), require('./sharedReports'), require('./trade'), require('./world')]; function register(router, services) { for (const f of files) f.register(router, services); diff --git a/server/routes/schemas.js b/server/routes/schemas.js index ab6a95e..32944ca 100644 --- a/server/routes/schemas.js +++ b/server/routes/schemas.js @@ -32,7 +32,7 @@ const schemas = { }), TownResponse: obj({ serverTime: int, town: { $ref: 'Town' } }), MapTown: obj({ id: int, name: str, x: int, y: int, isCapital: bool, owner: obj({ id: int, name: str, asNumber: int, allianceId: { type: ['integer', 'null'] }, alliance: { type: ['object', 'null'], properties: { id: int, tag: str, name: str }, additionalProperties: true }, protected: bool }) }), - MapSpecial: obj({ x: int, y: int, type: str, bonus: { type: ['string', 'null'] } }), + MapSpecial: obj({ x: int, y: int, type: str, bonus: { type: ['string', 'null'] }, site: { type: 'object', additionalProperties: true } }, ['x', 'y', 'type', 'bonus']), MapResponse: obj({ serverTime: int, world: { $ref: 'World' }, bounds: obj({ x0: int, x1: int, y0: int, y1: int }), specials: arr({ $ref: 'MapSpecial' }), towns: arr({ $ref: 'MapTown' }) }), BuildResult: obj({ serverTime: int, eventId: int, key: str, type: str, toLevel: int, startedAt: int, dueAt: int, cost: { $ref: 'Cost' } }), Notification: obj({ id: int, type: str, worldId: { type: ['integer', 'null'] }, payload: { type: 'object', additionalProperties: true }, createdAt: int, readAt: { type: ['integer', 'null'] } }), @@ -78,5 +78,6 @@ const schemas = { }; require('./schemasMilitary')(schemas, { int, num, str, bool, obj, arr }); +require('./schemasEndgame')(schemas, { int, num, str, bool, obj, arr }); module.exports = { schemas, int, num, str, bool, obj, arr }; diff --git a/server/routes/schemasEndgame.js b/server/routes/schemasEndgame.js new file mode 100644 index 0000000..a02c7a2 --- /dev/null +++ b/server/routes/schemasEndgame.js @@ -0,0 +1,45 @@ +'use strict'; +/* Response schemas of trade, the end game and the shared report folder (merged into routes/schemas.js). Documentation + * only, like the others (test helpers can check them with createTestServer({ contract: true })). */ +module.exports = function addEndgameSchemas(schemas, { int, num, str, bool, obj, arr }) { + const nint = { type: ['integer', 'null'] }; + const nstr = { type: ['string', 'null'] }; + const free = { type: 'object', additionalProperties: true }; + const Cost = { $ref: 'Cost' }; + Object.assign(schemas, { + // ---- trade + TradeAmount: obj({ resource: str, amount: int }), + TradeOffer: obj({ + id: int, status: str, worldId: int, townId: int, townName: nstr, x: nint, y: nint, operator: obj({ id: int, name: nstr }), + give: { $ref: 'TradeAmount' }, want: { $ref: 'TradeAmount' }, maxDistance: int, createdAt: int, expiresAt: int, acceptedAt: nint, closedAt: nint, + role: str, acceptableFrom: arr(obj({ townId: int, distance: num })), + }, ['id', 'status', 'townId', 'operator', 'give', 'want', 'maxDistance', 'createdAt', 'expiresAt']), + TradeOfferList: obj({ serverTime: int, items: arr({ $ref: 'TradeOffer' }), next: nint, exchangeLevels: arr(obj({ townId: int, level: int, reach: num })) }, ['serverTime', 'items', 'next']), + TradeOfferResponse: obj({ serverTime: int, offer: { $ref: 'TradeOffer' } }), + TradeCancelled: obj({ serverTime: int, offerId: int, status: str, returned: { $ref: 'TradeAmount' } }), + TradeAccepted: obj({ serverTime: int, offerId: int, status: str, goodsMovementId: int, paymentMovementId: int, distance: num, arriveAt: int, give: { $ref: 'TradeAmount' }, want: { $ref: 'TradeAmount' } }), + // ---- end game + LandingSite: obj({ + id: nint, index: int, x: int, y: int, holder: { type: ['object', 'null'], properties: { allianceId: int, tag: str, name: str }, additionalProperties: true }, + takenBy: { type: ['object', 'null'], additionalProperties: true }, takenAt: nint, level: int, maxLevel: int, progress: num, pool: Cost, + build: { type: ['object', 'null'], properties: { toLevel: int, startedAt: int, dueAt: int }, additionalProperties: true }, + next: { type: ['object', 'null'], properties: { toLevel: int, cost: Cost, durationMs: int }, additionalProperties: true }, + }), + WorldStatus: obj({ + serverTime: int, worldId: int, name: str, speed: num, status: str, phase: str, ageDays: num, openDay: int, opensAt: int, + sites: arr({ $ref: 'LandingSite' }), winner: { type: ['object', 'null'], additionalProperties: true }, endsAt: nint, endedAt: nint, + }), + WorldResults: obj({ serverTime: int, available: bool, status: str, winner: { type: ['object', 'null'], additionalProperties: true }, endsAt: nint, results: { type: ['object', 'null'], additionalProperties: true } }), + LandingSiteResponse: obj({ + serverTime: int, site: { $ref: 'LandingSite' }, you: obj({ holder: bool, canBuild: bool, canShip: bool, canAttack: bool }), + contributions: arr(obj({ operatorId: int, name: str, fiber: int, hardware: int, capital: int })), + }, ['serverTime', 'site', 'you']), + BackboneBuildStarted: obj({ serverTime: int, siteId: int, eventId: int, toLevel: int, startedAt: int, dueAt: int, cost: Cost }), + // ---- shared reports + ReportShared: obj({ serverTime: int, changed: bool, reportId: int, allianceId: int }), + SharedReportItem: obj({ id: int, type: str, createdAt: int, sharedAt: int, sharedBy: obj({ operatorId: int, name: str }), summary: free }), + SharedReportList: obj({ serverTime: int, items: arr({ $ref: 'SharedReportItem' }), next: nint }), + SharedReport: obj({ id: int, type: str, createdAt: int, expiresAt: int, sharedAt: int, sharedBy: obj({ operatorId: int, name: str }), summary: free, data: free }), + SharedReportResponse: obj({ serverTime: int, report: { $ref: 'SharedReport' } }), + }); +}; diff --git a/server/routes/schemasMilitary.js b/server/routes/schemasMilitary.js index 27446ca..e48fd03 100644 --- a/server/routes/schemasMilitary.js +++ b/server/routes/schemasMilitary.js @@ -17,7 +17,7 @@ module.exports = function addMilitarySchemas(schemas, { int, num, str, bool, obj id: int, type: str, status: str, ownerId: int, from: { $ref: 'MovementEnd' }, to: { $ref: 'MovementEnd' }, units: Units, cargo: free, departAt: int, arriveAt: int, recallableUntil: nint, target: { type: ['string', 'null'] }, parentId: nint, incoming: bool, }, ['id', 'type', 'status', 'from', 'to', 'departAt', 'arriveAt']), - MovementList: obj({ serverTime: int, outgoing: arr({ $ref: 'Movement' }), incoming: arr({ $ref: 'Movement' }) }), + MovementList: obj({ serverTime: int, outgoing: arr({ $ref: 'Movement' }), incoming: arr({ $ref: 'Movement' }), alliedIncoming: arr({ $ref: 'Movement' }) }, ['serverTime', 'outgoing', 'incoming']), Marked: obj({ serverTime: int, marked: int }), ReportItem: obj({ id: int, type: str, createdAt: int, role: str, read: bool, summary: free }), ReportList: obj({ serverTime: int, items: arr({ $ref: 'ReportItem' }), next: nint, unread: int }), diff --git a/server/routes/sharedReports.js b/server/routes/sharedReports.js new file mode 100644 index 0000000..14a447b --- /dev/null +++ b/server/routes/sharedReports.js @@ -0,0 +1,30 @@ +'use strict'; +/* The alliance's shared report folder: share one of your reports, list and read the folder, take one out. */ +const { createSharedReportQueries } = require('../sharedReports'); + +function register(router, services) { + const { commands } = services; + const folder = createSharedReportQueries(services); + const errs = ['unauthorized', 'not_found', 'validation_failed']; + + router.post('/reports/:id/share', { + summary: 'Put one of your reports into your alliance\'s shared folder (needs shareReport; keeps the report for another 14 days)', tag: 'reports', + response: { $ref: 'ReportShared' }, errors: errs.concat(['not_in_alliance', 'forbidden', 'world_ended']), + }, ({ user, params }) => commands.run('reportShare', { userId: user.id, reportId: params.id })); + + router.del('/reports/:id/share', { + summary: 'Take a report out of the alliance folder (whoever shared it, or leader/officer)', tag: 'reports', + response: { $ref: 'ReportShared' }, errors: errs.concat(['forbidden', 'world_ended']), + }, ({ user, params }) => commands.run('reportUnshare', { userId: user.id, reportId: params.id })); + + router.get('/alliances/:id/reports', { + summary: 'The alliance\'s shared reports, newest first (cursor: after = id of the last report seen; members only)', tag: 'reports', + query: { type: 'object', properties: { after: { type: 'integer', minimum: 1 }, limit: { type: 'integer', minimum: 1, maximum: 100 } } }, + response: { $ref: 'SharedReportList' }, errors: errs.concat(['forbidden']), + }, ({ user, params, query }) => folder.list(user.id, params.id, query)); + + router.get('/alliances/:id/reports/:reportId', { + summary: 'One shared report with its full data (members only)', tag: 'reports', response: { $ref: 'SharedReportResponse' }, errors: errs.concat(['forbidden']), + }, ({ user, params }) => folder.get(user.id, params.id, params.reportId)); +} +module.exports = { register }; diff --git a/server/routes/trade.js b/server/routes/trade.js new file mode 100644 index 0000000..3224988 --- /dev/null +++ b/server/routes/trade.js @@ -0,0 +1,53 @@ +'use strict'; +/* Internet exchange: open offers, your offers, create / cancel / accept. Direct transports (to your own POPs or any player) + * are POST /movements with type "transport". */ +const { reply } = require('../http'); +const { createTradeQueries } = require('../tradeQueries'); +const D = require('../../public/js/data.js'); + +const int1 = { type: 'integer', minimum: 1 }; +const res = { type: 'string', enum: D.RESOURCES }; +const page = { after: { type: 'integer', minimum: 0 }, limit: { type: 'integer', minimum: 1, maximum: 100 } }; + +function register(router, services) { + const { commands } = services; + const trade = createTradeQueries(services); + const errs = ['unauthorized', 'not_found', 'validation_failed']; + + router.get('/trade/offers', { + summary: 'Open offers you can take: within the offer\'s max distance and the reach of one of your Internet exchanges (newest first, cursor: after = last id seen)', tag: 'trade', + query: { type: 'object', properties: Object.assign({ worldId: int1, townId: int1, give: res, want: res }, page) }, response: { $ref: 'TradeOfferList' }, errors: errs, + }, ({ user, query }) => trade.offers(user.id, query)); + + router.get('/trade/offers/mine', { + summary: 'Offers you posted or accepted, any status (newest first)', tag: 'trade', + query: { type: 'object', properties: Object.assign({ worldId: int1, status: { type: 'string', enum: ['open', 'accepted', 'completed', 'cancelled', 'expired', 'void'] } }, page) }, + response: { $ref: 'TradeOfferList' }, errors: errs, + }, ({ user, query }) => trade.mineOffers(user.id, query)); + + router.get('/trade/offers/:id', { + summary: 'One offer (open ones to every operator of the world, closed ones to the two parties)', tag: 'trade', response: { $ref: 'TradeOfferResponse' }, errors: errs, + }, ({ user, params }) => trade.offer(user.id, params.id)); + + router.post('/trade/offers', { + summary: 'Post an offer from one of your POPs: give X of A for Y of B within a max distance. The offered amount is escrowed and a transport link reserved', + tag: 'trade', status: 201, + body: { + type: 'object', required: ['townId', 'giveRes', 'giveAmount', 'wantRes', 'wantAmount', 'maxDistance'], + properties: { townId: int1, giveRes: res, giveAmount: int1, wantRes: res, wantAmount: int1, maxDistance: { type: 'integer', minimum: 1, maximum: D.TRADE.maxDistance } }, + }, + response: { $ref: 'TradeOfferResponse' }, errors: errs.concat(['trade_ratio', 'capacity_exceeded', 'no_transport_link', 'not_enough_resources', 'world_ended']), + }, ({ user, body }) => reply(201, commands.run('tradeOffer', Object.assign({ userId: user.id }, body)))); + + router.del('/trade/offers/:id', { + summary: 'Cancel your open offer; the escrow returns to the POP', tag: 'trade', response: { $ref: 'TradeCancelled' }, errors: errs.concat(['offer_closed', 'world_ended']), + }, ({ user, params }) => commands.run('tradeCancel', { userId: user.id, offerId: params.id })); + + router.post('/trade/offers/:id/accept', { + summary: 'Take an open offer with one of your POPs: two transports leave at once (your payment, their goods) and the offer is settled when both arrive', tag: 'trade', status: 201, + body: { type: 'object', required: ['townId'], properties: { townId: int1 } }, + response: { $ref: 'TradeAccepted' }, + errors: errs.concat(['offer_closed', 'own_offer', 'trade_out_of_range', 'no_transport_link', 'capacity_exceeded', 'not_enough_resources', 'world_ended']), + }, ({ user, params, body }) => reply(201, commands.run('tradeAccept', { userId: user.id, offerId: params.id, townId: body.townId }))); +} +module.exports = { register }; diff --git a/server/routes/world.js b/server/routes/world.js new file mode 100644 index 0000000..5b577fa --- /dev/null +++ b/server/routes/world.js @@ -0,0 +1,41 @@ +'use strict'; +/* End game: the race (world status), the final results, landing sites (read, feed the stockpile, build the node). Taking a site is + * POST /movements (scan / attack at its x,y). */ +const { reply } = require('../http'); +const { createEndgameQueries } = require('../endgameQueries'); +const D = require('../../public/js/data.js'); + +function register(router, services) { + const { commands } = services; + const eg = createEndgameQueries(services); + const errs = ['unauthorized', 'not_found', 'validation_failed']; + + router.get('/worlds/:id/status', { + summary: 'The state of the world: phase (running, backbone_open, ended), world age, the landing sites with holder, node level, stockpile and build progress, the winner', tag: 'world', + response: { $ref: 'WorldStatus' }, errors: errs, + }, ({ user, params }) => eg.status(user.id, params.id)); + + router.get('/worlds/:id/results', { + summary: 'The final ranking snapshot (operators, alliances, attackers, defenders, winner); available once the world has ended', tag: 'world', + response: { $ref: 'WorldResults' }, errors: errs, + }, ({ user, params }) => eg.results(user.id, params.id)); + + router.get('/backbone/:id', { + summary: 'One landing site; members of the holding alliance also see the contribution ledger and what they may do', tag: 'world', + response: { $ref: 'LandingSiteResponse' }, errors: errs, + }, ({ user, params }) => eg.site(user.id, params.id)); + + router.post('/backbone/:id/ship', { + summary: 'Send resources from one of your POPs to a landing site your alliance holds (a transport: Internet exchange links, 500 each)', tag: 'world', status: 201, + body: { type: 'object', required: ['fromTownId', 'cargo'], properties: { fromTownId: { type: 'integer', minimum: 1 }, cargo: { type: 'object', additionalProperties: true, description: 'fiber/hardware/capital -> amount' } } }, + response: { $ref: 'MovementSent' }, + errors: errs.concat(['forbidden', 'backbone_closed', 'capacity_exceeded', 'no_transport_link', 'not_enough_resources', 'world_ended']), + }, ({ user, params, body }) => reply(201, commands.run('backboneShip', { userId: user.id, siteId: params.id, fromTownId: body.fromTownId, cargo: body.cargo }))); + + router.post('/backbone/:id/build', { + summary: 'Start the next Backbone node level on a landing site your alliance holds (paid from the site\'s stockpile; one level at a time, up to level ' + D.ENDGAME.maxLevel + ')', tag: 'world', status: 201, + response: { $ref: 'BackboneBuildStarted' }, + errors: errs.concat(['forbidden', 'backbone_closed', 'max_level', 'already_queued', 'not_enough_resources', 'world_ended']), + }, ({ user, params }) => reply(201, commands.run('backboneBuild', { userId: user.id, siteId: params.id }))); +} +module.exports = { register }; diff --git a/server/scheduler.js b/server/scheduler.js index 873833a..3c28e0e 100644 --- a/server/scheduler.js +++ b/server/scheduler.js @@ -19,6 +19,21 @@ class Scheduler { this.autoArm = autoArm !== false; this.timer = null; this.running = false; this.closed = false; this.onEvent = null; // optional hook: (event) => void after each processed event (push, tests) + // Notification outbox (stage 6 push): every notify() row is also queued here and handed to onNotify only AFTER the + // transaction that wrote it committed, so a rolled-back change never pushes. Nothing is queued without a listener. + this.onNotify = null; // optional hook: ({ id, userId, worldId, type, payload }) => void, post-commit + this.outbox = []; + } + + // Outbox helpers for code that owns a transaction (process() below, commands.run). + outboxMark() { return this.outbox.length; } + outboxRollback(mark) { if (this.outbox.length > mark) this.outbox.length = mark; } + // Deliver queued notifications. A no-op inside a transaction: the outermost commit delivers them. + flushOutbox() { + if (!this.outbox.length || this.db.depth > 0) return; + const items = this.outbox; this.outbox = []; + if (!this.onNotify) return; + for (const n of items) { try { this.onNotify(n); } catch (e) { this.log('onNotify hook failed: ' + e.message); } } } register(type, fn) { this.handlers[type] = fn; } @@ -30,9 +45,13 @@ class Scheduler { return Number(r.lastInsertRowid); } + // Write a notification row (call inside the transaction of the change it announces). Returns the row id. notify(userId, worldId, type, payload) { - this.db.run('INSERT INTO notifications (user_id, world_id, type, payload, created_at) VALUES (?, ?, ?, ?, ?)', + const r = this.db.run('INSERT INTO notifications (user_id, world_id, type, payload, created_at) VALUES (?, ?, ?, ?, ?)', userId, worldId === undefined ? null : worldId, type, JSON.stringify(payload || {}), this.clock.now()); + const id = Number(r.lastInsertRowid); + if (this.onNotify) { this.outbox.push({ id, userId, worldId: worldId === undefined ? null : worldId, type, payload: payload || {} }); this.flushOutbox(); } + return id; } next() { return this.db.get("SELECT id, due_at FROM events WHERE status = 'pending' ORDER BY due_at, id LIMIT 1"); } @@ -58,6 +77,7 @@ class Scheduler { process(ev) { const handler = this.handlers[ev.type]; const event = { id: ev.id, worldId: ev.world_id, dueAt: ev.due_at, type: ev.type, townId: ev.town_id, payload: JSON.parse(ev.payload) }; + const mark = this.outboxMark(); try { this.db.tx(() => { if (!handler) throw new Error('no handler for event type ' + ev.type); @@ -65,10 +85,12 @@ class Scheduler { this.db.run("UPDATE events SET status = 'done', done_at = ? WHERE id = ?", this.clock.now(), ev.id); }); } catch (err) { + this.outboxRollback(mark); this.log('event ' + ev.id + ' (' + ev.type + ') failed: ' + (err && err.stack || err)); this.db.run("UPDATE events SET status = 'failed', done_at = ?, error = ? WHERE id = ?", this.clock.now(), String(err && err.message || err).slice(0, 500), ev.id); return; } + this.flushOutbox(); if (this.onEvent) { try { this.onEvent(event); } catch (e) { this.log('onEvent hook failed: ' + e.message); } } } diff --git a/server/sharedReports.js b/server/sharedReports.js new file mode 100644 index 0000000..fab05bc --- /dev/null +++ b/server/sharedReports.js @@ -0,0 +1,35 @@ +'use strict'; +/* Read model of the alliance's shared report folder. Newest first, `after` = id of the last report you have (older ones + * follow), like GET /reports. Members with `viewSharedReports` only. */ +const { GameError } = require('./errors'); +const A = require('./alliances'); + +const j = (s) => JSON.parse(s || '{}'); + +function createSharedReportQueries({ db, clock, scheduler }) { + const fresh = () => { scheduler.runDue(); return clock.now(); }; + + function list(userId, allianceId, { after, limit }) { + const now = fresh(); + A.requireRole(db, userId, allianceId, 'viewSharedReports'); + const n = limit || 25; + const rows = db.all(`SELECT r.id, r.type, r.created_at, r.summary, s.created_at AS shared_at, s.shared_by, o.name AS shared_name + FROM report_shares s JOIN reports r ON r.id = s.report_id JOIN operators o ON o.id = s.shared_by + WHERE s.alliance_id = ? ${after ? 'AND r.id < ?' : ''} ORDER BY r.id DESC LIMIT ?`, ...(after ? [allianceId, after, n + 1] : [allianceId, n + 1])); + const items = rows.slice(0, n).map((r) => ({ id: r.id, type: r.type, createdAt: r.created_at, sharedAt: r.shared_at, sharedBy: { operatorId: r.shared_by, name: r.shared_name }, summary: j(r.summary) })); + return { serverTime: now, items, next: rows.length > n ? items[items.length - 1].id : null }; + } + + function get(userId, allianceId, reportId) { + const now = fresh(); + A.requireRole(db, userId, allianceId, 'viewSharedReports'); + const r = db.get(`SELECT r.*, s.created_at AS shared_at, s.shared_by, o.name AS shared_name FROM report_shares s JOIN reports r ON r.id = s.report_id JOIN operators o ON o.id = s.shared_by + WHERE s.alliance_id = ? AND r.id = ?`, allianceId, reportId); + if (!r) throw new GameError('not_found', { what: 'shared report' }); + return { serverTime: now, report: { id: r.id, type: r.type, createdAt: r.created_at, expiresAt: r.expires_at, sharedAt: r.shared_at, sharedBy: { operatorId: r.shared_by, name: r.shared_name }, summary: j(r.summary), data: j(r.data) } }; + } + + return { list, get }; +} + +module.exports = { createSharedReportQueries }; diff --git a/server/socialQueries.js b/server/socialQueries.js index d79d703..d05ee19 100644 --- a/server/socialQueries.js +++ b/server/socialQueries.js @@ -305,7 +305,7 @@ function createSocialQueries({ db, clock, scheduler }) { return { mine, list, get, members, invitesSent, invitesReceived, notes, diplomacy, - rankOperators, rankAlliances, rankBattles, + rankOperators, rankAlliances, rankBattles, footprints, inbox, outbox, thread, allianceFeed, message, blocks, footprints, }; } diff --git a/server/trade.js b/server/trade.js new file mode 100644 index 0000000..23cb469 --- /dev/null +++ b/server/trade.js @@ -0,0 +1,88 @@ +'use strict'; +/* + * Internet exchange trade: shared helpers of the trade commands, the expiry event and the read model. + * + * Offer life cycle (table trade_offers, status): + * open the offered amount is ESCROWED in the row (it left the POP at creation) and one transport link of the poster's POP is + * held in reserve (military/movements.activeLinks counts open offers) + * accepted two transports are on the road: poster -> acceptor carries the escrow, acceptor -> poster carries the payment + * completed both legs were delivered (the `transportArrived` hook below) + * cancelled the poster took it back: the escrow is credited to the POP again + * expired ttl ran out (event `tradeExpire`): same + * void the poster's POP changed hands while the offer was open: the escrow stays in that POP (it goes with the POP) + * Nothing is created or lost: escrow is returned WITHOUT the Rack hall cap (an amount above the cap is kept, it only stops + * growing); the only loss anywhere is what a delivery cannot store (the existing cargoLost rule of transports). + */ +const R = require('../public/js/rules.js'); +const D = require('../public/js/data.js'); +const { loadTown, settle } = require('./state'); +const M = require('./military/movements'); + +const COL = { fiber: 'fiber', hardware: 'hardware', capital: 'capital' }; + +// Credit `amount` of `res` to a POP (settled first, no storage cap: it is a refund of what left the POP). +function refund(db, townId, res, amount, at) { + const town = loadTown(db, townId); + if (!town) return; + settle(db, town, at); + db.run('UPDATE towns SET ' + COL[res] + ' = ' + COL[res] + ' + ? WHERE id = ?', amount, townId); +} + +const getOffer = (db, id) => db.get('SELECT * FROM trade_offers WHERE id = ?', id) || null; + +function expiryMs(speed) { return Math.round(D.TRADE.ttlHours * D.HOUR_MS / (speed || 1)); } + +function userOfOperator(db, operatorId) { const o = db.get('SELECT user_id FROM operators WHERE id = ?', operatorId); return o ? o.user_id : null; } + +// Close an open offer and give the escrow back to its POP. `status`: cancelled | expired | void. -> the offer row (before) +function closeOffer(ctx, offer, status, at) { + const { db } = ctx; + db.run('UPDATE trade_offers SET status = ?, closed_at = ? WHERE id = ?', status, at, offer.id); + if (offer.expire_event_id) db.run("UPDATE events SET status = 'cancelled', done_at = ? WHERE id = ? AND status = 'pending'", at, offer.expire_event_id); + refund(db, offer.town_id, offer.give_res, offer.give_amount, at); + return offer; +} + +// A POP changed hands (takeover): its open offers end and the escrow stays with the POP. Called from combat.transferTown. +function onTownTransferred(ctx, townId, at) { + const { db } = ctx; + for (const o of db.all("SELECT * FROM trade_offers WHERE town_id = ? AND status = 'open'", townId)) { + closeOffer(ctx, o, 'void', at); + const uid = userOfOperator(db, o.operator_id); + if (uid) ctx.notify(uid, o.world_id, 'trade_void', { offerId: o.id, townId }); + } +} + +// `transportArrived` consumer: both legs of an accepted offer delivered -> completed. +function onTransportArrived(ctx, mv, res) { + const tradeId = mv.extra && mv.extra.tradeId; + if (!tradeId) return; + const { db } = ctx; + const o = getOffer(db, tradeId); + if (!o || o.status !== 'accepted') return; + const legs = o.legs_done + 1; + if (legs < 2) { db.run('UPDATE trade_offers SET legs_done = ? WHERE id = ?', legs, o.id); return; } + db.run("UPDATE trade_offers SET legs_done = ?, status = 'completed', closed_at = ? WHERE id = ?", legs, ctx.now, o.id); + const body = { offerId: o.id, give: { resource: o.give_res, amount: o.give_amount }, want: { resource: o.want_res, amount: o.want_amount } }; + for (const opId of [o.operator_id, o.accepted_by_operator]) { + const uid = userOfOperator(db, opId); + if (uid) ctx.notify(uid, o.world_id, 'trade_completed', body); + } +} + +// Registered once, whoever requires this module first (commands and events both do): tests and the server see the same wiring. +if (!M.hooks.transportArrived.some((f) => f.name === 'tradeTransportArrived')) { + M.hooks.transportArrived.push(function tradeTransportArrived(ctx, mv, res) { return onTransportArrived(ctx, mv, res); }); +} + +function offerView(db, o, towns) { + const t = towns && towns.get(o.town_id); + return { + id: o.id, status: o.status, worldId: o.world_id, townId: o.town_id, townName: t ? t.name : null, x: t ? t.x : null, y: t ? t.y : null, + operator: { id: o.operator_id, name: (db.get('SELECT name FROM operators WHERE id = ?', o.operator_id) || {}).name || null }, + give: { resource: o.give_res, amount: o.give_amount }, want: { resource: o.want_res, amount: o.want_amount }, + maxDistance: o.max_distance, createdAt: o.created_at, expiresAt: o.expires_at, acceptedAt: o.accepted_at, closedAt: o.closed_at, + }; +} + +module.exports = { refund, getOffer, expiryMs, closeOffer, onTownTransferred, onTransportArrived, offerView, userOfOperator }; diff --git a/server/tradeQueries.js b/server/tradeQueries.js new file mode 100644 index 0000000..da799c1 --- /dev/null +++ b/server/tradeQueries.js @@ -0,0 +1,82 @@ +'use strict'; +/* + * Read models of the Internet exchange: the open offers you can see and take, your own offers, one offer. Reads catch the event + * queue up first. Lists are newest first, `after` = id of the last offer you have (older ones follow). + * Visibility: an open offer of somebody else is listed when one of your POPs (the one in `townId`, or any) has an Internet + * exchange and the poster's POP is within min(the offer's max distance, that exchange's reach). `acceptableFrom` names those POPs. + */ +const R = require('../public/js/rules.js'); +const D = require('../public/js/data.js'); +const { GameError } = require('./errors'); +const A = require('./alliances'); +const T = require('./trade'); + +function createTradeQueries({ db, clock, scheduler }) { + const fresh = () => { scheduler.runDue(); return clock.now(); }; + const townsOf = (ids) => { + const m = new Map(); + for (const id of ids) if (!m.has(id)) m.set(id, db.get('SELECT id, name, x, y FROM towns WHERE id = ?', id)); + return m; + }; + + // My POPs with an exchange: [{ id, x, y, level }]. + function exchanges(operatorId, townId) { + const rows = db.all(`SELECT t.id, t.x, t.y, b.level AS level FROM towns t JOIN buildings b ON b.town_id = t.id AND b.type = ? WHERE t.owner_id = ? AND b.level >= 1 ${townId ? 'AND t.id = ?' : ''} ORDER BY t.id`, + ...[D.TRANSPORT.building, operatorId].concat(townId ? [townId] : [])); + return rows; + } + + function offers(userId, { worldId, townId, give, want, after, limit }) { + const now = fresh(); + const op = A.operatorOf(db, userId, worldId); + if (townId && !db.get('SELECT 1 AS x FROM towns WHERE id = ? AND owner_id = ?', townId, op.id)) throw new GameError('not_found', { what: 'town' }); + const mine = exchanges(op.id, townId); + const n = limit || 25; + const out = []; + let next = null; + if (mine.length) { + // newest first in chunks: the range filter drops rows, so keep reading until a page is full or the offers are used up + let cur = after || 0, done = false; + while (!done && !next) { + const rows = db.all(`SELECT o.*, t.x AS tx, t.y AS ty FROM trade_offers o JOIN towns t ON t.id = o.town_id WHERE o.world_id = ? AND o.status = 'open' AND o.operator_id != ? + ${give ? 'AND o.give_res = ?' : ''} ${want ? 'AND o.want_res = ?' : ''} ${cur ? 'AND o.id < ?' : ''} ORDER BY o.id DESC LIMIT ?`, + ...[op.world_id, op.id].concat(give ? [give] : [], want ? [want] : [], cur ? [cur] : [], [D.TRADE.scanChunk])); + const towns = townsOf(rows.map((r) => r.town_id)); + for (const r of rows) { + cur = r.id; + const from = mine.map((m) => ({ townId: m.id, distance: R.distance(m.x, m.y, r.tx, r.ty), level: m.level })).filter((m) => R.tradeInRange(m.distance, r.max_distance, m.level)); + if (!from.length) continue; + if (out.length === n) { next = out[out.length - 1].id; break; } + out.push(Object.assign(T.offerView(db, r, towns), { acceptableFrom: from.map((m) => ({ townId: m.townId, distance: m.distance })) })); + } + done = rows.length < D.TRADE.scanChunk; + } + } + return { serverTime: now, items: out, next, exchangeLevels: mine.map((m) => ({ townId: m.id, level: m.level, reach: R.tradeReach(m.level) })) }; + } + + function mineOffers(userId, { worldId, after, limit, status }) { + const now = fresh(); + const op = A.operatorOf(db, userId, worldId); + const n = limit || 25; + const rows = db.all(`SELECT * FROM trade_offers WHERE (operator_id = ? OR accepted_by_operator = ?) ${status ? 'AND status = ?' : ''} ${after ? 'AND id < ?' : ''} ORDER BY id DESC LIMIT ?`, + ...[op.id, op.id].concat(status ? [status] : [], after ? [after] : [], [n + 1])); + const towns = townsOf(rows.map((r) => r.town_id)); + const items = rows.slice(0, n).map((r) => Object.assign(T.offerView(db, r, towns), { role: r.operator_id === op.id ? 'poster' : 'acceptor' })); + return { serverTime: now, items, next: rows.length > n ? items[items.length - 1].id : null }; + } + + // One offer: open ones are public inside the world (to operators of it), the rest only to the two parties. + function offer(userId, id) { + const now = fresh(); + const o = T.getOffer(db, id); + const op = o ? db.get('SELECT * FROM operators WHERE user_id = ? AND world_id = ?', userId, o.world_id) : null; + if (!o || !op) throw new GameError('not_found', { what: 'offer' }); + if (o.status !== 'open' && o.operator_id !== op.id && o.accepted_by_operator !== op.id) throw new GameError('not_found', { what: 'offer' }); + return { serverTime: now, offer: Object.assign(T.offerView(db, o, townsOf([o.town_id])), { role: o.operator_id === op.id ? 'poster' : (o.accepted_by_operator === op.id ? 'acceptor' : 'viewer') }) }; + } + + return { offers, mineOffers, offer }; +} + +module.exports = { createTradeQueries }; diff --git a/test/client-i18n.test.js b/test/client-i18n.test.js index eec903a..51cd560 100644 --- a/test/client-i18n.test.js +++ b/test/client-i18n.test.js @@ -3,6 +3,10 @@ const test = require('node:test'); const assert = require('node:assert'); const I = require('../public/js/i18n.js'); const D = require('../public/js/data.js'); +// Strings added by later screens: public/js/strings/*.js, loaded for the parity test the same way the browser loads them. +for (const f of require('fs').readdirSync(require('path').join(__dirname, '..', 'public', 'js', 'strings')).sort()) { + if (f.endsWith('.js')) require('../public/js/strings/' + f); +} const placeholders = (s) => (s.match(/\{\w+\}/g) || []).sort().join(','); diff --git a/test/client-mil.test.js b/test/client-mil.test.js new file mode 100644 index 0000000..3a05108 --- /dev/null +++ b/test/client-mil.test.js @@ -0,0 +1,83 @@ +'use strict'; +const test = require('node:test'); +const assert = require('node:assert'); +const M = require('../public/js/milcore.js'); +const D = require('../public/js/data.js'); + +const land = (settle) => ({ x: 3, y: 4, type: 'land', settle: Object.assign({ possible: true, code: null, footprint: 100, footprintNeeded: 50, maxDistance: 15 }, settle) }); +const rival = (owner) => ({ x: 5, y: 5, type: 'pop', town: { id: 9, name: 'R', mine: false, owner: Object.assign({ id: 2, protected: false, allianceId: null }, owner) } }); +const types = (o) => o.map((x) => x.type + (x.ok ? '' : '!')); + +test('unitsForType: roles, fixed units and zero counts are filtered', () => { + const home = { script_crew: 5, honeypot: 3, port_scanner: 2, soc_analyst: 0, rollout_crew: 3 }; + assert.deepStrictEqual(M.unitsForType('raid', home).map((u) => u.unit), ['script_crew']); // honeypot is fixed, scanner is a scout + assert.deepStrictEqual(M.unitsForType('scan', home).map((u) => u.unit), ['port_scanner']); + assert.deepStrictEqual(M.unitsForType('settle', home).map((u) => u.unit), ['rollout_crew']); + assert.deepStrictEqual(M.unitsForType('reinforce', home).map((u) => u.unit), ['port_scanner', 'script_crew', 'rollout_crew']); + assert.deepStrictEqual(M.unitsForType('transport', home), []); +}); + +test('moveOptions on a rival POP: hostile types need units, protection blocks them, takeover needs an M&A team', () => { + const home = { script_crew: 10, port_scanner: 1 }; + assert.deepStrictEqual(types(M.moveOptions({ tile: rival(), home })), ['scan', 'raid', 'attack', 'takeover!']); + assert.strictEqual(M.moveOptions({ tile: rival(), home }).find((o) => o.type === 'takeover').reason, 'needs_ma_team'); + const prot = M.moveOptions({ tile: rival({ protected: true }), home }); + assert.deepStrictEqual(types(prot), ['scan', 'raid!', 'attack!', 'takeover!']); + assert.strictEqual(prot[1].reason, 'target_protected'); + assert.deepStrictEqual(types(M.moveOptions({ tile: rival(), home: {} })), ['scan!', 'raid!', 'attack!', 'takeover!']); + assert.ok(M.moveOptions({ tile: rival(), home: { ma_team: 1, script_crew: 1 } }).find((o) => o.type === 'takeover').ok); +}); + +test('moveOptions: reinforce only for the same alliance; own POP offers reinforce and transport', () => { + const home = { soc_analyst: 4 }; + const ally = rival({ allianceId: 7 }); + assert.ok(!M.moveOptions({ tile: ally, home, allianceId: 5 }).some((o) => o.type === 'reinforce')); + assert.ok(M.moveOptions({ tile: ally, home, allianceId: 7 }).some((o) => o.type === 'reinforce' && o.ok)); + const mine = { x: 1, y: 1, type: 'pop', town: { id: 3, mine: true, owner: { id: 1 } } }; + assert.deepStrictEqual(types(M.moveOptions({ tile: mine, home, transport: { links: 2, active: 2 } })), ['reinforce', 'transport!']); + assert.strictEqual(M.moveOptions({ tile: mine, home, transport: { links: 0, active: 0 } })[1].reason, 'no_link'); + assert.deepStrictEqual(types(M.moveOptions({ tile: mine, home, transport: { links: 2, active: 1 } })), ['reinforce', 'transport']); +}); + +test('moveOptions: incumbent sites take scan and attack; land offers settle with its reason; rural nothing', () => { + assert.deepStrictEqual(types(M.moveOptions({ tile: { type: 'incumbent' }, home: { port_scanner: 1, script_crew: 1 } })), ['scan', 'attack']); + assert.deepStrictEqual(types(M.moveOptions({ tile: land(), home: {}, crews: 3 })), ['settle']); + assert.deepStrictEqual(types(M.moveOptions({ tile: land(), home: {}, crews: 2 })), ['settle!']); + const far = M.moveOptions({ tile: land({ possible: false, code: 'out_of_range' }), home: {}, crews: 3 }); + assert.strictEqual(far[0].reason, 'settle:out_of_range'); + assert.deepStrictEqual(M.moveOptions({ tile: { type: 'rural' }, home: { script_crew: 1 } }), []); +}); + +test('defaultUnits / cleanSelection / preview', () => { + assert.deepStrictEqual(M.defaultUnits('settle', {}), { rollout_crew: D.EXPANSION.crews }); + assert.deepStrictEqual(M.defaultUnits('raid', {}), {}); + assert.deepStrictEqual(M.cleanSelection({ a: 0, script_crew: 99, botnet: 2.7 }, { script_crew: 5, botnet: 1 }), { script_crew: 5, botnet: 1 }); + const p = M.preview('raid', { x: 0, y: 0 }, { x: 16, y: 0 }, { script_crew: 10, botnet: 1 }, {}, 1); + assert.strictEqual(p.dist, 16); + assert.strictEqual(p.slowest, 8); // script crew 8 tiles/h + assert.strictEqual(p.ms, 2 * 3600 * 1000); + assert.strictEqual(p.carry, 10 * 50 + 150); + assert.strictEqual(M.preview('transport', { x: 0, y: 0 }, { x: 12, y: 0 }, {}, { fiber: 5 }, 2).ms, 30 * 60 * 1000); // 12 tiles at 12/h and speed 2x = 30 min +}); + +test('perspective: the report role decides who won', () => { + assert.strictEqual(M.perspective('attacker', 'attacker_won'), 'victory'); + assert.strictEqual(M.perspective('attacker', 'defender_won'), 'defeat'); + assert.strictEqual(M.perspective('defender', 'attacker_won'), 'defeat'); + assert.strictEqual(M.perspective('reinforcer', 'defender_won'), 'victory'); +}); + +test('backoffMs grows to a 60 s cap with +-25% jitter', () => { + assert.strictEqual(M.backoffMs(0, 0.5), 1000); + assert.strictEqual(M.backoffMs(1, 0.5), 2000); + assert.strictEqual(M.backoffMs(3, 0.5), 8000); + assert.strictEqual(M.backoffMs(20, 0.5), 60000); + assert.strictEqual(M.backoffMs(2, 0), 3000); + assert.ok(M.backoffMs(2, 0.999) >= 4990 && M.backoffMs(2, 0.999) <= 5000); +}); + +test('siegeTargets are infrastructure types only', () => { + const t = M.siegeTargets(); + assert.ok(t.includes('firewall') && t.includes('core_router')); + assert.ok(!t.includes('backbone_node') && !t.some((k) => D.BUILDINGS[k].kind !== 'infra')); +}); diff --git a/test/client-social.test.js b/test/client-social.test.js new file mode 100644 index 0000000..32d1138 --- /dev/null +++ b/test/client-social.test.js @@ -0,0 +1,161 @@ +'use strict'; +const test = require('node:test'); +const assert = require('node:assert'); +const fs = require('fs'); +const path = require('path'); +const I = require('../public/js/i18n.js'); +const D = require('../public/js/data.js'); +const Soc = require('../public/js/social.js'); +for (const f of fs.readdirSync(path.join(__dirname, '..', 'public', 'js', 'strings')).sort()) if (f.endsWith('.js')) require('../public/js/strings/' + f); + +const S = D.SOCIAL; + +test('selfActions follows the permission table and the leader-must-transfer rule', () => { + const leader = Soc.selfActions('leader', 4), officer = Soc.selfActions('officer', 4), diplomat = Soc.selfActions('diplomat', 4), member = Soc.selfActions('member', 4); + assert.ok(leader.invite && leader.disband && leader.diplomacy && leader.editNotes && leader.transfer && leader.setRole); + assert.ok(leader.leaveNeedsTransfer); + assert.ok(!Soc.selfActions('leader', 1).leaveNeedsTransfer, 'alone: leaving disbands, no transfer needed'); + assert.ok(officer.invite && officer.viewInvites && officer.editNotes && !officer.diplomacy && !officer.disband && !officer.setRole); + assert.ok(diplomat.diplomacy && diplomat.editNotes && !diplomat.invite); + assert.ok(member.broadcast && !member.invite && !member.editNotes && !member.diplomacy && member.leave && !member.leaveNeedsTransfer); + const none = Soc.selfActions(null, 0); + assert.ok(!none.leave && !none.invite && !none.broadcast); + // every key of SOCIAL.permissions the screens use is derived, not copied + for (const [k, roles] of Object.entries(S.permissions)) { + for (const r of S.roles) { + const a = Soc.selfActions(r, 3); + if (a[k] !== undefined) assert.strictEqual(a[k], roles.includes(r), k + ' for ' + r); + } + } +}); + +test('memberActions: kick needs permission and strictly higher rank, roles and transfer are leader-only, never on yourself', () => { + const m = (role, id) => ({ operatorId: id || 7, role }); + const lead = Soc.memberActions('leader', m('officer'), 1); + assert.ok(lead.kick && lead.transfer && lead.message); + assert.deepStrictEqual(lead.roles.sort(), ['diplomat', 'member']); + assert.deepStrictEqual(Soc.memberActions('leader', m('member'), 1).roles.sort(), ['diplomat', 'officer']); + const off = Soc.memberActions('officer', m('member'), 1); + assert.ok(off.kick && !off.transfer && off.roles.length === 0); + assert.ok(!Soc.memberActions('officer', m('officer'), 1).kick, 'equal rank'); + assert.ok(!Soc.memberActions('officer', m('leader'), 1).kick, 'higher rank'); + assert.ok(!Soc.memberActions('diplomat', m('member'), 1).kick, 'no kick permission'); + assert.ok(!Soc.memberActions('member', m('member'), 1).kick); + const self = Soc.memberActions('leader', m('leader', 1), 1); + assert.ok(self.self && !self.kick && !self.transfer && !self.message && self.roles.length === 0); + assert.strictEqual(Soc.memberActions('leader', m('leader', 9), 1).roles.length, 0, 'the leader role is only moved by transfer'); +}); + +test('diplomacyOptions mirrors SOCIAL.diplomacyMoves and locks pending pairs', () => { + const kinds = (from) => Object.fromEntries(Soc.diplomacyOptions(from, null).map((o) => [o.state, o.kind])); + assert.deepStrictEqual(kinds('neutral'), { war: 'immediate', nap: 'proposal', confed: 'proposal' }); + assert.deepStrictEqual(kinds('nap'), { war: 'delayed', neutral: 'delayed', confed: 'proposal' }); + assert.deepStrictEqual(kinds('confed'), { war: 'delayed', neutral: 'delayed', nap: 'delayed' }); + assert.deepStrictEqual(kinds('war'), { neutral: 'proposal', nap: 'proposal' }, 'war -> confed is not allowed'); + assert.deepStrictEqual(Soc.diplomacyOptions('nap', { to: 'neutral' }), []); +}); + +test('relationTo defaults to neutral and exposes pending changes', () => { + const rels = [{ other: { id: 5 }, state: 'nap', since: 10, pending: { to: 'neutral', effectiveAt: 99, byUs: true } }]; + assert.deepStrictEqual(Soc.relationTo(rels, 6), { state: 'neutral', since: null, pending: null }); + assert.strictEqual(Soc.relationTo(rels, 5).state, 'nap'); + assert.strictEqual(Soc.relationTo(rels, 5).pending.byUs, true); + assert.strictEqual(Soc.pendingRemaining({ effectiveAt: 1000 }, 400), 600); + assert.strictEqual(Soc.pendingRemaining({ effectiveAt: 1000 }, 5000), 0); + assert.strictEqual(Soc.pendingRemaining(null, 5), 0); +}); + +test('character counting matches the server: code points, CRLF as one', () => { + assert.strictEqual(Soc.charCount('abc'), 3); + assert.strictEqual(Soc.charCount('a\r\nb'), 3); + assert.strictEqual(Soc.charCount('\u{1F680}\u{1F680}'), 2, 'astral characters count once'); + assert.strictEqual(Soc.charCount(null), 0); + const ok = Soc.composeState('x'.repeat(S.messageMax)); + assert.ok(!ok.over && ok.left === 0 && !ok.empty); + assert.ok(Soc.composeState('x'.repeat(S.messageMax + 1)).over); + assert.ok(Soc.composeState(' \n ').empty); + assert.ok(Soc.composeState('').empty); + assert.strictEqual(Soc.composeState('abc', 10).left, 7); +}); + +test('retrySeconds is at least 1 and rounds up', () => { + assert.strictEqual(Soc.retrySeconds({ retryAfter: 12.2 }), 13); + assert.strictEqual(Soc.retrySeconds({ retryAfter: 0 }), 1); + assert.strictEqual(Soc.retrySeconds(null), 1); +}); + +test('message lists merge without duplicates, newest first; conversations read oldest first', () => { + const a = [{ id: 9 }, { id: 8 }], b = [{ id: 8 }, { id: 7 }, { id: 6 }]; + assert.deepStrictEqual(Soc.mergeMessages(a, b).map((m) => m.id), [9, 8, 7, 6]); + assert.deepStrictEqual(Soc.chronological([{ id: 3 }, { id: 1 }, { id: 2 }]).map((m) => m.id), [1, 2, 3]); + assert.deepStrictEqual(a.map((m) => m.id), [9, 8], 'inputs are not mutated'); +}); + +test('peerOf and unreadIds', () => { + const inMsg = { id: 1, direction: 'in', from: { operatorId: 2, name: 'b' }, to: { operatorId: 1, name: 'a' }, readAt: null }; + const outMsg = { id: 2, direction: 'out', from: { operatorId: 1, name: 'a' }, to: { operatorId: 2, name: 'b' }, readAt: null }; + const read = { id: 3, direction: 'in', readAt: 5 }; + assert.strictEqual(Soc.peerOf(inMsg).operatorId, 2); + assert.strictEqual(Soc.peerOf(outMsg).operatorId, 2); + assert.deepStrictEqual(Soc.unreadIds([inMsg, outMsg, read]), [1], 'own messages and read ones are not unread'); +}); + +test('ranking pages merge by rank and your row is recognised per kind', () => { + const p1 = [{ rank: 1 }, { rank: 2 }], p2 = [{ rank: 2 }, { rank: 3 }]; + assert.deepStrictEqual(Soc.mergeRanks(p1, p2).map((r) => r.rank), [1, 2, 3]); + assert.ok(Soc.isYou('operators', { operatorId: 4 }, { operatorId: 4, rank: 9 })); + assert.ok(!Soc.isYou('operators', { operatorId: 5 }, { operatorId: 4 })); + assert.ok(Soc.isYou('alliances', { allianceId: 2 }, { allianceId: 2 })); + assert.ok(Soc.isYou('battles', { operatorId: 4 }, { operatorId: 4 })); + assert.ok(!Soc.isYou('operators', { operatorId: 4 }, null)); + const r = { attackPoints: 30, defensePoints: 12 }; + assert.deepStrictEqual(['attack', 'defense', 'total'].map((by) => Soc.battlePoints(r, by)), [30, 12, 42]); +}); + +test('cleanName collapses whitespace; sinceMs handles never-online', () => { + assert.strictEqual(Soc.cleanName(' Bob the Builder '), 'Bob the Builder'); + assert.strictEqual(Soc.cleanName(null), ''); + assert.strictEqual(Soc.sinceMs(null, 100), null); + assert.strictEqual(Soc.sinceMs(40, 100), 60); + assert.strictEqual(Soc.sinceMs(400, 100), 0); +}); + +// ---- strings: every key the three screens use exists in both languages, every role/state/kind has a name +const dir = path.join(__dirname, '..', 'public', 'js', 'screens'); +const SRC = ['alliance.js', 'messages.js', 'rankings.js', 'social-ui.js'].map((f) => fs.readFileSync(path.join(dir, f), 'utf8')).join('\n'); + +test('every static i18n key used by the social screens exists in en and nb', () => { + const used = new Set(); + for (const m of SRC.matchAll(/\bApp\.t\('([a-zA-Z0-9_.]+)'/g)) if (!m[1].endsWith('.')) used.add(m[1]); + for (const m of SRC.matchAll(/\bt: '([a-zA-Z0-9_.]+)'/g)) used.add(m[1]); + assert.ok(used.size > 100, 'found the keys (' + used.size + ')'); + for (const l of I.LANGS) for (const k of used) assert.ok(I.strings[l][k], l + ' is missing ' + k); +}); + +test('dynamic i18n key families are complete', () => { + const need = []; + for (const r of S.roles) need.push('soc.role.' + r); + for (const s of S.diplomacyStates) need.push('soc.state.' + s); + for (const k of ['immediate', 'proposal', 'delayed']) need.push('soc.kind.' + k, 'soc.kind.' + k + '.hint'); + for (const k of ['applied', 'proposed', 'scheduled']) need.push('soc.dip.result.' + k); + for (const k of ['inbox', 'sent', 'alliance']) need.push('soc.msg.empty.' + k); + for (const k of ['attack', 'defense', 'total']) need.push('soc.rank.by.' + k); + for (const k of ['inbox', 'sent', 'alliance', 'blocked']) need.push('soc.msg.tab.' + k); + for (const k of ['operators', 'alliances', 'battles']) need.push('soc.rank.tab.' + k); + for (const k of ['overview', 'members', 'diplomacy']) need.push('soc.tab.' + k); + for (const l of I.LANGS) for (const k of need) assert.ok(I.strings[l][k], l + ' is missing ' + k); +}); + +test('every error code the social routes can return is translated', () => { + const errors = require('../server/errors'); + const social = ['peering_office_required', 'already_in_alliance', 'not_in_alliance', 'alliance_name_taken', 'alliance_tag_taken', 'alliance_full', 'invite_expired', + 'leader_must_transfer', 'notes_full', 'diplomacy_invalid', 'diplomacy_pending', 'proposal_exists', 'proposal_expired', 'forbidden', 'not_found', 'conflict', 'rate_limited', 'validation_failed']; + for (const l of I.LANGS) for (const c of social) assert.ok(I.strings[l]['err.' + c], l + ' err.' + c); + const defined = Object.keys(errors.CODES || errors.codes || {}); + if (defined.length) for (const c of defined.filter((x) => social.includes(x))) assert.ok(I.strings.en['err.' + c]); +}); + +test('screens never put player-controlled text through innerHTML', () => { + const code = SRC.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, ''); + assert.ok(!/innerHTML|insertAdjacentHTML|outerHTML|document\.write/.test(code), 'no HTML injection sinks in the social screens'); +}); diff --git a/test/client-ws.test.js b/test/client-ws.test.js new file mode 100644 index 0000000..66e32c2 --- /dev/null +++ b/test/client-ws.test.js @@ -0,0 +1,137 @@ +'use strict'; +const test = require('node:test'); +const assert = require('node:assert'); +const { createSocketClient } = require('../public/js/ws.js'); + +// A fake WebSocket and a manual clock: no real timers, no network. +function rig(over) { + const socks = []; + class FakeWS { + constructor(url) { this.url = url; this.sent = []; this.closed = false; socks.push(this); } + send(s) { this.sent.push(JSON.parse(s)); } + close() { this.closed = true; } + // test helpers + open() { this.onopen(); } + recv(o) { this.onmessage({ data: JSON.stringify(o) }); } + drop() { this.onclose(); } + } + const timers = []; let t = 0, seq = 0; + const setTimeout_ = (fn, ms) => { const id = ++seq; timers.push({ id, at: t + ms, fn }); return id; }; + const clearTimeout_ = (id) => { const i = timers.findIndex((x) => x.id === id); if (i >= 0) timers.splice(i, 1); }; + const advance = (ms) => { + const end = t + ms; + for (;;) { + timers.sort((a, b) => a.at - b.at); + if (!timers.length || timers[0].at > end) break; + const x = timers.shift(); t = x.at; x.fn(); + } + t = end; + }; + const got = [], states = []; + const client = createSocketClient(Object.assign({ + WebSocket: FakeWS, url: () => 'ws://x/ws', token: () => 'tok', random: () => 0.5, + setTimeout: setTimeout_, clearTimeout: clearTimeout_, onMessage: (m) => got.push(m), onState: (s) => states.push(s), + }, over || {})); + return { client, socks, advance, got, states }; +} + +test('auth is the first message, ready opens the client, hints are passed on', () => { + const r = rig(); + r.client.start(); + assert.strictEqual(r.socks.length, 1); + r.socks[0].open(); + assert.deepStrictEqual(r.socks[0].sent, [{ type: 'auth', token: 'tok' }]); + assert.strictEqual(r.client.open, false); + r.socks[0].recv({ type: 'ready', serverTime: 5 }); + assert.strictEqual(r.client.open, true); + r.socks[0].recv({ type: 'town', townId: 3 }); + r.socks[0].recv({ type: 'pong' }); // pong is plumbing, not a hint + r.socks[0].onmessage({ data: 'not json' }); // garbage is ignored + assert.deepStrictEqual(r.got, [{ type: 'town', townId: 3 }]); + assert.ok(!JSON.stringify(r.socks[0].url).includes('tok'), 'the token never goes into the URL'); +}); + +test('pings every 25 s; a missing pong drops the socket and reconnects with backoff', () => { + const r = rig(); + r.client.start(); r.socks[0].open(); r.socks[0].recv({ type: 'ready' }); + r.advance(25000); + assert.deepStrictEqual(r.socks[0].sent.slice(-1), [{ type: 'ping' }]); + r.socks[0].recv({ type: 'pong' }); + r.advance(25000); + assert.strictEqual(r.socks[0].sent.filter((m) => m.type === 'ping').length, 2); + r.advance(8000); // no pong for the second ping + assert.strictEqual(r.socks[0].closed, true); + assert.strictEqual(r.client.open, false); + assert.strictEqual(r.socks.length, 1); + r.advance(1000); // backoff for attempt 0 = 1 s at jitter 0.5 + assert.strictEqual(r.socks.length, 2); +}); + +test('reconnect backoff grows while the server is down and resets after ready', () => { + const r = rig(); + r.client.start(); + r.socks[0].drop(); // never got ready + r.advance(999); assert.strictEqual(r.socks.length, 1); + r.advance(1); assert.strictEqual(r.socks.length, 2); + r.socks[1].drop(); + r.advance(1999); assert.strictEqual(r.socks.length, 2); + r.advance(1); assert.strictEqual(r.socks.length, 3); + r.socks[2].open(); r.socks[2].recv({ type: 'ready' }); + assert.strictEqual(r.client.attempts, 0); + r.socks[2].drop(); + r.advance(1000); assert.strictEqual(r.socks.length, 4); +}); + +test('stop() closes for good; kick() connects now; no token means no socket', () => { + const r = rig(); + r.client.start(); r.socks[0].open(); r.socks[0].recv({ type: 'ready' }); + r.client.stop(); + assert.strictEqual(r.socks[0].closed, true); + r.advance(120000); assert.strictEqual(r.socks.length, 1); + assert.strictEqual(r.client.state, 'idle'); + + const r2 = rig(); + r2.client.start(); r2.socks[0].drop(); + r2.client.kick(); + assert.strictEqual(r2.socks.length, 2); + + const r3 = rig({ token: () => null }); + r3.client.start(); + assert.strictEqual(r3.socks.length, 0); +}); + +test('a throwing WebSocket constructor degrades silently and retries', () => { + let n = 0; + const r = rig({ WebSocket: class { constructor() { n++; throw new Error('blocked'); } } }); + r.client.start(); + assert.strictEqual(n, 1); + r.advance(1000); + assert.strictEqual(n, 2); +}); + +test('close codes: 4401/4400/1009 stop for good, 4429 waits 30 s, others reconnect', () => { + const fatal = []; + const r = rig({ onFatal: (c) => fatal.push(c) }); + r.client.start(); r.socks[0].open(); r.socks[0].recv({ type: 'ready' }); + r.socks[0].onclose({ code: 4401 }); + r.advance(300000); + assert.strictEqual(r.socks.length, 1, 'no reconnect after 4401'); + assert.deepStrictEqual(fatal, [4401]); + assert.strictEqual(r.client.state, 'idle'); + r.client.start(); // a fresh session starts again + assert.strictEqual(r.socks.length, 2); + r.socks[1].onclose({ code: 4429 }); + r.advance(29000); assert.strictEqual(r.socks.length, 2); + r.advance(2000); assert.strictEqual(r.socks.length, 3); + r.socks[2].onclose({ code: 1006 }); + r.advance(3000); assert.strictEqual(r.socks.length, 4); +}); + +test('onReady tells a re-connect from the first connect', () => { + const seen = []; + const r = rig({ onReady: (m, again) => seen.push(again) }); + r.client.start(); r.socks[0].open(); r.socks[0].recv({ type: 'ready' }); + r.socks[0].onclose({ code: 1006 }); + r.advance(1000); r.socks[1].open(); r.socks[1].recv({ type: 'ready' }); + assert.deepStrictEqual(seen, [false, true]); +}); diff --git a/test/endgame-flow.test.js b/test/endgame-flow.test.js new file mode 100644 index 0000000..e12f8b0 --- /dev/null +++ b/test/endgame-flow.test.js @@ -0,0 +1,501 @@ +'use strict'; +/* End game on the server: sites open at day 100, taking them, shipping, building the node, winning, the end of the world. + * Fake clock, in-memory db; the world is moved to day 100 by advancing the clock (nothing else is pending in these worlds). */ +const test = require('node:test'); +const assert = require('node:assert'); +const T = require('./military-helpers'); +const A = require('../server/alliances'); +const E = require('../server/endgame'); +const { createEndgameQueries } = require('../server/endgameQueries'); +const { R, D, H } = T; +const DAY = 24 * H; + +function alliance(h, name, leader, members) { + const id = Number(h.db.run('INSERT INTO alliances (world_id, name, tag, size_cap, created_by, created_at) VALUES (?, ?, ?, 10, ?, ?)', h.worldId, name, name.slice(0, 3).toUpperCase(), leader.opId, h.clock.now()).lastInsertRowid); + A.addMember(h.db, id, leader.opId, 'leader', h.clock.now()); + for (const m of members || []) A.addMember(h.db, id, m.opId, 'member', h.clock.now()); + return id; +} +const err = (fn) => { try { fn(); } catch (e) { return e; } assert.fail('expected an error'); }; + +// A world at day `day`, with the sites at fixed positions; operators are created AFTER the clock moved so their POPs are fresh. +function world(day, o) { + const h = T.setup(Object.assign({ seed: 4242, radius: 50 }, o)); + h.advanceTo(h.world.start_at + Math.round(day * DAY / (h.world.speed || 1))); + h.eg = createEndgameQueries(h); + h.sites = R.backboneSites(h.world.seed, h.world.map_radius); + return h; +} +// An operator next to site `i` with plenty of power so that its units stay online; no production unless asked. +function near(h, name, i, o) { + const s = h.sites[i]; + const op = T.addOperator(h, name, Object.assign({ x: s.x - 4, y: s.y, power: 25 }, o || {})); + if (!(o && o.produce)) h.db.run("UPDATE buildings SET level = 0 WHERE town_id = ? AND key LIKE 'f%' AND key NOT IN ('f13','f14','f15','f16')", op.townId); + return op; +} +const siteOf = (h, i) => h.db.get('SELECT * FROM landing_sites WHERE world_id = ? AND idx = ?', h.worldId, i); +const attack = (h, who, i, units, type) => h.run('sendMovement', { userId: who.userId, fromTownId: who.townId, type: type || 'attack', x: h.sites[i].x, y: h.sites[i].y, units }); +const defenceNow = (h, i, level) => R.backboneDefence(h.world.seed, h.sites[i].x, h.sites[i].y, R.worldAgeDays(h.world.start_at, h.clock.now(), h.world.speed), level || 0); + +test('before day 100: the sites are plain land - cannot be attacked, settled or seen; status says running', () => { + const h = world(99.9); + const a = near(h, 'alice', 0, { units: { script_crew: 50 } }); + alliance(h, 'Alpha', a); + const s0 = h.sites[0]; + assert.equal(err(() => attack(h, a, 0, { script_crew: 10 })).code, 'backbone_closed'); + assert.equal(err(() => attack(h, a, 0, { script_crew: 10 }, 'raid')).code, 'backbone_closed'); + // settling the tile is refused although it looks like land: (the crews would otherwise found a POP on the future site) + T.giveUnits(h, a.townId, { rollout_crew: 3 }); + h.db.run('UPDATE towns SET footprint = 1e9 WHERE id = ?', a.townId); + const e = err(() => h.run('sendMovement', { userId: a.userId, fromTownId: a.townId, type: 'settle', x: s0.x, y: s0.y, units: { rollout_crew: 3 } })); + assert.equal(e.code, 'invalid_target'); + assert.equal(e.details.reason, 'backbone_site'); + const st = h.eg.status(a.userId, h.worldId); + assert.equal(st.phase, 'running'); + assert.deepEqual(st.sites, []); + assert.equal(st.winner, null); + assert.equal(st.ageDays < 100, true); + assert.equal(h.mq.tileInfo(a.userId, { x: s0.x, y: s0.y }).type, 'land'); + assert.equal(h.queries.map(a.userId, { x: s0.x, y: s0.y, r: 2 }).specials.some((s) => s.type === 'backbone'), false); + h.advanceTo(h.world.start_at + 100 * DAY); + assert.equal(h.eg.status(a.userId, h.worldId).phase, 'backbone_open'); +}); + +test('day 100: 7 sites appear (status, map, tile), held by the incumbent; a scan reports the heavy defence', () => { + const h = world(100); + const a = near(h, 'alice', 0, { units: { port_scanner: 100 } }); + const st = h.eg.status(a.userId, h.worldId); + assert.equal(st.phase, 'backbone_open'); + assert.equal(st.sites.length, 7); + assert.ok(st.sites.every((s) => s.holder === null && s.level === 0 && s.id === null && s.next.toLevel === 1)); + assert.deepEqual(st.sites.map((s) => [s.x, s.y]), h.sites.map((s) => [s.x, s.y])); + assert.equal(st.opensAt, h.world.start_at + 100 * DAY); + const m = h.queries.map(a.userId, { x: h.sites[0].x, y: h.sites[0].y, r: 3 }); + const sp = m.specials.find((s) => s.type === 'backbone'); + assert.ok(sp && sp.x === h.sites[0].x && sp.site.index === 0 && sp.site.holder === null && sp.site.level === 0); + const ti = h.mq.tileInfo(a.userId, { x: h.sites[0].x, y: h.sites[0].y }); + assert.equal(ti.type, 'backbone'); + assert.equal(ti.backbone.holder, null); + assert.equal(ti.backbone.canAttack, false, 'no alliance, no attack'); + assert.equal(ti.settle.possible, false); + // scan (no alliance needed) + const mv = attack(h, a, 0, { port_scanner: 100 }, 'scan'); + h.advanceTo(mv.arriveAt); + const rep = T.reportsOf(h, a.userId).find((r) => r.type === 'scan'); + assert.equal(rep.data.site.type, 'backbone'); + assert.equal(rep.data.success, true); + assert.equal(rep.data.intel.defence, defenceNow(h, 0, 0), 'the scan shows the exact static defence'); + assert.ok(rep.data.intel.defence > 10 * R.incumbentDefence(h.world.seed, h.sites[0].x, h.sites[0].y, 100)); + assert.equal(h.db.get('SELECT COUNT(*) AS n FROM landing_sites').n, 7, 'the first touch created the rows'); + assert.equal(T.notes(h, a.userId, 'backbone_open').length, 1, 'and told the world once'); +}); + +test('taking a site: alliance members only, heavy defence, the winner holds it; losing attackers change nothing; friends and pacts are refused', () => { + const h = world(100); + const a = near(h, 'alice', 0, { units: { script_crew: 1200 } }); + const a2 = near(h, 'alice2', 0, { x: h.sites[0].x - 4, y: h.sites[0].y + 3 }); + const b = near(h, 'bob', 0, { x: h.sites[0].x + 4, y: h.sites[0].y, units: { script_crew: 300 } }); + const loner = near(h, 'loner', 0, { x: h.sites[0].x, y: h.sites[0].y - 5, units: { script_crew: 1200 } }); + const A1 = alliance(h, 'Alpha', a, [a2]), B1 = alliance(h, 'Bravo', b); + + // an operator without an alliance cannot take a site + assert.equal(err(() => attack(h, loner, 0, { script_crew: 1200 })).details.reason, 'no_alliance'); + T.giveUnits(h, a.townId, { ma_team: 1 }); + assert.equal(err(() => attack(h, a, 0, { script_crew: 10, ma_team: 1 }, 'takeover')).details.reason, 'landing_scan_or_attack_only'); + assert.equal(err(() => attack(h, a, 0, { script_crew: 10 }, 'reinforce')).code, 'invalid_target'); + + // too weak: bob's 300 crews (12 000) against ~40 000: lost, nothing changes + const weak = attack(h, b, 0, { script_crew: 300 }); + h.advanceTo(weak.arriveAt); + assert.equal(siteOf(h, 0).holder_alliance_id, null); + const lost = T.reportsOf(h, b.userId).find((r) => r.type === 'landing'); + assert.equal(lost.data.outcome, 'defender_won'); + assert.equal(lost.data.taken, false); + assert.equal(T.units(h, b.townId).script_crew, undefined, 'all lost'); + + // alice takes it + const power = 1200 * 40; + assert.ok(power > defenceNow(h, 0, 0) * 1.05); + const mv = attack(h, a, 0, { script_crew: 1200 }); + h.advanceTo(mv.arriveAt); + const site = siteOf(h, 0); + assert.equal(site.holder_alliance_id, A1); + assert.equal(site.holder_operator_id, a.opId); + assert.equal(site.taken_at, mv.arriveAt); + assert.equal(site.level, 0); + const rep = T.reportsOf(h, a.userId).find((r) => r.type === 'landing'); + assert.equal(rep.data.outcome, 'attacker_won'); + assert.equal(rep.data.taken, true); + assert.equal(rep.data.site.holder, null, 'the report says who held it BEFORE'); + assert.equal(T.notes(h, a2.userId, 'backbone_taken').length, 1, 'every member of the new holder hears it'); + const surv = h.db.get("SELECT units FROM movements WHERE type = 'return' AND owner_id = ?", a.opId); + assert.ok(JSON.parse(surv.units).script_crew > 0 && JSON.parse(surv.units).script_crew < 1200, 'survivors drive home, with losses'); + // status and tile now show the holder + const st = h.eg.status(a2.userId, h.worldId); + assert.equal(st.sites[0].holder.allianceId, A1); + assert.equal(st.sites[0].holder.tag, 'ALP'); + assert.equal(st.sites[0].takenBy.operatorId, a.opId); + assert.equal(h.mq.tileInfo(a2.userId, { x: h.sites[0].x, y: h.sites[0].y }).backbone.mine, true); + assert.equal(h.mq.tileInfo(b.userId, { x: h.sites[0].x, y: h.sites[0].y }).backbone.canAttack, true); + + // the holder's own members cannot attack it; a NAP partner cannot either + T.giveUnits(h, a2.townId, { script_crew: 10 }); + assert.equal(err(() => attack(h, a2, 0, { script_crew: 10 })).details.reason, 'own_site'); + A.setRelation(h.db, h.worldId, A1, B1, 'nap', h.clock.now()); + T.giveUnits(h, b.townId, { script_crew: 10 }); + assert.equal(err(() => attack(h, b, 0, { script_crew: 10 })).details.reason, 'pact'); + A.setRelation(h.db, h.worldId, A1, B1, 'war', h.clock.now()); +}); + +test('re-checked at arrival: a pact signed while the attack is on the road bounces it', () => { + const h = world(100); + const a = near(h, 'alice', 1, { units: { script_crew: 1200 } }); + const b = near(h, 'bob', 1, { x: h.sites[1].x + 4, y: h.sites[1].y }); + const A1 = alliance(h, 'Alpha', a), B1 = alliance(h, 'Bravo', b); + // bob's alliance holds the site + E.ensureSites(h.db, h.world, h.clock.now()); + h.db.run('UPDATE landing_sites SET holder_alliance_id = ?, holder_operator_id = ? WHERE idx = 1', B1, b.opId); + const mv = attack(h, a, 1, { script_crew: 1200 }); + A.setRelation(h.db, h.worldId, A1, B1, 'nap', h.clock.now()); + h.advanceTo(mv.arriveAt); + assert.equal(siteOf(h, 1).holder_alliance_id, B1, 'not taken'); + const rep = T.reportsOf(h, a.userId).find((r) => r.type === 'movement_failed'); + assert.equal(rep.data.reason, 'pact'); + assert.equal(h.db.get("SELECT COUNT(*) AS n FROM movements WHERE type = 'return' AND owner_id = ?", a.opId).n, 1, 'the units come home'); +}); + +test('shipping: members feed the stockpile by transport; strangers cannot; a shipment that arrives after the site changed hands rides home', () => { + const h = world(100); + const a = near(h, 'alice', 2); + const a2 = near(h, 'alice2', 2, { x: h.sites[2].x - 14, y: h.sites[2].y }); + const b = near(h, 'bob', 2, { x: h.sites[2].x + 4, y: h.sites[2].y, units: { script_crew: 1300 } }); + const A1 = alliance(h, 'Alpha', a, [a2]), B1 = alliance(h, 'Bravo', b); + E.ensureSites(h.db, h.world, h.clock.now()); + h.db.run('UPDATE landing_sites SET holder_alliance_id = ?, holder_operator_id = ? WHERE idx = 2', A1, a.opId); + const site = siteOf(h, 2); + const stock = (id) => { const t = T.town(h, id); return t.fiber + t.hardware + t.capital; }; + + assert.equal(err(() => h.run('backboneShip', { userId: b.userId, siteId: site.id, fromTownId: b.townId, cargo: { fiber: 100 } })).code, 'forbidden'); + assert.equal(err(() => h.run('backboneShip', { userId: a2.userId, siteId: site.id, fromTownId: a.townId, cargo: { fiber: 100 } })).code, 'not_found', "not your POP"); + assert.equal(err(() => h.run('backboneShip', { userId: a2.userId, siteId: site.id, fromTownId: a2.townId, cargo: { fiber: 501 } })).code, 'capacity_exceeded'); + assert.equal(err(() => h.run('backboneShip', { userId: a2.userId, siteId: 9999, fromTownId: a2.townId, cargo: { fiber: 5 } })).code, 'not_found'); + + const before = stock(a2.townId); + const s1 = h.run('backboneShip', { userId: a2.userId, siteId: site.id, fromTownId: a2.townId, cargo: { fiber: 300, hardware: 200 } }); + assert.equal(stock(a2.townId), before - 500, 'it left the POP'); + assert.equal(s1.arriveAt - s1.departAt, R.transportMs(R.distance(a2.x, a2.y, site.x, site.y), 1)); + h.advanceTo(s1.arriveAt); + let row = siteOf(h, 2); + assert.deepEqual([row.fiber, row.hardware, row.capital], [300, 200, 0]); + assert.deepEqual(h.db.get('SELECT fiber, hardware, capital FROM landing_contributions WHERE site_id = ? AND operator_id = ?', site.id, a2.opId), { fiber: 300, hardware: 200, capital: 0 }); + assert.equal(T.notes(h, a2.userId, 'backbone_delivered').length, 1); + assert.equal(stock(a2.townId), before - 500, 'nothing came back: it was delivered'); + + // second shipment is still on the road when bob takes the site + const s2 = h.run('backboneShip', { userId: a2.userId, siteId: site.id, fromTownId: a2.townId, cargo: { capital: 400 } }); + const mid = stock(a2.townId); + const atk = attack(h, b, 2, { script_crew: 1300 }); + assert.ok(atk.arriveAt < s2.arriveAt, 'the attack gets there first (a2 lives further away)'); + h.advanceTo(s2.arriveAt); + assert.equal(siteOf(h, 2).holder_alliance_id, B1, 'bob took it first'); + row = siteOf(h, 2); + assert.deepEqual([row.fiber, row.hardware, row.capital], [300, 200, 0], 'the late shipment was not added to the new holder\'s stockpile, the old stock stayed with the site'); + assert.equal(T.notes(h, a2.userId, 'backbone_ship_bounced').length, 1); + assert.equal(stock(a2.townId), mid, 'still on its way home'); + h.advance(10 * H); + assert.equal(stock(a2.townId), mid + 400, 'back home: nothing lost'); +}); + +test('building the node: from the stockpile, one level at a time, holders only; the level and the build stay with the site when it is taken', () => { + const h = world(100); + const a = near(h, 'alice', 3); + const a2 = near(h, 'alice2', 3, { x: h.sites[3].x - 4, y: h.sites[3].y + 3 }); + const b = near(h, 'bob', 3, { x: h.sites[3].x + 4, y: h.sites[3].y, units: { script_crew: 1300 } }); + const A1 = alliance(h, 'Alpha', a, [a2]), B1 = alliance(h, 'Bravo', b); + E.ensureSites(h.db, h.world, h.clock.now()); + h.db.run('UPDATE landing_sites SET holder_alliance_id = ?, holder_operator_id = ? WHERE idx = 3', A1, a.opId); + const site = siteOf(h, 3); + const build = (who) => h.run('backboneBuild', { userId: who.userId, siteId: site.id }); + + assert.equal(err(() => build(a)).code, 'not_enough_resources'); + assert.equal(err(() => build(b)).code, 'forbidden', 'not a holder'); + h.db.run('UPDATE landing_sites SET fiber = 5000, hardware = 4200, capital = 4000 WHERE id = ?', site.id); + const t0 = h.clock.now(); + const q = build(a2); + assert.equal(q.toLevel, 1); + assert.deepEqual(q.cost, R.backboneCost(1)); + assert.equal(q.dueAt, t0 + R.backboneTimeMs(1, 1)); + let row = siteOf(h, 3); + assert.deepEqual([row.fiber, row.hardware, row.capital], [1000, 200, 0], 'paid from the stockpile at once'); + assert.equal(row.build_to, 1); + assert.equal(err(() => build(a)).code, 'already_queued'); + const view = h.eg.site(a.userId, site.id); + assert.equal(view.site.build.toLevel, 1); + assert.equal(view.you.canBuild, true); + assert.equal(h.eg.site(b.userId, site.id).contributions, undefined, 'the ledger is for holders'); + + // bob takes the site while level 1 is being built: the level lands on the site for its NEW holder + h.advanceTo(q.dueAt - H); + const atk = attack(h, b, 3, { script_crew: 1300 }); + h.advanceTo(atk.arriveAt); + assert.equal(siteOf(h, 3).holder_alliance_id, B1); + assert.equal(siteOf(h, 3).build_to, 1, 'the build runs on'); + h.advanceTo(q.dueAt); + row = siteOf(h, 3); + assert.equal(row.level, 1); + assert.equal(row.build_to, null); + assert.equal(row.holder_alliance_id, B1); + assert.equal(err(() => build(a2)).code, 'forbidden', 'alice is a stranger now'); + // the node raises the site's defence (level stays with the site) + assert.ok(defenceNow(h, 3, 1) > defenceNow(h, 3, 0)); + assert.equal(h.eg.status(a.userId, h.worldId).sites[3].level, 1); + + // the new holder pays the next level from what is left in the stockpile + h.db.run('UPDATE landing_sites SET fiber = 9000, hardware = 9000, capital = 9000 WHERE id = ?', site.id); + const q2 = build(b); + assert.equal(q2.toLevel, 2); + assert.deepEqual(q2.cost, R.backboneCost(2)); + h.advanceTo(q2.dueAt); + assert.equal(siteOf(h, 3).level, 2); + assert.equal(T.notes(h, b.userId, 'backbone_level').length, 0, 'only every 10th level is announced'); + assert.equal(h.db.all("SELECT 1 FROM events WHERE status = 'failed'").length, 0); +}); + +test('winning: level 100 makes the holder the winner, the world ends two world days later with a ranking, then it is frozen but readable', () => { + const h = world(100, { speed: 2 }); + const a = near(h, 'alice', 4, { produce: true }); + const a2 = near(h, 'alice2', 4, { x: h.sites[4].x - 4, y: h.sites[4].y + 3 }); + const b = near(h, 'bob', 4, { x: h.sites[4].x + 4, y: h.sites[4].y, units: { script_crew: 20 } }); + const A1 = alliance(h, 'Alpha', a, [a2]), B1 = alliance(h, 'Bravo', b); + T.giveUnits(h, a.townId, { script_crew: 40 }); + h.db.run('INSERT INTO operator_stats (operator_id, attack_points, defense_points) VALUES (?, 12.5, 3), (?, 40, 1)', a.opId, b.opId); + E.ensureSites(h.db, h.world, h.clock.now()); + h.db.run('UPDATE landing_sites SET holder_alliance_id = ?, holder_operator_id = ?, level = 99, fiber = 1e7, hardware = 1e7, capital = 1e7 WHERE idx = 4', A1, a.opId); + const site = siteOf(h, 4); + const q = h.run('backboneBuild', { userId: a.userId, siteId: site.id }); + assert.equal(q.toLevel, 100); + assert.equal(h.eg.status(a.userId, h.worldId).winner, null); + const wonAt = q.dueAt; + h.advanceTo(wonAt); + const w = h.db.get('SELECT * FROM worlds WHERE id = ?', h.worldId); + assert.equal(w.winner_alliance_id, A1); + assert.equal(w.winner_name, 'Alpha'); + assert.equal(w.won_at, wonAt); + assert.equal(w.status, 'running', 'the world goes on for two days'); + assert.equal(w.end_at, wonAt + DAY, 'two WORLD days at speed 2 = one real day'); + assert.equal(T.notes(h, b.userId, 'backbone_won').length, 1, 'everybody hears who won'); + assert.equal(T.notes(h, a2.userId, 'backbone_level').length, 1); + const st = h.eg.status(b.userId, h.worldId); + assert.equal(st.winner.allianceId, A1); assert.equal(st.winner.tag, 'ALP'); + assert.equal(st.endsAt, wonAt + DAY); assert.equal(st.endedAt, null); + assert.equal(st.phase, 'backbone_open'); + assert.equal(h.eg.results(b.userId, h.worldId).available, false); + assert.equal(h.db.get("SELECT COUNT(*) AS n FROM events WHERE type = 'worldEnd' AND status = 'pending'").n, 1); + + // still playable during the grace period; the winner is fixed even if the site is lost + h.run('renameTown', { userId: a.userId, townId: a.townId, name: 'Still Playing' }); + assert.equal(err(() => h.run('backboneBuild', { userId: a.userId, siteId: site.id })).code, 'max_level'); + h.run('build', { userId: a.userId, townId: a.townId, key: 'firewall' }); // something in the queue that the end will cancel + const offer = h.run('tradeOffer', { userId: a.userId, townId: a.townId, giveRes: 'capital', giveAmount: 100, wantRes: 'fiber', wantAmount: 100, maxDistance: 30 }).offer; // open at the end + h.advanceTo(w.end_at - 1); + assert.equal(h.db.get('SELECT status FROM worlds WHERE id = ?', h.worldId).status, 'running'); + h.advanceTo(w.end_at); + const ended = h.db.get('SELECT * FROM worlds WHERE id = ?', h.worldId); + assert.equal(ended.status, 'ended'); + assert.equal(ended.end_at, w.end_at); + assert.equal(h.db.get("SELECT COUNT(*) AS n FROM events WHERE world_id = ? AND status = 'pending'", h.worldId).n, 0, 'the world is frozen: nothing pending'); + assert.equal(T.notes(h, a.userId, 'world_ended').length, 1); + assert.equal(h.db.get('SELECT status FROM trade_offers WHERE id = ?', offer.id).status, 'expired', 'open offers end with the world: the escrow is back in its POP'); + assert.equal(h.db.get("SELECT COUNT(*) AS n FROM trade_offers WHERE status = 'open'").n, 0); + + // the snapshot + const res = h.eg.results(b.userId, h.worldId); + assert.equal(res.available, true); + assert.equal(res.status, 'ended'); + assert.equal(res.results.winner.name, 'Alpha'); + assert.equal(res.results.operators.length, 3); + assert.deepEqual(res.results.operators.map((o) => o.rank), [1, 2, 3]); + assert.ok(res.results.operators[0].footprint >= res.results.operators[1].footprint); + assert.equal(res.results.alliances.length, 2); + assert.equal(res.results.alliances[0].members + res.results.alliances[1].members, 3); + assert.deepEqual(res.results.attackers.map((o) => o.name), ['bob', 'alice']); + assert.deepEqual(res.results.defenders.map((o) => o.name), ['alice', 'bob']); + assert.equal(res.results.sites.find((s) => s.index === 4).level, 100); + const stored = JSON.parse(h.db.get('SELECT data FROM world_rankings WHERE world_id = ?', h.worldId).data); + assert.deepEqual(stored, res.results); + + // ended: every game command is refused with one stable code ... + const refused = (name, args) => assert.equal(err(() => h.run(name, args)).code, 'world_ended', name); + refused('build', { userId: a.userId, townId: a.townId, key: 'firewall' }); + refused('renameTown', { userId: a.userId, townId: a.townId, name: 'x' }); + refused('sendMovement', { userId: a.userId, fromTownId: a.townId, type: 'scan', x: b.x, y: b.y, units: { port_scanner: 1 } }); + refused('sendTransport', { userId: a.userId, fromTownId: a.townId, toTownId: a2.townId, cargo: { fiber: 1 } }); + refused('train', { userId: a.userId, townId: a.townId, unit: 'soc_analyst', count: 1 }); + refused('tradeOffer', { userId: a.userId, townId: a.townId, giveRes: 'fiber', giveAmount: 10, wantRes: 'capital', wantAmount: 10, maxDistance: 5 }); + refused('tradeAccept', { userId: a.userId, offerId: 1, townId: a.townId }); + refused('backboneBuild', { userId: a.userId, siteId: site.id }); + refused('backboneShip', { userId: a.userId, siteId: site.id, fromTownId: a.townId, cargo: { fiber: 1 } }); + refused('allianceCreate', { userId: a2.userId, worldId: h.worldId, name: 'New', tag: 'NW' }); + refused('allianceLeave', { userId: a2.userId, allianceId: A1 }); + refused('diploPropose', { userId: a.userId, allianceId: A1, targetId: B1, state: 'war' }); + refused('reportShare', { userId: a.userId, reportId: 1 }); + refused('recallMovement', { userId: a.userId, movementId: 1 }); + refused('joinWorld', { userId: a.userId, worldId: h.worldId }); + // ... except reading state and talking + h.run('markReportRead', { userId: a.userId, all: true }); + assert.equal(h.run('messageSend', { userId: a.userId, toOperatorId: b.opId, text: 'gg' }).recipients, 1); + // ... and everything stays readable + assert.equal(h.queries.map(a.userId, { x: 0, y: 0, r: 40 }).world.status, 'ended'); + assert.ok(h.queries.map(a.userId, { x: 0, y: 0, r: 40 }).specials.some((s) => s.type === 'backbone')); + assert.ok(h.mq.reports(a.userId, {}).items.length >= 0); + assert.ok(h.queries.town(a.userId, a.townId).town.id === a.townId); + assert.equal(h.eg.status(a.userId, h.worldId).phase, 'ended'); + assert.equal(h.eg.status(a.userId, h.worldId).endedAt, w.end_at); + assert.equal(h.eg.site(a.userId, site.id).site.level, 100); + // running it again changes nothing (idempotent) + const snap = JSON.stringify(h.db.get('SELECT * FROM world_rankings')); + require('../server/events/worldEnd')(Object.assign(h.ctx(), { now: w.end_at }), { id: 0, worldId: h.worldId, dueAt: w.end_at + 5, payload: {} }); + assert.equal(JSON.stringify(h.db.get('SELECT * FROM world_rankings')), snap); +}); + +test('winner is fixed at level 100: losing the node during the grace period does not change it; a disbanded holder leaves the site to the incumbent (level stays)', () => { + const h = world(100); + const a = near(h, 'alice', 5); + const b = near(h, 'bob', 5, { x: h.sites[5].x + 4, y: h.sites[5].y, units: { script_crew: 4700 } }); + const A1 = alliance(h, 'Alpha', a), B1 = alliance(h, 'Bravo', b); + E.ensureSites(h.db, h.world, h.clock.now()); + h.db.run('UPDATE landing_sites SET holder_alliance_id = ?, holder_operator_id = ?, level = 99, fiber = 1e7, hardware = 1e7, capital = 1e7 WHERE idx = 5', A1, a.opId); + const site = siteOf(h, 5); + const q = h.run('backboneBuild', { userId: a.userId, siteId: site.id }); + h.advanceTo(q.dueAt); + assert.equal(h.db.get('SELECT winner_alliance_id AS w FROM worlds').w, A1); + const atk = attack(h, b, 5, { script_crew: 4700 }); + h.advanceTo(atk.arriveAt); + assert.equal(siteOf(h, 5).holder_alliance_id, B1, 'bob took the finished node'); + assert.equal(h.db.get('SELECT winner_alliance_id AS w FROM worlds').w, A1, 'but alice\'s alliance already won'); + // the site keeps its level when its holder disbands + A.dissolve(Object.assign(h.ctx(), { scheduler: h.scheduler }), B1, 'test'); + assert.equal(siteOf(h, 5).holder_alliance_id, null); + assert.equal(siteOf(h, 5).level, 100); + assert.equal(h.eg.status(a.userId, h.worldId).sites[5].holder, null); +}); + +test('a finished node taken while nobody wins yet completes for the new holder; only one winner per world', () => { + const h = world(100); + const a = near(h, 'alice', 6, { units: { script_crew: 4700 } }); + const A1 = alliance(h, 'Alpha', a); + E.ensureSites(h.db, h.world, h.clock.now()); + h.db.run('UPDATE landing_sites SET level = 100 WHERE idx = 6'); // finished while its holder was disbanded: nobody won + assert.equal(h.db.get('SELECT winner_alliance_id AS w FROM worlds').w, null); + const atk = attack(h, a, 6, { script_crew: 4700 }); + h.advanceTo(atk.arriveAt); + assert.equal(h.db.get('SELECT winner_alliance_id AS w FROM worlds').w, A1); + assert.equal(h.db.get("SELECT COUNT(*) AS n FROM events WHERE type = 'worldEnd'").n, 1); + // a second node reaching 100 does not start a second ending + const ctx = h.ctx(); + E.ensureSites(h.db, h.world, h.clock.now()); + h.db.run('UPDATE landing_sites SET level = 100, holder_alliance_id = ? WHERE idx = 0', A1); + assert.equal(E.maybeWin(ctx, siteOf(h, 0), h.clock.now()), false); + assert.equal(h.db.get("SELECT COUNT(*) AS n FROM events WHERE type = 'worldEnd'").n, 1); +}); + +test('ended worlds over HTTP: reads work, writes say world_ended; status and results routes follow their schemas', async () => { + const { createTestServer } = require('./helpers'); + const t = await createTestServer({ contract: true }); + try { + const a = await t.signup('alice'); + const w = t.srv.db.get('SELECT * FROM worlds'); + let r = await t.api('/worlds/' + w.id + '/status', {}, a.token); + assert.equal(r.status, 200); + assert.equal(r.body.phase, 'running'); + assert.equal((await t.api('/worlds/999/status', {}, a.token)).status, 404); + assert.equal((await t.api('/worlds/' + w.id + '/status')).status, 401); + r = await t.api('/worlds/' + w.id + '/results', {}, a.token); + assert.equal(r.body.available, false); + // jump to the end + t.srv.db.run("UPDATE worlds SET winner_alliance_id = NULL, winner_name = 'Win', winner_tag = 'WIN', won_at = ?, end_at = ?, start_at = ? WHERE id = ?", t.clock.now(), t.clock.now() + 1000, t.clock.now() - 101 * DAY, w.id); + t.srv.scheduler.enqueue({ worldId: w.id, dueAt: t.clock.now() + 1000, type: 'worldEnd', payload: {} }); + t.clock.advance(1000); + r = await t.api('/worlds/' + w.id + '/status', {}, a.token); + assert.equal(r.body.phase, 'ended'); + assert.equal(r.body.winner.name, 'Win'); + assert.equal(r.body.sites.length, 7); + r = await t.api('/worlds/' + w.id + '/results', {}, a.token); + assert.equal(r.body.available, true); + assert.equal(r.body.results.operators[0].name, 'alice'); + const build = await t.api('/towns/' + a.townId + '/build', { method: 'POST', body: { key: 'firewall' } }, a.token); + assert.equal(build.status, 409); + assert.equal(build.body.error.code, 'world_ended'); + for (const p of ['/me', '/map?x=0&y=0&r=5', '/reports', '/rankings/operators', '/rankings/alliances', '/rankings/battles', '/towns/' + a.townId, '/movements', '/trade/offers', '/notifications', '/map/tile?x=0&y=0']) { + const g = await t.api(p, {}, a.token); + assert.equal(g.status, 200, p + ' -> ' + JSON.stringify(g.body).slice(0, 200)); + } + const post = await t.api('/trade/offers', { method: 'POST', body: { townId: a.townId, giveRes: 'fiber', giveAmount: 10, wantRes: 'capital', wantAmount: 10, maxDistance: 5 } }, a.token); + assert.equal(post.body.error.code, 'world_ended'); + } finally { await t.close(); } +}); + +test('backbone routes over HTTP: site detail, ship, build follow their schemas and permissions', async () => { + const { createTestServer } = require('./helpers'); + const t = await createTestServer({ contract: true }); + try { + const lead = await t.signupPeering('lead'), mem = await t.signupPeering('mem'), out = await t.signup('outsider'); + t.setBuilding(mem.townId, 'internet_exchange', 2); + const w = t.srv.db.get('SELECT * FROM worlds'); + assert.equal((await t.api('/backbone/1', {}, lead.token)).status, 404, 'no such site yet'); + t.srv.db.run('UPDATE worlds SET start_at = ? WHERE id = ?', t.clock.now() - 101 * DAY, w.id); + const mk = await t.api('/alliances', { method: 'POST', body: { name: 'Backers', tag: 'BKR' } }, lead.token); + const inv = await t.api('/alliances/' + mk.body.allianceId + '/invite', { method: 'POST', body: { operatorId: mem.operatorId } }, lead.token); + await t.api('/alliance-invites/' + inv.body.inviteId + '/accept', { method: 'POST' }, mem.token); + const world = require('../server/state').loadWorld(t.srv.db, w.id); + E.ensureSites(t.srv.db, world, t.clock.now()); + t.srv.db.run('UPDATE landing_sites SET holder_alliance_id = ?, holder_operator_id = ? WHERE idx = 0', mk.body.allianceId, lead.operatorId); + const site = t.srv.db.get('SELECT * FROM landing_sites WHERE idx = 0'); + + let r = await t.api('/worlds/' + w.id + '/status', {}, out.token); + assert.equal(r.body.phase, 'backbone_open'); + assert.equal(r.body.sites[0].holder.tag, 'BKR'); + r = await t.api('/backbone/' + site.id, {}, out.token); + assert.equal(r.status, 200); + assert.equal(r.body.you.holder, false); + assert.equal(r.body.contributions, undefined); + r = await t.api('/backbone/' + site.id, {}, mem.token); + assert.equal(r.body.you.canBuild, true); + assert.deepEqual(r.body.contributions, []); + + // strangers: 403 on ship and build + assert.equal((await t.api('/backbone/' + site.id + '/ship', { method: 'POST', body: { fromTownId: out.townId, cargo: { fiber: 5 } } }, out.token)).status, 403); + assert.equal((await t.api('/backbone/' + site.id + '/build', { method: 'POST' }, out.token)).status, 403); + assert.equal((await t.api('/backbone/' + site.id + '/build', { method: 'POST' }, mem.token)).body.error.code, 'not_enough_resources'); + + const ship = await t.api('/backbone/' + site.id + '/ship', { method: 'POST', body: { fromTownId: mem.townId, cargo: { fiber: 100, capital: 50 } } }, mem.token); + assert.equal(ship.status, 201); + assert.equal(ship.body.siteId, site.id); + assert.equal(ship.body.toTownId, null); + const mv = await t.api('/movements', {}, mem.token); + assert.equal(mv.body.outgoing[0].siteId, site.id, 'the movement list says it is a shipment to a site'); + t.clock.advance(ship.body.arriveAt - t.clock.now()); + t.srv.scheduler.runDue(); + r = await t.api('/backbone/' + site.id, {}, lead.token); + assert.deepEqual(r.body.site.pool, { fiber: 100, hardware: 0, capital: 50 }); + assert.deepEqual(r.body.contributions.map((c) => [c.name, c.fiber, c.capital]), [['mem', 100, 50]]); + + t.srv.db.run('UPDATE landing_sites SET fiber = 4000, hardware = 4000, capital = 4000 WHERE id = ?', site.id); + const b = await t.api('/backbone/' + site.id + '/build', { method: 'POST' }, lead.token); + assert.equal(b.status, 201); + assert.equal(b.body.toLevel, 1); + assert.equal((await t.api('/backbone/' + site.id + '/build', { method: 'POST' }, lead.token)).body.error.code, 'already_queued'); + t.clock.advance(b.body.dueAt - t.clock.now()); + t.srv.scheduler.runDue(); + r = await t.api('/worlds/' + w.id + '/status', {}, out.token); + assert.equal(r.body.sites[0].level, 1); + assert.equal(r.body.sites[0].build, null); + const map = await t.api('/map?x=' + site.x + '&y=' + site.y + '&r=2', {}, out.token); + const sp = map.body.specials.find((x) => x.type === 'backbone'); + assert.equal(sp.site.level, 1); + assert.equal(sp.site.holder.tag, 'BKR'); + const tile = await t.api('/map/tile?x=' + site.x + '&y=' + site.y, {}, lead.token); + assert.equal(tile.body.type, 'backbone'); + assert.equal(tile.body.backbone.mine, true); + } finally { await t.close(); } +}); diff --git a/test/endgame-gaps.test.js b/test/endgame-gaps.test.js new file mode 100644 index 0000000..fcafdcb --- /dev/null +++ b/test/endgame-gaps.test.js @@ -0,0 +1,177 @@ +'use strict'; +/* Gaps closed next to the end game: buildDone after exploit-kit damage, confederation sees incoming, shared reports. */ +const test = require('node:test'); +const assert = require('node:assert'); +const T = require('./military-helpers'); +const { R, D, H } = T; + +const level = (h, townId, key) => h.db.get('SELECT level FROM buildings WHERE town_id = ? AND key = ?', townId, key).level; + +test('buildDone: an upgrade in flight lands ONE level above whatever the building is now (exploit kits cannot be undone by it)', () => { + const h = T.setup(); + const a = T.addOperator(h, 'alice', { infra: { firewall: 5, core_router: 10 } }); + const q = h.run('build', { userId: a.userId, townId: a.townId, key: 'firewall' }); + assert.equal(q.toLevel, 6); + // exploit kits hit the firewall while the upgrade is being built (siege writes the level directly) + h.db.run("UPDATE buildings SET level = 2 WHERE town_id = ? AND key = 'firewall'", a.townId); + h.advanceTo(q.dueAt); + assert.equal(level(h, a.townId, 'firewall'), 3, 'the finished level adds one to the damaged building, it does not restore the queued level'); + const done = T.notes(h, a.userId, 'build_done'); + assert.equal(done[done.length - 1].level, 3, 'the notification reports the real level'); +}); + +test('buildDone: a building knocked down to 0 while its upgrade is queued comes back at level 1; an undamaged one still gets +1', () => { + const h = T.setup(); + const a = T.addOperator(h, 'alice', { infra: { firewall: 4, noc: 5, core_router: 10 } }); + const q1 = h.run('build', { userId: a.userId, townId: a.townId, key: 'firewall' }); // 4 -> 5 + const q2 = h.run('build', { userId: a.userId, townId: a.townId, key: 'noc' }); // 5 -> 6 (second slot: core router 10) + h.db.run("UPDATE buildings SET level = 0 WHERE town_id = ? AND key = 'firewall'", a.townId); + h.advanceTo(Math.max(q1.dueAt, q2.dueAt)); + assert.equal(level(h, a.townId, 'firewall'), 1); + assert.equal(level(h, a.townId, 'noc'), 6); +}); + +test('buildDone: a brand-new infrastructure building appears at level 1 (no row yet)', () => { + const h = T.setup(); + const a = T.addOperator(h, 'alice', { infra: { core_router: 10 } }); + h.db.run("DELETE FROM buildings WHERE town_id = ? AND key = 'firewall'", a.townId); + const q = h.run('build', { userId: a.userId, townId: a.townId, key: 'firewall' }); + h.advanceTo(q.dueAt); + assert.equal(level(h, a.townId, 'firewall'), 1); +}); + +// ---- helpers: alliances without the HTTP layer +const A = require('../server/alliances'); +function alliance(h, name, leader, members) { + const id = Number(h.db.run('INSERT INTO alliances (world_id, name, tag, size_cap, created_by, created_at) VALUES (?, ?, ?, 10, ?, ?)', h.worldId, name, name.slice(0, 3).toUpperCase(), leader.opId, h.clock.now()).lastInsertRowid); + A.addMember(h.db, id, leader.opId, 'leader', h.clock.now()); + for (const m of members || []) A.addMember(h.db, id, m.opId, 'member', h.clock.now()); + return id; +} + +test('confederation: members see each other\'s incoming movements (origin and ETA, type hidden), strangers and neutrals do not', () => { + const h = T.setup(); + const a = T.addOperator(h, 'alice', { x: 5, y: 0 }); + const a2 = T.addOperator(h, 'alice2', { x: 5, y: 6 }); + const b = T.addOperator(h, 'bob', { x: 9, y: 0 }); + const c = T.addOperator(h, 'cat', { x: 14, y: 0, units: { script_crew: 20 } }); + const d = T.addOperator(h, 'dan', { x: 20, y: 0 }); + const X = alliance(h, 'Xray', a, [a2]), Y = alliance(h, 'Yankee', b); + const sent = h.run('sendMovement', { userId: c.userId, fromTownId: c.townId, type: 'attack', toTownId: b.townId, units: { script_crew: 20 } }); + + // neutral: nobody but the target is told + assert.equal(h.mq.movements(a.userId, {}).alliedIncoming.length, 0); + assert.equal(h.mq.movements(b.userId, {}).incoming.length, 1); + + A.setRelation(h.db, h.worldId, X, Y, 'confed', h.clock.now()); + for (const who of [a, a2]) { + const l = h.mq.movements(who.userId, {}); + assert.equal(l.alliedIncoming.length, 1, who.name + ' sees the attack on the confederate'); + const m = l.alliedIncoming[0]; + assert.equal(m.id, sent.movementId); + assert.equal(m.type, 'unknown'); + assert.equal(m.units, undefined); + assert.equal(m.arriveAt, sent.arriveAt); + assert.equal(m.from.townId, c.townId); + assert.equal(m.to.townId, b.townId); + assert.equal(m.toOperator.id, b.opId); + assert.equal(l.incoming.length, 0, 'the personal incoming list is only about your own POPs'); + } + const bl = h.mq.movements(b.userId, {}); + assert.equal(bl.incoming.length, 1, 'bob is the target himself'); + assert.equal(bl.alliedIncoming.length, 0, 'nothing is heading for his confederates'); + assert.equal(h.mq.movements(d.userId, {}).alliedIncoming.length, 0, 'a stranger sees nothing'); + assert.equal(h.mq.movements(c.userId, {}).alliedIncoming.length, 0); + + // an attack on alice shows up for bob, but alice2's own reinforcement of alice is friendly traffic and does not + h.db.run("UPDATE movements SET status = 'done'"); + T.giveUnits(h, a2.townId, { soc_analyst: 5 }); + T.giveUnits(h, c.townId, { script_crew: 5 }); + h.run('sendMovement', { userId: a2.userId, fromTownId: a2.townId, type: 'reinforce', toTownId: a.townId, units: { soc_analyst: 5 } }); + const atk = h.run('sendMovement', { userId: c.userId, fromTownId: c.townId, type: 'raid', toTownId: a.townId, units: { script_crew: 1 } }); + const bl2 = h.mq.movements(b.userId, {}); + assert.deepEqual(bl2.alliedIncoming.map((m) => m.id), [atk.movementId]); + assert.equal(h.mq.movements(a.userId, {}).incoming.length, 2, 'alice herself sees both, types hidden'); + + // the confederation ends: the window closes + A.setRelation(h.db, h.worldId, X, Y, 'neutral', h.clock.now()); + assert.equal(h.mq.movements(b.userId, {}).alliedIncoming.length, 0); +}); + +// ---- shared report folder (HTTP, so routes, permissions and schemas are covered) +const { createTestServer } = require('./helpers'); +const { createReport } = require('../server/military/reports'); + +test('shared reports: share, list, read, permissions, retention, unshare', async () => { + const t = await createTestServer({ contract: true }); + try { + const lead = await t.signupPeering('lead'), mem = await t.signupPeering('mem'), out = await t.signupPeering('outsider'); + const mk = await t.api('/alliances', { method: 'POST', body: { name: 'Folder', tag: 'FLD' } }, lead.token); + const aid = mk.body.allianceId; + const inv = await t.api('/alliances/' + aid + '/invite', { method: 'POST', body: { operatorId: mem.operatorId } }, lead.token); + await t.api('/alliance-invites/' + inv.body.inviteId + '/accept', { method: 'POST' }, mem.token); + + // two reports: one for lead, one for outsider + const ctx = { db: t.srv.db, enqueue: (e) => t.srv.scheduler.enqueue(e), notify: () => {} }; + const now = t.clock.now(); + const rid = createReport(ctx, { worldId: 1, type: 'raid', now, summary: { s: 1 }, data: { secret: 'x' }, recipients: [{ userId: lead.userId, role: 'attacker' }] }); + const rid2 = createReport(ctx, { worldId: 1, type: 'scan', now, summary: {}, data: {}, recipients: [{ userId: out.userId, role: 'attacker' }] }); + + // sharing needs to be a recipient and an alliance member + assert.equal((await t.api('/reports/' + rid2 + '/share', { method: 'POST' }, lead.token)).status, 404, 'not your report'); + assert.equal((await t.api('/reports/' + rid + '/share', { method: 'POST' }, out.token)).status, 404, 'a stranger cannot even see it exists'); + const outRep = createReport(ctx, { worldId: 1, type: 'raid', now, summary: {}, data: {}, recipients: [{ userId: out.userId, role: 'attacker' }] }); + const noAll = await t.api('/reports/' + outRep + '/share', { method: 'POST' }, out.token); + assert.equal(noAll.body.error.code, 'not_in_alliance'); + + // the folder is empty, only members read it + assert.deepEqual((await t.api('/alliances/' + aid + '/reports', {}, mem.token)).body.items, []); + assert.equal((await t.api('/alliances/' + aid + '/reports', {}, out.token)).status, 403); + + // share; retention is pushed out; repeating is a no-op + t.clock.advance(10 * 24 * 3600e3); + const sh = await t.api('/reports/' + rid + '/share', { method: 'POST' }, lead.token); + assert.equal(sh.status, 200); + assert.equal(sh.body.changed, true); + assert.equal((await t.api('/reports/' + rid + '/share', { method: 'POST' }, lead.token)).body.changed, false); + const exp = t.srv.db.get('SELECT expires_at FROM reports WHERE id = ?', rid).expires_at; + assert.equal(exp, t.clock.now() + D.MILITARY.reportRetentionMs, 'shared report is kept 14 days from the share'); + + // the member reads it although they were never a participant; the stranger still cannot + const list = await t.api('/alliances/' + aid + '/reports', {}, mem.token); + assert.equal(list.body.items.length, 1); + assert.equal(list.body.items[0].id, rid); + assert.equal(list.body.items[0].sharedBy.name, 'lead'); + const one = await t.api('/alliances/' + aid + '/reports/' + rid, {}, mem.token); + assert.equal(one.body.report.data.secret, 'x'); + assert.equal((await t.api('/alliances/' + aid + '/reports/' + rid, {}, out.token)).status, 403); + assert.equal((await t.api('/reports/' + rid, {}, mem.token)).status, 404, 'the personal report list is unchanged: sharing is not handing out the participant role'); + + // the member cannot remove the leader's share; the leader can; the report row survives it + assert.equal((await t.api('/reports/' + rid + '/share', { method: 'DELETE' }, mem.token)).status, 403); + assert.equal((await t.api('/reports/' + rid + '/share', { method: 'DELETE' }, lead.token)).body.changed, true); + assert.equal((await t.api('/alliances/' + aid + '/reports', {}, mem.token)).body.items.length, 0); + assert.ok(t.srv.db.get('SELECT 1 AS x FROM reports WHERE id = ?', rid)); + + // a member shares their own; deleting the report (cleanup) takes the share with it + const mrep = createReport(ctx, { worldId: 1, type: 'raid', now: t.clock.now(), summary: {}, data: {}, recipients: [{ userId: mem.userId, role: 'defender' }] }); + assert.equal((await t.api('/reports/' + mrep + '/share', { method: 'POST' }, mem.token)).status, 200); + assert.equal((await t.api('/reports/' + mrep + '/share', { method: 'DELETE' }, mem.token)).status, 200, 'the sharer may remove their own'); + await t.api('/reports/' + mrep + '/share', { method: 'POST' }, mem.token); + t.srv.db.run('DELETE FROM reports WHERE id = ?', mrep); + assert.equal(t.srv.db.get('SELECT COUNT(*) AS n FROM report_shares WHERE report_id = ?', mrep).n, 0); + + // cursor: newest first, next page holds older ones + const ids = []; + for (let i = 0; i < 3; i++) { + const r = createReport(ctx, { worldId: 1, type: 'raid', now: t.clock.now(), summary: {}, data: {}, recipients: [{ userId: lead.userId, role: 'attacker' }] }); + await t.api('/reports/' + r + '/share', { method: 'POST' }, lead.token); + ids.push(r); + } + const p1 = await t.api('/alliances/' + aid + '/reports?limit=2', {}, lead.token); + assert.deepEqual(p1.body.items.map((i) => i.id), [ids[2], ids[1]]); + const p2 = await t.api('/alliances/' + aid + '/reports?limit=2&after=' + p1.body.next, {}, lead.token); + assert.deepEqual(p2.body.items.map((i) => i.id), [ids[0]]); + assert.equal(p2.body.next, null); + } finally { await t.close(); } +}); diff --git a/test/endgame-rules.test.js b/test/endgame-rules.test.js new file mode 100644 index 0000000..a7b76c7 --- /dev/null +++ b/test/endgame-rules.test.js @@ -0,0 +1,128 @@ +'use strict'; +/* End game and trade rules as pure functions (public/js/rules.js, data.js). */ +const test = require('node:test'); +const assert = require('node:assert'); +const R = require('../public/js/rules.js'); +const D = require('../public/js/data.js'); + +test('backbone sites: 7 fixed positions per (seed, radius), on plain land, spread out, never in the free centre, deterministic', () => { + for (const [seed, radius] of [[4242, 50], [1, 50], [99, 20], [7, 150], [123456, 30]]) { + const sites = R.backboneSites(seed, radius); + assert.equal(sites.length, D.ENDGAME.sites, 'seed ' + seed + ' radius ' + radius); + assert.deepEqual(sites.map((s) => s.index), [0, 1, 2, 3, 4, 5, 6]); + for (const s of sites) { + assert.equal(R.terrainAt(seed, radius, s.x, s.y).type, 'land'); + assert.ok(Math.abs(s.x) > 2 || Math.abs(s.y) > 2, 'not in the free centre'); + assert.ok(Math.abs(s.x) <= radius && Math.abs(s.y) <= radius); + for (const o of sites) if (o !== s) assert.ok(R.distance(s.x, s.y, o.x, o.y) >= D.ENDGAME.siteMinSpacing, 'spacing'); + } + assert.deepEqual(R.backboneSites(seed, radius), sites, 'same input, same answer'); + } + assert.notDeepEqual(R.backboneSites(1, 50), R.backboneSites(2, 50), 'the seed decides'); +}); + +test('tileAt: a landing site is plain land until world day openDay, then reads backbone; old 4-argument callers see no change', () => { + const seed = 4242, radius = 50; + const s = R.backboneSites(seed, radius)[3]; + assert.deepEqual(R.tileAt(seed, radius, s.x, s.y), { type: 'land' }); + assert.deepEqual(R.tileAt(seed, radius, s.x, s.y, 0), { type: 'land' }); + assert.deepEqual(R.tileAt(seed, radius, s.x, s.y, D.ENDGAME.openDay - 0.001), { type: 'land' }); + assert.deepEqual(R.tileAt(seed, radius, s.x, s.y, D.ENDGAME.openDay), { type: 'backbone', site: 3 }); + assert.deepEqual(R.tileAt(seed, radius, s.x, s.y, 500), { type: 'backbone', site: 3 }); + // every other tile is identical with and without age + let seen = 0; + for (let x = -radius; x <= radius; x += 1) for (let y = -radius; y <= radius; y += 3) { + const a = R.tileAt(seed, radius, x, y), b = R.tileAt(seed, radius, x, y, 1000); + if (b.type === 'backbone') { seen++; assert.ok(R.isBackboneSite(seed, radius, x, y)); } else assert.deepEqual(a, b); + } + assert.ok(seen >= 1); + assert.equal(R.tileAt(seed, radius, radius + 1, 0, 1000).type, 'void'); +}); + +test('spawning and settling never use a landing site, not even before it shows', () => { + const seed = 4242, radius = 50; + const sites = R.backboneSites(seed, radius); + const towns = []; + for (let n = 0; n < 150; n++) { + const p = R.pickSpawn(seed, radius, n, towns); + if (!p) break; + assert.ok(!sites.some((s) => s.x === p.x && s.y === p.y), 'spawn ' + n + ' on a landing site'); + towns.push(p); + } + assert.ok(towns.length > 100); + const s = sites[0]; + const ok = { tileType: 'land', occupied: false, nearestOwnDist: 3, ownedCount: 1, footprint: 1e9 }; + assert.equal(R.settleCheck(ok).ok, true); + const refused = R.settleCheck(Object.assign({ backbone: R.isBackboneSite(seed, radius, s.x, s.y) }, ok)); + assert.equal(refused.ok, false); + assert.equal(refused.reason, 'backbone_site'); + assert.equal(R.settleCheck({ tileType: 'backbone', occupied: false, nearestOwnDist: 3, ownedCount: 1, footprint: 1e9 }).ok, false); +}); + +test('world phase and age: running, backbone_open from day 100 / speed, ended wins over everything', () => { + const DAY = 24 * 3600e3; + assert.equal(R.worldAgeDays(1000, 1000, 1), 0); + assert.equal(R.worldAgeDays(1000, 1000 - 5, 1), 0, 'never negative'); + assert.equal(R.worldAgeDays(0, 10 * DAY, 3), 30); + assert.equal(R.worldPhase('running', 99.9), 'running'); + assert.equal(R.worldPhase('running', 100), 'backbone_open'); + assert.equal(R.worldPhase('ended', 5), 'ended'); + assert.equal(R.worldPhase('ended', 500), 'ended'); + // speed 4: day 100 of world time arrives after 25 real days + assert.ok(R.worldAgeDays(0, 25 * DAY, 4) >= D.ENDGAME.openDay); +}); + +test('backbone defence grows with world age and node level; cost and time curves are monotonic and far above any other building', () => { + const seed = 4242; + const d0 = R.backboneDefence(seed, 10, 10, 100, 0), d50 = R.backboneDefence(seed, 10, 10, 100, 50), dOld = R.backboneDefence(seed, 10, 10, 200, 0); + assert.ok(d50 > d0 && dOld > d0); + assert.equal(R.backboneDefence(seed, 10, 10, 100, 0), Math.round(R.incumbentDefence(seed, 10, 10, 100) * D.ENDGAME.defenceMult)); + assert.ok(d0 > 10 * R.incumbentDefence(seed, 10, 10, 100), 'heavy: well above an ordinary incumbent site'); + let prev = 0, prevT = 0, sumFiber = 0; + for (let l = 1; l <= D.ENDGAME.maxLevel; l++) { + const c = R.backboneCost(l), t = R.backboneTimeMs(l, 1); + assert.ok(c.fiber > prev && t > prevT, 'level ' + l); + prev = c.fiber; prevT = t; sumFiber += c.fiber; + } + assert.equal(R.backboneCost(1).fiber, D.BUILDINGS.backbone_node.cost.fiber); + assert.ok(R.backboneCost(1).fiber > R.buildingCost('rollout_depot', 1).fiber * 10, 'level 1 already dwarfs the dearest ordinary building level 1'); + assert.ok(R.backboneCost(D.ENDGAME.maxLevel).fiber > R.buildingCost('rack_hall', 20).fiber, 'level 100 > the best ordinary building'); + assert.equal(R.backboneTimeMs(1, 4), R.backboneTimeMs(1, 1) / 4, 'world speed divides'); + assert.ok(sumFiber > 1e6, 'millions in total (a first guess, not balanced)'); +}); + +test('backbonePlan: one level at a time, paid from the pool', () => { + const pool = (n) => ({ fiber: n, hardware: n, capital: n }); + assert.equal(R.backbonePlan({ level: 0, build: null, pool: pool(100) }, 1).code, 'not_enough_resources'); + assert.equal(R.backbonePlan({ level: 0, build: null, pool: { fiber: 4000, hardware: 4000, capital: 3999 } }, 1).code, 'not_enough_resources'); + const ok = R.backbonePlan({ level: 0, build: null, pool: pool(4000) }, 1); + assert.equal(ok.ok, true); assert.equal(ok.toLevel, 1); assert.deepEqual(ok.cost, R.backboneCost(1)); + assert.equal(R.backbonePlan({ level: 3, build: { to: 4 }, pool: pool(1e9) }, 1).code, 'already_queued'); + assert.equal(R.backbonePlan({ level: 100, build: null, pool: pool(1e12) }, 1).code, 'max_level'); +}); + +test('trade terms: ratio band 1:2 both ways, one transport link per side, distinct resources, whole numbers', () => { + const t = (o) => R.tradeTermsCheck(Object.assign({ giveRes: 'fiber', giveAmount: 100, wantRes: 'hardware', wantAmount: 100, maxDistance: 10 }, o)); + assert.equal(t().ok, true); + assert.equal(t({ giveAmount: 200, wantAmount: 100 }).ok, true); + assert.equal(t({ giveAmount: 100, wantAmount: 200 }).ok, true); + assert.equal(t({ giveAmount: 201, wantAmount: 100 }).code, 'trade_ratio'); + assert.equal(t({ giveAmount: 100, wantAmount: 201 }).code, 'trade_ratio'); + assert.equal(t({ giveAmount: D.TRANSPORT.capacityPerLink, wantAmount: D.TRANSPORT.capacityPerLink }).ok, true); + assert.equal(t({ giveAmount: D.TRANSPORT.capacityPerLink + 1, wantAmount: D.TRANSPORT.capacityPerLink }).code, 'capacity_exceeded'); + assert.equal(t({ wantRes: 'fiber' }).code, 'validation_failed'); + assert.equal(t({ giveRes: 'power' }).code, 'validation_failed'); + assert.equal(t({ giveAmount: 0.5 }).code, 'validation_failed'); + assert.equal(t({ maxDistance: 0 }).code, 'validation_failed'); + assert.equal(R.tradeReach(0), 0); + assert.equal(R.tradeReach(3), 3 * D.TRADE.reachPerLevel); + assert.equal(R.tradeInRange(10, 10, 1), true); + assert.equal(R.tradeInRange(10.01, 20, 1), false, "the taker's reach limits"); + assert.equal(R.tradeInRange(5, 4, 5), false, "the offer's max distance limits"); + assert.equal(R.tradeInRange(1, 50, 0), false, 'no exchange'); +}); + +test('data: the end-game level cap matches the Backbone node building', () => { + assert.equal(D.ENDGAME.maxLevel, D.BUILDINGS.backbone_node.maxLevel); + assert.equal(D.BUILDINGS.backbone_node.special, 'backbone'); +}); diff --git a/test/push-game.test.js b/test/push-game.test.js new file mode 100644 index 0000000..c27f054 --- /dev/null +++ b/test/push-game.test.js @@ -0,0 +1,189 @@ +'use strict'; +/* Which hint goes to whom (server/pushHooks.js), end to end: REST commands and the event queue on a fake clock, real + * WebSocket clients. Push is only a hint: every assertion on a hint is paired with the REST/DB truth it points at. */ +const test = require('node:test'); +const assert = require('node:assert'); +const { createTestServer } = require('./helpers'); +const { login, sleep } = require('./push-helpers'); +const D = require('../public/js/data.js'); +const H = D.HOUR_MS; + +const post = (body) => ({ method: 'POST', body }); + +test('build: command hint on all devices of the owner, then town + notification when it finishes; nothing for others', async () => { + const t = await createTestServer(); + try { + const alice = await t.signup('alice'), bob = await t.signup('bobby'); + const login2 = await t.api('/auth/login', post({ username: 'alice', password: 'correct horse battery' })); + const a1 = await login(t.srv, alice.token), a2 = await login(t.srv, login2.body.token), b = await login(t.srv, bob.token); + + const r = await t.api('/towns/' + alice.townId + '/build', post({ key: 'f1' }), alice.token); + assert.equal(r.status, 201, JSON.stringify(r.body)); + for (const c of [a1, a2]) await c.waitFor((m) => m.type === 'town' && m.townId === alice.townId); + await sleep(50); + + for (const c of [a1, a2]) c.msgs.length = 0; + t.clock.advance(r.body.dueAt - t.clock.now()); + t.srv.scheduler.runDue(); // the buildDone event fires + for (const c of [a1, a2]) { + const town = await c.waitFor((m) => m.type === 'town' && m.townId === alice.townId); + assert.deepEqual(town, { type: 'town', townId: alice.townId }); + const n = await c.waitFor((m) => m.type === 'notification'); + assert.equal(n.kind, 'build_done'); + const row = t.srv.db.get('SELECT type FROM notifications WHERE id = ?', n.id); + assert.equal(row.type, 'build_done', 'the id points at a real notification row'); + } + assert.deepEqual((await b.settle(100)).filter((m) => m.type !== 'ready'), [], 'another player hears nothing'); + const poll = await t.api('/notifications', {}, alice.token); + assert.ok(poll.body.items.some((x) => x.id === a1.msgs.find((m) => m.type === 'notification').id), 'and REST agrees'); + } finally { await t.close(); } +}); + +test('train done: town + notification (train_done)', async () => { + const t = await createTestServer(); + try { + const a = await t.signup('alice'); + t.clock.advance(73 * H); + for (const [k, lv] of [['ops_lab', 3], ['noc', 2]]) t.srv.db.run('INSERT OR REPLACE INTO buildings (town_id, key, type, level) VALUES (?, ?, ?, ?)', a.townId, k, k, lv); + t.srv.db.run('UPDATE towns SET fiber = 5000, hardware = 5000, capital = 5000 WHERE id = ?', a.townId); + const c = await login(t.srv, a.token); + const r = await t.api('/towns/' + a.townId + '/train', post({ unit: 'script_crew', count: 5 }), a.token); + assert.equal(r.status, 201, JSON.stringify(r.body)); + await c.waitFor((m) => m.type === 'town'); // command hint + await c.settle(50); c.msgs.length = 0; + t.clock.set(r.body.dueAt); + t.srv.scheduler.runDue(); + await c.waitFor((m) => m.type === 'town' && m.townId === a.townId); + const n = await c.waitFor((m) => m.type === 'notification'); + assert.equal(n.kind, 'train_done'); + } finally { await t.close(); } +}); + +// alice raids bobby: bobby gets 'incoming' (only him), a report lands for both +async function raidSetup(t) { + const a = await t.signup('alice'), b = await t.signup('bobby'); + const db = t.srv.db; + t.clock.advance(73 * H); // beginner protection over + for (const [k, lv] of [['ops_lab', 3], ['research_lab', 3], ['noc', 2]]) db.run('INSERT OR REPLACE INTO buildings (town_id, key, type, level) VALUES (?, ?, ?, ?)', a.townId, k, k, lv); + db.run('UPDATE towns SET fiber = 5000, hardware = 5000, capital = 5000 WHERE id = ?', a.townId); + let r = await t.api('/towns/' + a.townId + '/train', post({ unit: 'script_crew', count: 20 }), a.token); + assert.equal(r.status, 201, JSON.stringify(r.body)); + t.clock.advance(3 * H); + t.srv.scheduler.runDue(); + return { a, b }; +} + +test('incoming attack: defender gets incoming (+ notification), attacker does not; then report hints for both', async () => { + const t = await createTestServer(); + try { + const { a, b } = await raidSetup(t); + const ca = await login(t.srv, a.token), cb = await login(t.srv, b.token); + await sleep(30); ca.msgs.length = 0; cb.msgs.length = 0; + + const r = await t.api('/movements', post({ fromTownId: a.townId, type: 'raid', toTownId: b.townId, units: { script_crew: 10 } }), a.token); + assert.equal(r.status, 201, JSON.stringify(r.body)); + const inc = await cb.waitFor((m) => m.type === 'incoming'); + assert.deepEqual(inc, { type: 'incoming', townId: b.townId, arriveAt: r.body.arriveAt }, 'town and ETA only, no type, no origin'); + const note = await cb.waitFor((m) => m.type === 'notification' && m.kind === 'incoming'); + assert.ok(t.srv.db.get('SELECT 1 AS x FROM notifications WHERE id = ? AND user_id = ?', note.id, b.userId)); + const mine = await ca.settle(100); + assert.ok(!mine.some((m) => m.type === 'incoming' || m.type === 'notification'), 'the attacker gets no warning: ' + JSON.stringify(mine)); + assert.ok(mine.some((m) => m.type === 'town' && m.townId === a.townId), 'but a town hint for the POP that sent the units'); + assert.ok(!cb.msgs.some((m) => m.type === 'town'), 'no plain town hint for the target at launch (the warning carries the ETA)'); + + ca.msgs.length = 0; cb.msgs.length = 0; + t.clock.set(r.body.arriveAt); + t.srv.scheduler.runDue(); // combat resolves + const rep = t.srv.db.get('SELECT id FROM reports ORDER BY id DESC LIMIT 1'); + assert.ok(rep); + for (const c of [ca, cb]) { + const m = await c.waitFor((x) => x.type === 'report'); + assert.deepEqual(m, { type: 'report', id: rep.id }); + await c.waitFor((x) => x.type === 'notification' && x.kind === 'report'); + } + await cb.waitFor((m) => m.type === 'town' && m.townId === b.townId); // the attacked POP changed + const view = await t.api('/reports/' + rep.id, {}, b.token); + assert.equal(view.status, 200, 'the id in the hint is fetchable over REST'); + } finally { await t.close(); } +}); + +test('recall: the target owner learns the warning is gone (town hint), the sender gets his POP hint', async () => { + const t = await createTestServer(); + try { + const { a, b } = await raidSetup(t); + const ca = await login(t.srv, a.token), cb = await login(t.srv, b.token); + const r = await t.api('/movements', post({ fromTownId: a.townId, type: 'raid', toTownId: b.townId, units: { script_crew: 10 } }), a.token); + await cb.waitFor((m) => m.type === 'incoming'); + await sleep(50); cb.msgs.length = 0; ca.msgs.length = 0; + const rc = await t.api('/movements/' + r.body.movementId + '/recall', post({}), a.token); + assert.equal(rc.status, 200, JSON.stringify(rc.body)); + await cb.waitFor((m) => m.type === 'town' && m.townId === b.townId); + await ca.waitFor((m) => m.type === 'town' && m.townId === a.townId); + } finally { await t.close(); } +}); + +test('messages and alliance invites: message hint with id, notification with kind alliance_invite', async () => { + const t = await createTestServer(); + try { + const lead = await t.signupPeering('leader'), bob = await t.signup('bobby'); + const cl = await login(t.srv, lead.token), cb = await login(t.srv, bob.token); + + let r = await t.api('/messages', post({ toOperatorId: bob.operatorId, text: 'hello there' }), lead.token); + assert.equal(r.status, 201, JSON.stringify(r.body)); + const m = await cb.waitFor((x) => x.type === 'message'); + assert.deepEqual(m, { type: 'message', id: r.body.messageId }); + assert.equal((await cb.waitFor((x) => x.type === 'notification' && x.kind === 'message')).kind, 'message'); + assert.ok(!(await cl.settle(50)).some((x) => x.type === 'message'), 'the sender gets no message hint'); + + r = await t.api('/alliances', post({ name: 'Pushers', tag: 'PSH' }), lead.token); + assert.equal(r.status, 201, JSON.stringify(r.body)); + const inv = await t.api('/alliances/' + r.body.allianceId + '/invite', post({ operatorId: bob.operatorId }), lead.token); + assert.equal(inv.status, 201, JSON.stringify(inv.body)); + const n = await cb.waitFor((x) => x.type === 'notification' && x.kind === 'alliance_invite'); + assert.ok(t.srv.db.get("SELECT 1 AS x FROM notifications WHERE id = ? AND type = 'alliance_invite'", n.id)); + } finally { await t.close(); } +}); + +test('hints are coalesced: identical hints produced in one tick go out once, distinct ones all arrive in order', async () => { + const t = await createTestServer(); + try { + const a = await t.signup('alice'); + const c = await login(t.srv, a.token); + for (let i = 0; i < 50; i++) t.srv.push.toTown(a.townId, { type: 'town', townId: a.townId }); // e.g. a long catch-up + t.srv.push.toUser(a.userId, { type: 'notification', id: 1, kind: 'x' }); + t.srv.push.toUser(a.userId, { type: 'notification', id: 2, kind: 'x' }); + t.srv.push.toUser(a.userId, { type: 'notification', id: 1, kind: 'x' }); + await c.waitFor((m) => m.type === 'notification' && m.id === 2); + await c.settle(50); + const got = c.msgs.filter((m) => m.type !== 'ready'); + assert.deepEqual(got, [{ type: 'town', townId: a.townId }, { type: 'notification', id: 1, kind: 'x' }, { type: 'notification', id: 2, kind: 'x' }]); + t.srv.push.toUser(999999, { type: 'town', townId: 1 }); // unknown user: silently nothing + t.srv.push.toTown(999999, { type: 'town', townId: 999999 }); // unknown POP: silently nothing + } finally { await t.close(); } +}); + +test('rollback: a notification written by an event or command that then fails is never pushed (hints follow the commit)', async () => { + const t = await createTestServer(); + try { + const a = await t.signup('alice'); + const c = await login(t.srv, a.token); + const sc = t.srv.scheduler; + sc.register('boom', (ctx, ev) => { ctx.notify(a.userId, ev.worldId, 'ghost', {}); throw new Error('handler failed'); }); + sc.register('fine', (ctx, ev) => { ctx.notify(a.userId, ev.worldId, 'real', {}); }); + t.srv.commands.handlers.boomCmd = (ctx) => { ctx.scheduler.notify(a.userId, null, 'ghost_cmd', {}); throw new Error('command failed'); }; + t.srv.commands.handlers.fineCmd = (ctx) => { ctx.scheduler.notify(a.userId, null, 'real_cmd', {}); return {}; }; + const worldId = t.srv.db.get('SELECT id FROM worlds').id; + const now = t.clock.now(); + sc.enqueue({ worldId, dueAt: now + 10, type: 'boom', payload: {} }); + sc.enqueue({ worldId, dueAt: now + 20, type: 'fine', payload: {} }); + t.clock.advance(100); + sc.runDue(); + assert.throws(() => t.srv.commands.run('boomCmd', {}), /command failed/); + t.srv.commands.run('fineCmd', {}); + await c.waitFor((m) => m.kind === 'real_cmd'); + const kinds = (await c.settle(60)).filter((m) => m.type === 'notification').map((m) => m.kind); + assert.deepEqual(kinds, ['real', 'real_cmd']); + assert.equal(t.srv.db.get("SELECT COUNT(*) AS n FROM notifications WHERE type IN ('ghost', 'ghost_cmd')").n, 0, 'the rows rolled back too'); + assert.equal(sc.outbox.length, 0); + } finally { await t.close(); } +}); diff --git a/test/push-helpers.js b/test/push-helpers.js new file mode 100644 index 0000000..2613151 --- /dev/null +++ b/test/push-helpers.js @@ -0,0 +1,56 @@ +'use strict'; +/* Shared helpers of the push tests (no tests in here): a recording WebSocket client around the real `ws` package. */ +const WebSocket = require('ws'); + +const sleep = (ms) => new Promise((r) => setTimeout(r, ms)); + +// Opens ws://127.0.0.1:port/ws. Resolves { ws, msgs, closed, open, waitFor(pred, ms), expectNone(ms), send(obj), auth(token) }. +// `closed` resolves { code, reason } when the socket closes. Rejects with { status } when the upgrade is refused. +function connect(srv, o) { + o = o || {}; + return new Promise((resolve, reject) => { + const ws = new WebSocket('ws://127.0.0.1:' + srv.port + (o.path || '/ws'), Object.assign({ headers: o.headers || {} }, o.wsOptions || {})); + const msgs = []; + const waiters = []; + let closedResolve; + const closed = new Promise((r) => { closedResolve = r; }); + const c = { + ws, msgs, closed, + send: (obj) => ws.send(typeof obj === 'string' ? obj : JSON.stringify(obj)), + auth: (token) => c.send({ type: 'auth', token }), + // first message (already received or still to come) matching pred, within ms + waitFor(pred, ms) { + const hit = msgs.find(pred); + if (hit) return Promise.resolve(hit); + return new Promise((res, rej) => { + const t = setTimeout(() => { const i = waiters.indexOf(w); if (i >= 0) waiters.splice(i, 1); rej(new Error('no matching message in ' + (ms || 2000) + ' ms; got ' + JSON.stringify(msgs))); }, ms || 2000); + const w = { pred, res: (m) => { clearTimeout(t); res(m); } }; + waiters.push(w); + }); + }, + // wait ms, then return everything received so far + async settle(ms) { await sleep(ms === undefined ? 80 : ms); return msgs.slice(); }, + async connectAndAuth(token) { c.auth(token); return c.waitFor((m) => m.type === 'ready'); }, + }; + ws.on('message', (d) => { + let m; try { m = JSON.parse(d.toString()); } catch (e) { m = { raw: d.toString() }; } + msgs.push(m); + for (let i = waiters.length - 1; i >= 0; i--) if (waiters[i].pred(m)) { const w = waiters.splice(i, 1)[0]; w.res(m); } + }); + ws.on('close', (code, reason) => closedResolve({ code, reason: reason.toString() })); + ws.on('unexpected-response', (req, res) => { res.resume(); reject({ status: res.statusCode }); }); + ws.on('error', (err) => { if (!/Unexpected server response/.test(err.message)) { /* closed or reset: `closed` reports it */ } }); + ws.on('open', () => resolve(c)); + }); +} + +// Connect and authenticate in one go. +async function login(srv, token, o) { + const c = await connect(srv, o); + await c.connectAndAuth(token); + return c; +} + +const within = (p, ms, label) => Promise.race([p, new Promise((_, rej) => setTimeout(() => rej(new Error('timeout after ' + ms + ' ms: ' + (label || ''))), ms))]); + +module.exports = { connect, login, sleep, within }; diff --git a/test/push-ws.test.js b/test/push-ws.test.js new file mode 100644 index 0000000..a6daf53 --- /dev/null +++ b/test/push-ws.test.js @@ -0,0 +1,193 @@ +'use strict'; +/* WebSocket transport (server/push.js): auth, limits, keepalive, revocation, shutdown. Real `ws` client against + * createServer on port 0 with the fake clock. Game hints are in push-game.test.js. */ +const test = require('node:test'); +const assert = require('node:assert'); +const WebSocket = require('ws'); +const { createTestServer } = require('./helpers'); +const { connect, login, sleep, within } = require('./push-helpers'); + +test('auth: ready carries the server clock, ping gets pong, REST token works as ws token', async () => { + const t = await createTestServer(); + try { + const u = await t.signup('alice'); + t.clock.advance(12345); + const c = await connect(t.srv); + c.auth(u.token); + const ready = await c.waitFor((m) => m.type === 'ready'); + assert.deepEqual(Object.keys(ready).sort(), ['serverTime', 'type']); + assert.equal(ready.serverTime, t.clock.now()); + c.send({ type: 'ping' }); + const pong = await c.waitFor((m) => m.type === 'pong'); + assert.equal(pong.serverTime, t.clock.now()); + assert.equal(t.srv.push.stats().users, 1); + c.ws.close(); + await c.closed; + await sleep(20); + assert.deepEqual(t.srv.push.stats(), { connections: 0, users: 0, ips: 0 }, 'registry is empty after close'); + } finally { await t.close(); } +}); + +test('auth: bad token, first message not auth, junk first message: close 4401, never a ready', async () => { + const t = await createTestServer(); + try { + const u = await t.signup('alice'); + for (const first of [{ type: 'auth', token: 'x'.repeat(43) }, { type: 'auth' }, { type: 'auth', token: 12345 }, { type: 'ping' }, 'not json', '[1,2]', { type: 'auth', token: u.token + 'x' }]) { + const c = await connect(t.srv); + c.send(first); + const r = await within(c.closed, 2000, JSON.stringify(first)); + assert.equal(r.code, 4401, JSON.stringify(first)); + assert.ok(!c.msgs.some((m) => m.type === 'ready')); + } + // a token in the URL is ignored: auth is the first MESSAGE only + const c = await connect(t.srv, { path: '/ws?token=' + u.token }); + c.send({ type: 'ping' }); + assert.equal((await c.closed).code, 4401); + await sleep(30); + assert.equal(t.srv.push.stats().connections, 0); + } finally { await t.close(); } +}); + +test('auth timeout: no message within wsAuthTimeoutMs closes 4408', async () => { + const t = await createTestServer({ server: { wsAuthTimeoutMs: 150 } }); + try { + const c = await connect(t.srv); + const r = await within(c.closed, 2000); + assert.equal(r.code, 4408); + } finally { await t.close(); } +}); + +test('upgrade checks: origin, path, per-IP cap (released on close)', async () => { + const t = await createTestServer({ server: { maxConnPerIp: 2, allowedOrigins: ['https://game.example.com'] } }); + try { + const u = await t.signup('alice'); + await assert.rejects(connect(t.srv, { headers: { Origin: 'https://evil.example' } }), { status: 403 }); + await assert.rejects(connect(t.srv, { headers: { Origin: 'null' } }), { status: 403 }); + await assert.rejects(connect(t.srv, { path: '/socket' }), { status: 404 }); + const ok1 = await login(t.srv, u.token, { headers: { Origin: 'https://game.example.com' } }); // allowlisted + const ok2 = await login(t.srv, u.token, { headers: { Origin: 'http://127.0.0.1:' + t.srv.port } }); // same host as Host + await assert.rejects(connect(t.srv), { status: 429 }, 'third socket from one address'); + ok1.ws.close(); await ok1.closed; await sleep(20); + const ok3 = await login(t.srv, u.token); // no Origin: non-browser client + assert.equal(t.srv.push.stats().connections, 2); + ok2.ws.close(); ok3.ws.close(); + await Promise.all([ok2.closed, ok3.closed]); + // refused requests never leaked a count + await sleep(20); + assert.equal(t.srv.push.stats().ips, 0); + } finally { await t.close(); } +}); + +test('rate limit per socket closes 4429; the bucket refills', async () => { + const t = await createTestServer({ server: { wsRate: 2, wsBurst: 4 } }); + try { + const u = await t.signup('alice'); + const calm = await login(t.srv, u.token); + for (let i = 0; i < 3; i++) { calm.send({ type: 'ping' }); await sleep(600); } // 1.7 msg/s: fine + assert.equal(calm.msgs.filter((m) => m.type === 'pong').length, 3); + calm.ws.close(); + const c = await login(t.srv, u.token); + for (let i = 0; i < 12; i++) c.send({ type: 'ping' }); // burst of 12 > 4 + refill + assert.equal((await within(c.closed, 2000)).code, 4429); + } finally { await t.close(); } +}); + +test('bad-message budget closes 4400; oversize payload closes 1009', async () => { + const t = await createTestServer({ server: { wsBadBudget: 3 } }); + try { + const u = await t.signup('alice'); + const c = await login(t.srv, u.token); + c.send({ type: 'subscribe' }); + c.send('not json'); + c.send({ type: 'auth', token: u.token }); // already authenticated: counts as bad + assert.equal((await within(c.closed, 2000)).code, 4400); + + const big = await login(t.srv, u.token); + big.send(JSON.stringify({ type: 'ping', pad: 'x'.repeat(2000) })); + assert.equal((await within(big.closed, 2000)).code, 1009); + + const bin = await login(t.srv, u.token); + bin.ws.send(Buffer.from([1, 2, 3])); // binary frames are bad messages too + bin.ws.send(Buffer.from([1, 2, 3])); + bin.ws.send(Buffer.from([1, 2, 3])); + assert.equal((await within(bin.closed, 2000)).code, 4400); + } finally { await t.close(); } +}); + +test('keepalive: a socket that never answers pings is terminated', async () => { + const t = await createTestServer({ server: { wsPingMs: 60 } }); + try { + const u = await t.signup('alice'); + const live = await login(t.srv, u.token); // answers pings (ws default) + const dead = await login(t.srv, u.token, { wsOptions: { autoPong: false } }); // swallows them + const r = await within(dead.closed, 2000, 'dead socket should be dropped'); + assert.equal(r.code, 1006); + await sleep(200); + assert.equal(live.ws.readyState, WebSocket.OPEN, 'a healthy socket stays'); + assert.equal(t.srv.push.stats().connections, 1); + live.ws.close(); + } finally { await t.close(); } +}); + +test('revoked token and banned user are disconnected at the next ping tick; other devices stay', async () => { + const t = await createTestServer({ server: { wsPingMs: 60 } }); + try { + const u = await t.signup('alice'); + const login2 = await t.api('/auth/login', { method: 'POST', body: { username: 'alice', password: 'correct horse battery' } }); + const phone = login2.body.token; + const a = await login(t.srv, u.token), b = await login(t.srv, phone); + let r = await t.api('/auth/logout', { method: 'POST' }, u.token); // revoke device 1 + assert.equal(r.status, 200); + const res = await within(a.closed, 2000, 'revoked socket'); + assert.equal(res.code, 4401); assert.equal(res.reason, 'token_revoked'); + await sleep(150); + assert.equal(b.ws.readyState, WebSocket.OPEN, 'the phone token is still valid'); + // and a revoked token cannot open a new socket + const c = await connect(t.srv); + c.auth(u.token); + assert.equal((await within(c.closed, 2000)).code, 4401); + // ban + t.srv.db.run('UPDATE users SET banned = 1 WHERE id = ?', u.userId); + assert.equal((await within(b.closed, 2000, 'banned user')).code, 4401); + } finally { await t.close(); } +}); + +test('shutdown: srv.close() closes every socket with 1001 and completes promptly', async () => { + const t = await createTestServer(); + const u = await t.signup('alice'); + const socks = [await login(t.srv, u.token), await login(t.srv, u.token), await connect(t.srv)]; // two authed, one silent + const started = Date.now(); + await within(t.close(), 4000, 'srv.close()'); + assert.ok(Date.now() - started < 3000, 'close took ' + (Date.now() - started) + ' ms'); + for (const s of socks) assert.equal((await within(s.closed, 1000)).code, 1001); +}); + +test('REST works fully with no socket, with an idle socket, and a failing command pushes nothing', async () => { + const t = await createTestServer(); + try { + const u = await t.signup('alice'); + // no socket at all: build, finish, notification row, all over REST + let r = await t.api('/towns/' + u.townId + '/build', { method: 'POST', body: { key: 'f1' } }, u.token); + assert.equal(r.status, 201, JSON.stringify(r.body)); + t.clock.advance(r.body.dueAt - t.clock.now() + 1000); + r = await t.api('/notifications', {}, u.token); + assert.equal(r.status, 200); + assert.ok(r.body.items.some((n) => n.type === 'build_done')); + // a connected socket sees no hint for a refused command (rolled back, nothing happened) + const c = await login(t.srv, u.token); + r = await t.api('/towns/' + u.townId + '/build', { method: 'POST', body: { key: 'f1' } }, u.token); + assert.equal(r.status, 201); // sanity: this one is valid + await c.waitFor((m) => m.type === 'town'); // the valid build's own hint + await c.settle(50); c.msgs.length = 0; + const bad = await t.api('/towns/' + u.townId + '/build', { method: 'POST', body: { key: 'f1' } }, u.token); // queue/resources: refused + assert.ok(bad.status >= 400, 'second build of the same field is refused: ' + bad.status); + assert.deepEqual(await c.settle(100), [], 'no hint for a refused command'); + // an unauthenticated socket gets no hints either + const idle = await connect(t.srv); + t.clock.advance(24 * 3600e3); + t.srv.scheduler.runDue(); + assert.deepEqual(await idle.settle(100), []); + assert.equal(c.msgs.filter((m) => m.type === 'town').length >= 1, true, 'the authenticated one got its hint'); + idle.ws.close(); c.ws.close(); + } finally { await t.close(); } +}); diff --git a/test/trade-api.test.js b/test/trade-api.test.js new file mode 100644 index 0000000..0faefda --- /dev/null +++ b/test/trade-api.test.js @@ -0,0 +1,75 @@ +'use strict'; +/* Trade over HTTP: routes, validation, error codes, pagination, and the declared response schemas (contract: true). */ +const test = require('node:test'); +const assert = require('node:assert'); +const { createTestServer } = require('./helpers'); +const D = require('../public/js/data.js'); + +test('trade API: post, list, take, mine, detail, cancel, errors', async () => { + const t = await createTestServer({ contract: true }); + try { + const a = await t.signup('alice'), b = await t.signup('bob'), c = await t.signup('cara'); + for (const u of [a, b]) t.setBuilding(u.townId, 'internet_exchange', 3); + // cara has no exchange at all + const body = (o) => Object.assign({ townId: a.townId, giveRes: 'fiber', giveAmount: 400, wantRes: 'hardware', wantAmount: 300, maxDistance: 40 }, o || {}); + + const bad = await t.api('/trade/offers', { method: 'POST', body: body({ giveAmount: 500, wantAmount: 200 }) }, a.token); + assert.equal(bad.status, 409); assert.equal(bad.body.error.code, 'trade_ratio'); + assert.equal((await t.api('/trade/offers', { method: 'POST', body: body({ wantRes: 'fiber' }) }, a.token)).status, 422); + assert.equal((await t.api('/trade/offers', { method: 'POST', body: body({ townId: b.townId }) }, a.token)).status, 404); + assert.equal((await t.api('/trade/offers', { method: 'POST', body: body() })).status, 401); + + const made = await t.api('/trade/offers', { method: 'POST', body: body() }, a.token); + assert.equal(made.status, 201); + const id = made.body.offer.id; + assert.equal(made.body.offer.give.amount, 400); + assert.equal((await t.api('/trade/offers', { method: 'POST', body: body({ giveAmount: 100, wantAmount: 100, giveRes: 'capital' }) }, a.token)).status, 201); + + const listB = await t.api('/trade/offers', {}, b.token); + assert.equal(listB.status, 200); + assert.equal(listB.body.items.length, 2); + assert.equal(listB.body.items[0].id > listB.body.items[1].id, true, 'newest first'); + const p1 = await t.api('/trade/offers?limit=1', {}, b.token); + assert.equal(p1.body.items.length, 1); + const p2 = await t.api('/trade/offers?limit=1&after=' + p1.body.next, {}, b.token); + assert.equal(p2.body.items[0].id, id); + assert.equal(p2.body.next, null); + assert.equal((await t.api('/trade/offers?give=capital', {}, b.token)).body.items.length, 1, 'filter by offered resource'); + assert.equal((await t.api('/trade/offers?want=capital', {}, b.token)).body.items.length, 0); + assert.equal((await t.api('/trade/offers', {}, a.token)).body.items.length, 0, 'not your own'); + assert.equal((await t.api('/trade/offers', {}, c.token)).body.items.length, 0, 'no exchange: you see nothing'); + assert.equal((await t.api('/trade/offers?give=gold', {}, b.token)).status, 422); + + const one = await t.api('/trade/offers/' + id, {}, c.token); + assert.equal(one.body.offer.status, 'open', 'open offers are public inside the world'); + + const acc = await t.api('/trade/offers/' + id + '/accept', { method: 'POST', body: { townId: b.townId } }, b.token); + assert.equal(acc.status, 201); + assert.equal(acc.body.status, 'accepted'); + assert.equal((await t.api('/trade/offers/' + id + '/accept', { method: 'POST', body: { townId: b.townId } }, b.token)).body.error.code, 'offer_closed'); + assert.equal((await t.api('/trade/offers/' + id, {}, c.token)).status, 404, 'closed offers are for the two parties'); + t.clock.advance(acc.body.arriveAt - t.clock.now()); + t.srv.scheduler.runDue(); + const mineA = await t.api('/trade/offers/mine', {}, a.token), mineB = await t.api('/trade/offers/mine?status=completed', {}, b.token); + assert.equal(mineA.body.items.length, 2); + assert.equal(mineB.body.items[0].status, 'completed'); + assert.equal(mineB.body.items[0].role, 'acceptor'); + const notes = await t.api('/notifications', {}, a.token); + assert.ok(notes.body.items.some((n) => n.type === 'trade_completed')); + + const other = await t.api('/trade/offers', { method: 'GET' }, b.token); + const open = other.body.items[0]; + assert.equal((await t.api('/trade/offers/' + open.id, { method: 'DELETE' }, b.token)).status, 404); + const del = await t.api('/trade/offers/' + open.id, { method: 'DELETE' }, a.token); + assert.equal(del.status, 200); + assert.deepEqual(del.body.returned, { resource: 'capital', amount: 100 }); + + // the Idempotency-Key makes a retried POST safe: one offer, not two + const k = { 'idempotency-key': 'offer-retry-0001' }; + const r1 = await t.api('/trade/offers', { method: 'POST', body: body({ giveAmount: 50, wantAmount: 50 }), headers: k }, a.token); + const r2 = await t.api('/trade/offers', { method: 'POST', body: body({ giveAmount: 50, wantAmount: 50 }), headers: k }, a.token); + assert.equal(r1.body.offer.id, r2.body.offer.id); + assert.equal(t.srv.db.get("SELECT COUNT(*) AS n FROM trade_offers WHERE give_amount = 50").n, 1); + void D; + } finally { await t.close(); } +}); diff --git a/test/trade-flow.test.js b/test/trade-flow.test.js new file mode 100644 index 0000000..9af245d --- /dev/null +++ b/test/trade-flow.test.js @@ -0,0 +1,226 @@ +'use strict'; +/* Internet exchange trade: offers, escrow, accept (two transports), cancel, expire, rules, conservation. Fake clock, in-memory db. */ +const test = require('node:test'); +const assert = require('node:assert'); +const T = require('./military-helpers'); +const { R, D, H } = T; + +// Two traders next to each other with no production at all, so every resource that moves can be counted exactly. +function traders(o) { + o = o || {}; + const h = T.setup(); + const a = T.addOperator(h, 'alice', { x: 5, y: 0, infra: o.aInfra }); + const b = T.addOperator(h, 'bob', { x: 9, y: 0, infra: o.bInfra }); + for (const t of [a, b]) h.db.run("UPDATE buildings SET level = 0 WHERE town_id = ? AND key LIKE 'f%'", t.townId); + return { h, a, b }; +} +const stock = (h, townId) => { const t = T.town(h, townId); return { fiber: t.fiber, hardware: t.hardware, capital: t.capital }; }; +// every unit of every resource in the world: in POPs, in open offers (escrow), on the road +function total(h) { + let sum = 0; + for (const t of h.db.all('SELECT fiber, hardware, capital FROM towns')) sum += t.fiber + t.hardware + t.capital; + for (const o of h.db.all("SELECT give_amount FROM trade_offers WHERE status = 'open'")) sum += o.give_amount; + for (const m of h.db.all("SELECT cargo FROM movements WHERE status = 'out'")) for (const v of Object.values(JSON.parse(m.cargo))) sum += v; + return sum; +} +const post = (h, who, townId, o) => h.run('tradeOffer', Object.assign({ userId: who.userId, townId, giveRes: 'fiber', giveAmount: 400, wantRes: 'hardware', wantAmount: 300, maxDistance: 30 }, o || {})).offer; +const { createTradeQueries } = require('../server/tradeQueries'); +const err = (fn) => { try { fn(); } catch (e) { return e; } assert.fail('expected an error'); }; + +test('trade: post, escrow, accept spawns two transports, both arrive, offer completes; nothing is created or lost', () => { + const { h, a, b } = traders(); + const before = total(h); + const aStart = stock(h, a.townId), bStart = stock(h, b.townId); + + const offer = post(h, a, a.townId); + assert.equal(offer.status, 'open'); + assert.equal(stock(h, a.townId).fiber, aStart.fiber - 400, 'the offered amount left the POP (escrow)'); + assert.equal(total(h), before, 'escrow is counted: conserved'); + assert.equal(h.db.get("SELECT COUNT(*) AS n FROM events WHERE type = 'tradeExpire' AND status = 'pending'").n, 1); + + // bob sees it and can take it + const tq = createTradeQueries(h); + const list = tq.offers(b.userId, {}); + assert.equal(list.items.length, 1); + assert.equal(list.items[0].id, offer.id); + assert.equal(list.items[0].acceptableFrom[0].townId, b.townId); + assert.equal(tq.offers(a.userId, {}).items.length, 0, 'your own offers are not in the market list'); + + const t0 = h.clock.now(); + const acc = h.run('tradeAccept', { userId: b.userId, offerId: offer.id, townId: b.townId }); + assert.equal(acc.status, 'accepted'); + const dist = R.distance(a.x, a.y, b.x, b.y); + assert.equal(acc.arriveAt, t0 + R.transportMs(dist, 1), 'both legs use the transport speed'); + assert.equal(stock(h, b.townId).hardware, bStart.hardware - 300, "the acceptor's payment left at once"); + assert.equal(total(h), before, 'in flight: still conserved'); + const mvs = h.db.all("SELECT * FROM movements WHERE type = 'transport' ORDER BY id"); + assert.equal(mvs.length, 2); + const goods = mvs.find((m) => m.id === acc.goodsMovementId), pay = mvs.find((m) => m.id === acc.paymentMovementId); + assert.equal(goods.from_town_id, a.townId); assert.equal(goods.to_town_id, b.townId); assert.deepEqual(JSON.parse(goods.cargo), { fiber: 400 }); + assert.equal(pay.from_town_id, b.townId); assert.equal(pay.to_town_id, a.townId); assert.deepEqual(JSON.parse(pay.cargo), { hardware: 300 }); + assert.equal(T.notes(h, a.userId, 'trade_accepted').length, 1); + assert.equal(h.db.get('SELECT status FROM trade_offers WHERE id = ?', offer.id).status, 'accepted'); + assert.equal(h.db.get("SELECT status FROM events WHERE type = 'tradeExpire'").status, 'cancelled', 'an accepted offer cannot expire'); + + h.advanceTo(acc.arriveAt); + assert.equal(h.db.get('SELECT status, legs_done FROM trade_offers WHERE id = ?', offer.id).status, 'completed'); + assert.equal(stock(h, a.townId).hardware, aStart.hardware + 300); + assert.equal(stock(h, b.townId).fiber, bStart.fiber + 400); + assert.equal(stock(h, a.townId).fiber, aStart.fiber - 400); + assert.equal(T.notes(h, a.userId, 'trade_completed').length, 1); + assert.equal(T.notes(h, b.userId, 'trade_completed').length, 1); + assert.equal(total(h), before, 'delivered: conserved'); + + // the carriers drive back; the links are free again afterwards + const back = h.db.all("SELECT * FROM movements WHERE type = 'return' AND status = 'out'"); + assert.equal(back.length, 2); + h.advance(10 * H); + assert.equal(require('../server/military/movements').activeLinks(h.db, a.townId), 0); + assert.equal(total(h), before); + assert.equal(h.db.all("SELECT 1 FROM events WHERE status = 'failed'").length, 0); +}); + +test('trade: terms - 1:2 ratio band, capacity, distinct resources, links, resources, ownership', () => { + const { h, a, b } = traders({ aInfra: { internet_exchange: 1 } }); + assert.equal(err(() => post(h, a, a.townId, { giveAmount: 500, wantAmount: 249 })).code, 'trade_ratio'); + assert.equal(err(() => post(h, a, a.townId, { giveAmount: 100, wantAmount: 201 })).code, 'trade_ratio'); + assert.equal(err(() => post(h, a, a.townId, { giveAmount: 500, wantAmount: 501 })).code, 'capacity_exceeded'); + assert.equal(err(() => post(h, a, a.townId, { wantRes: 'fiber' })).code, 'validation_failed'); + assert.equal(err(() => post(h, a, a.townId, { giveRes: 'power' })).code, 'validation_failed'); + assert.equal(err(() => post(h, a, a.townId, { giveAmount: 0 })).code, 'validation_failed'); + assert.equal(err(() => post(h, a, a.townId, { giveAmount: 1.5 })).code, 'validation_failed'); + assert.equal(err(() => post(h, a, a.townId, { maxDistance: 0 })).code, 'validation_failed'); + assert.equal(err(() => post(h, a, a.townId, { maxDistance: D.TRADE.maxDistance + 1 })).code, 'validation_failed'); + assert.equal(err(() => post(h, b, a.townId)).code, 'not_found', 'not your POP'); + assert.equal(post(h, a, a.townId, { giveAmount: 500, wantAmount: 250 }).status, 'open', 'exactly 2:1 is allowed'); + // level 1 exchange = one link, held by the open offer: no second offer and no direct transport meanwhile + assert.equal(err(() => post(h, a, a.townId)).code, 'no_transport_link'); + assert.equal(err(() => h.run('sendTransport', { userId: a.userId, fromTownId: a.townId, toTownId: b.townId, cargo: { fiber: 10 } })).code, 'no_transport_link'); + // a POP without an exchange cannot post + h.db.run("DELETE FROM buildings WHERE town_id = ? AND key = 'internet_exchange'", b.townId); + assert.equal(err(() => post(h, b, b.townId)).code, 'no_transport_link'); + // not enough of the offered resource + const c = T.addOperator(h, 'cat', { x: 14, y: 0, res: 100 }); + assert.equal(err(() => post(h, c, c.townId)).code, 'not_enough_resources'); +}); + +test('trade: accept rules - own offer, closed, range, exchange, cannot afford (atomic), links', () => { + const { h, a, b } = traders(); + const c = T.addOperator(h, 'cat', { x: 40, y: 0 }); // 35 tiles from alice + const d = T.addOperator(h, 'dan', { x: 12, y: 0, infra: { internet_exchange: 0 } }); + h.db.run("DELETE FROM buildings WHERE town_id = ? AND key = 'internet_exchange'", d.townId); + const offer = post(h, a, a.townId, { maxDistance: 12 }); + + assert.equal(err(() => h.run('tradeAccept', { userId: a.userId, offerId: offer.id, townId: a.townId })).code, 'own_offer'); + assert.equal(err(() => h.run('tradeAccept', { userId: c.userId, offerId: offer.id, townId: c.townId })).code, 'trade_out_of_range', 'beyond the offer\'s max distance'); + assert.equal(err(() => h.run('tradeAccept', { userId: d.userId, offerId: offer.id, townId: d.townId })).code, 'no_transport_link', 'no Internet exchange'); + assert.equal(err(() => h.run('tradeAccept', { userId: b.userId, offerId: 999, townId: b.townId })).code, 'not_found'); + assert.equal(err(() => h.run('tradeAccept', { userId: b.userId, offerId: offer.id, townId: a.townId })).code, 'not_found', 'not your POP'); + + // reach: a level-1 exchange sees 10 tiles + const far = T.addOperator(h, 'far', { x: 20, y: 0, infra: { internet_exchange: 1 } }); // 15 tiles from alice, within the offer's 30 below + const wide = post(h, a, a.townId, { maxDistance: 30, giveAmount: 100, wantAmount: 100 }); + assert.equal(err(() => h.run('tradeAccept', { userId: far.userId, offerId: wide.id, townId: far.townId })).code, 'trade_out_of_range'); + const seen = createTradeQueries(h).offers(far.userId, {}); + assert.equal(seen.items.length, 0, 'out of reach: not even listed'); + assert.equal(seen.exchangeLevels[0].reach, 10); + + // bob cannot pay: nothing changes (all or nothing) + h.db.run('UPDATE towns SET hardware = 100 WHERE id = ?', b.townId); + const snap = JSON.stringify([stock(h, a.townId), stock(h, b.townId), h.db.all('SELECT * FROM movements'), h.db.all('SELECT status FROM trade_offers ORDER BY id')]); + assert.equal(err(() => h.run('tradeAccept', { userId: b.userId, offerId: offer.id, townId: b.townId })).code, 'not_enough_resources'); + assert.equal(JSON.stringify([stock(h, a.townId), stock(h, b.townId), h.db.all('SELECT * FROM movements'), h.db.all('SELECT status FROM trade_offers ORDER BY id')]), snap, 'a failed accept leaves no trace'); + // no free link for bob (level 3, three running transports) + h.db.run('UPDATE towns SET hardware = 1000 WHERE id = ?', b.townId); + for (let i = 0; i < 3; i++) h.run('sendTransport', { userId: b.userId, fromTownId: b.townId, toTownId: c.townId, cargo: { capital: 10 } }); + assert.equal(err(() => h.run('tradeAccept', { userId: b.userId, offerId: offer.id, townId: b.townId })).code, 'no_transport_link'); + assert.equal(h.db.get('SELECT status FROM trade_offers WHERE id = ?', offer.id).status, 'open'); +}); + +test('trade: cancel returns the escrow, closed offers cannot be taken, strangers cannot cancel', () => { + const { h, a, b } = traders(); + const start = stock(h, a.townId), before = total(h); + const offer = post(h, a, a.townId); + assert.equal(err(() => h.run('tradeCancel', { userId: b.userId, offerId: offer.id })).code, 'not_found'); + const r = h.run('tradeCancel', { userId: a.userId, offerId: offer.id }); + assert.deepEqual(r.returned, { resource: 'fiber', amount: 400 }); + assert.deepEqual(stock(h, a.townId), start); + assert.equal(total(h), before); + assert.equal(h.db.get("SELECT status FROM events WHERE type = 'tradeExpire'").status, 'cancelled'); + assert.equal(err(() => h.run('tradeAccept', { userId: b.userId, offerId: offer.id, townId: b.townId })).code, 'offer_closed'); + assert.equal(err(() => h.run('tradeCancel', { userId: a.userId, offerId: offer.id })).code, 'offer_closed'); + assert.equal(require('../server/military/movements').activeLinks(h.db, a.townId), 0, 'the reserved link is free again'); +}); + +test('trade: an offer expires after its ttl (divided by world speed) and returns the escrow exactly once', () => { + for (const speed of [1, 4]) { + const h = T.setup({ speed }); + const a = T.addOperator(h, 'alice', { x: 5, y: 0 }); + h.db.run("UPDATE buildings SET level = 0 WHERE town_id = ? AND key LIKE 'f%'", a.townId); + const start = stock(h, a.townId); + const offer = h.run('tradeOffer', { userId: a.userId, townId: a.townId, giveRes: 'capital', giveAmount: 250, wantRes: 'fiber', wantAmount: 400, maxDistance: 20 }).offer; + assert.equal(offer.expiresAt - h.clock.now(), D.TRADE.ttlHours * H / speed); + h.advanceTo(offer.expiresAt - 1); + assert.equal(h.db.get('SELECT status FROM trade_offers WHERE id = ?', offer.id).status, 'open'); + h.advanceTo(offer.expiresAt); + assert.equal(h.db.get('SELECT status FROM trade_offers WHERE id = ?', offer.id).status, 'expired'); + assert.deepEqual(stock(h, a.townId), start); + assert.equal(T.notes(h, a.userId, 'trade_expired').length, 1); + // running the handler again (idempotence) does not pay twice + require('../server/events/tradeExpire')(Object.assign(h.ctx(), { now: offer.expiresAt }), { id: 0, worldId: h.worldId, dueAt: offer.expiresAt, payload: { offerId: offer.id } }); + assert.deepEqual(stock(h, a.townId), start); + } +}); + +test('trade: a delivery above the receiver\'s storage cap loses exactly the overflow (and says so); the rest is conserved', () => { + const { h, a, b } = traders({ bInfra: { rack_hall: 1 } }); // cap 1000 + h.db.run('UPDATE towns SET fiber = 900 WHERE id = ?', b.townId); + const before = total(h); + const offer = post(h, a, a.townId); + const acc = h.run('tradeAccept', { userId: b.userId, offerId: offer.id, townId: b.townId }); + h.advanceTo(acc.arriveAt); + assert.equal(stock(h, b.townId).fiber, 1000); + const arrived = T.notes(h, b.userId, 'transport_arrived')[0]; + assert.deepEqual(arrived.cargoLost, { fiber: 300 }); + assert.equal(total(h) + 300, before, 'every unit is somewhere, except the 300 that did not fit and were reported lost'); + assert.equal(h.db.get('SELECT status FROM trade_offers WHERE id = ?', offer.id).status, 'completed'); +}); + +test('trade: a POP that changes hands voids its open offers; the escrow stays in the POP', () => { + const { h, a, b } = traders(); + const offer = post(h, a, a.townId); + const before = total(h); + const combat = require('../server/military/combat'); + const town = require('../server/state').loadTown(h.db, a.townId); + h.db.tx(() => combat.transferTown(h.ctx(), town, { id: b.opId, name: 'bob' }, { id: a.opId, name: 'alice' }, h.clock.now())); + assert.equal(h.db.get('SELECT status FROM trade_offers WHERE id = ?', offer.id).status, 'void'); + assert.equal(T.town(h, a.townId).owner_id, b.opId); + assert.equal(T.town(h, a.townId).fiber, 4000, "the escrow is back in the POP, now bob's"); + assert.equal(total(h), before, 'nothing created or lost'); + assert.equal(err(() => h.run('tradeAccept', { userId: b.userId, offerId: offer.id, townId: b.townId })).code, 'offer_closed'); + assert.equal(h.db.get("SELECT status FROM events WHERE type = 'tradeExpire'").status, 'cancelled'); + assert.equal(T.notes(h, a.userId, 'trade_void').length, 1); +}); + +test('trade list: pages through offers that are out of reach (chunked read), cursor and filters stay right', () => { + const saved = D.TRADE.scanChunk; + D.TRADE.scanChunk = 2; + try { + const h = T.setup(); + const p = T.addOperator(h, 'poster', { x: 5, y: 0, infra: { internet_exchange: 10 } }); + const v = T.addOperator(h, 'viewer', { x: 9, y: 0 }); // 4 tiles away, exchange 3 (reach 30) + for (const q of [p, v]) h.db.run("UPDATE buildings SET level = 0 WHERE town_id = ? AND key LIKE 'f%'", q.townId); + const ids = []; + for (const [md, amt] of [[2, 10], [10, 20], [2, 30], [2, 40], [10, 50], [3, 60], [10, 70]]) ids.push(post(h, p, p.townId, { maxDistance: md, giveAmount: amt, wantAmount: amt }).id); + const tq = createTradeQueries(h); + const visible = [ids[1], ids[4], ids[6]]; // maxDistance >= 4 + const p1 = tq.offers(v.userId, { limit: 2 }); + assert.deepEqual(p1.items.map((o) => o.id), [visible[2], visible[1]]); + assert.equal(p1.next, visible[1]); + const p2 = tq.offers(v.userId, { limit: 2, after: p1.next }); + assert.deepEqual(p2.items.map((o) => o.id), [visible[0]]); + assert.equal(p2.next, null); + assert.equal(tq.offers(v.userId, { limit: 10 }).items.length, 3); + assert.deepEqual(tq.offers(v.userId, { limit: 10, give: 'capital' }).items, []); + } finally { D.TRADE.scanChunk = saved; } +});