// In-browser stand-in for the backend, used while MOCK_SERVER is on. It answers the same // WS intents with the same payload shapes, keeps its state in localStorage, finishes // build orders on timers and pushes `village:updated`, so the UI behaves as it will live. // Its rules are deliberately crude; nothing here is meant to survive into the backend. import { onUnmounted, ref } from 'vue' import type { AuthResult, AuthUser, BuildOption, BuildOrder, Building, BuildingType, Cost, GameError, MilitaryBuilding, Offer, Resource, Resources, UnitType, VillageState, WorldSummary, } from '~/types/game' import type { MapVillage, MapView } from '~/types/map' import type { GameAuth, GameWs } from '~/utils/networking' import { BASE_TRICKLE, BUILDERS, BUILDING_TYPES, CATALOG, DEFAULT_PRIORITY, DEMOLISH_REFUND, MAX_SPACE, SPACE_PER_HQ_LEVEL, MAX_LEVEL, START_RESOURCES, UNITS, UNIT_TYPES, VILLAGER_UPKEEP, atLevel, } from './catalog' interface MockBuilding { id: number type: BuildingType level: number priority: number } interface MockOrder { id: number building_id: number | null type: BuildingType action: BuildOrder['action'] target_level: number cost: Cost seconds: number builder: number | null starts_at: number | null finishes_at: number | null } interface MockVillage { id: number world_id: number user_id: number name: string x: number y: number /** Base building space; the headquarters level adds to it. */ space_max: number resources: Resources resources_at: number buildings: MockBuilding[] orders: MockOrder[] /** Missing in states stored before recruiting existed. */ troops?: Partial> recruits?: MockRecruit[] militia?: number levy_until?: number | null } /** Mock levy length; the backend's comes from the world config. */ const LEVY_SECONDS = 120 interface MockRecruit { id: number building_id: number unit: UnitType count: number done: number seconds_per_unit: number /** Per unit. */ cost: Cost starts_at: number finishes_at: number } interface MockState { seq: number token: string | null users: AuthUser[] villages: MockVillage[] } const STORAGE_KEY = 'vp.mock.v3' const LATENCY_MS = 60 const WORLDS = [ { id: 1, name: 'World 1', slug: 'w1', speed: 1 }, { id: 2, name: 'Dev world', slug: 'dev', speed: 100 }, ] const RESOURCES: Resource[] = ['wood', 'clay', 'iron', 'food'] function fail(code: string): never { throw { code, message: code } satisfies GameError } const delay = () => new Promise((resolve) => setTimeout(resolve, LATENCY_MS)) const iso = (ms: number) => new Date(ms).toISOString() const round = (n: number) => Math.round(n * 100) / 100 const mapCost = (cost: Cost, fn: (n: number) => number): Cost => ({ wood: fn(cost.wood), clay: fn(cost.clay), iron: fn(cost.iron), }) // State lives in localStorage and is re-read per request, so several tabs stay in step. function load(): MockState { try { const raw = localStorage.getItem(STORAGE_KEY) if (raw) return JSON.parse(raw) // v2 counted levels from 0: shift buildings and queued orders up by one. const old = localStorage.getItem('vp.mock.v2') if (old) { const state: MockState = JSON.parse(old) for (const v of state.villages) { v.buildings.forEach((b) => b.level++) v.orders.forEach((o) => o.target_level++) } return state } } catch { // fall through to a fresh state } return { seq: 1, token: null, users: [], villages: [] } } function save(state: MockState) { try { localStorage.setItem(STORAGE_KEY, JSON.stringify(state)) } catch { // private mode: the mock just forgets on reload } } const nextId = (state: MockState) => state.seq++ // Village rules, crude stand-ins for app/Game/. const levelCost = (type: BuildingType, level: number) => mapCost(CATALOG[type].cost, (n) => atLevel(n, level)) const levelSeconds = (type: BuildingType, level: number) => atLevel(CATALOG[type].seconds, level) const requiredWorkers = (b: MockBuilding) => atLevel(CATALOG[b.type].workers, b.level) function foodBudget(v: MockVillage) { return v.buildings .filter((b) => b.type === 'farm') .reduce((sum, b) => sum + atLevel(CATALOG.farm.production!.per_hour, b.level), 0) } /** Food the troops and the units in training eat; it comes out of the villagers' share. */ function soldierUpkeep(v: MockVillage) { const home = Object.entries(v.troops ?? {}).reduce((sum, [unit, n]) => sum + UNITS[unit as UnitType].upkeep * (n ?? 0), 0) return home + (v.recruits ?? []).reduce((sum, o) => sum + UNITS[o.unit].upkeep * (o.count - o.done), 0) } function villagers(v: MockVillage) { return Math.max(0, Math.floor((foodBudget(v) - soldierUpkeep(v)) / VILLAGER_UPKEEP)) } /** Drafted villagers, never more than there are. */ const militia = (v: MockVillage) => Math.min(v.militia ?? 0, villagers(v)) /** Farms first, then by priority, then oldest first. */ function assignWorkers(v: MockVillage) { let free = villagers(v) - militia(v) const assigned = new Map() const order = [...v.buildings].sort( (a, b) => Number(b.type === 'farm') - Number(a.type === 'farm') || b.priority - a.priority || a.id - b.id, ) for (const b of order) { const n = Math.min(requiredWorkers(b), free) assigned.set(b.id, n) free -= n } return assigned } const staffing = (b: MockBuilding, assigned: Map) => { const required = requiredWorkers(b) return required === 0 ? 1 : (assigned.get(b.id) ?? 0) / required } /** Linear stand-in for the real staffing curve: empty buildings still make 10%. */ const outputFactor = (ratio: number) => 0.1 + 0.9 * ratio function production(b: MockBuilding, assigned: Map) { const prod = CATALOG[b.type].production if (!prod) return null return { resource: prod.resource, per_hour: atLevel(prod.per_hour, b.level) * outputFactor(staffing(b, assigned)) } } function rates(v: MockVillage): Resources { const assigned = assignWorkers(v) const r: Resources = { wood: BASE_TRICKLE, clay: BASE_TRICKLE, iron: BASE_TRICKLE, food: 0 } for (const b of v.buildings) { const p = production(b, assigned) if (p) r[p.resource] += p.per_hour } r.food -= villagers(v) * VILLAGER_UPKEEP + soldierUpkeep(v) return r } function storageCap(v: MockVillage) { return v.buildings .filter((b) => b.type === 'storage') .reduce((sum, b) => sum + atLevel(CATALOG.storage.capacity!, b.level), 0) } /** stored + rate × elapsed, written back into the village. */ function settle(v: MockVillage, at: number) { const r = rates(v) const cap = storageCap(v) const hours = (at - v.resources_at) / 3_600_000 for (const res of RESOURCES) { v.resources[res] = Math.min(cap, Math.max(0, v.resources[res] + r[res] * hours)) } v.resources_at = at } const canPay = (v: MockVillage, cost: Cost) => v.resources.wood >= cost.wood && v.resources.clay >= cost.clay && v.resources.iron >= cost.iron function pay(v: MockVillage, cost: Cost) { if (!canPay(v, cost)) fail('resources') v.resources.wood -= cost.wood v.resources.clay -= cost.clay v.resources.iron -= cost.iron } function refund(v: MockVillage, amount: Cost) { const cap = storageCap(v) v.resources.wood = Math.min(cap, v.resources.wood + amount.wood) v.resources.clay = Math.min(cap, v.resources.clay + amount.clay) v.resources.iron = Math.min(cap, v.resources.iron + amount.iron) } /** Building space taken by buildings and by queued new buildings. */ function spaceUsed(v: MockVillage) { return ( v.buildings.reduce((sum, b) => sum + CATALOG[b.type].space, 0) + v.orders.filter((o) => o.action === 'build').reduce((sum, o) => sum + CATALOG[o.type].space, 0) ) } const spaceMax = (v: MockVillage) => Math.min(v.space_max, MAX_SPACE) + SPACE_PER_HQ_LEVEL * Math.max(0, (v.buildings.find((b) => b.type === 'headquarters')?.level ?? 1) - 1) const spaceFits = (v: MockVillage, type: BuildingType) => spaceUsed(v) + CATALOG[type].space <= spaceMax(v) /** Level after everything already queued for this building; 0 if it is being removed. */ function queuedLevel(v: MockVillage, b: MockBuilding) { const last = v.orders.filter((o) => o.building_id === b.id).at(-1) return last ? last.target_level : b.level } const instances = (v: MockVillage, type: BuildingType) => v.buildings.filter((b) => b.type === type).length + v.orders.filter((o) => o.action === 'build' && o.type === type).length const isCore = (v: MockVillage, b: MockBuilding) => b.type === 'headquarters' || ((b.type === 'storage' || b.type === 'farm') && v.buildings.filter((o) => o.type === b.type).length === 1) function upgradeOffer(v: MockVillage, b: MockBuilding): Offer | null { const current = queuedLevel(v, b) if (current < 1 || current >= MAX_LEVEL) return null const target = current + 1 const cost = levelCost(b.type, target) return { target_level: target, cost, seconds: levelSeconds(b.type, target), blocked: null } } function demolishOffer(v: MockVillage, b: MockBuilding) { const current = queuedLevel(v, b) if (current < 1 || (current === 1 && isCore(v, b))) return null return { target_level: current - 1, refund: mapCost(levelCost(b.type, current), (n) => Math.floor(n * DEMOLISH_REFUND)), seconds: Math.ceil(levelSeconds(b.type, current) / 2), } } function buildOptions(v: MockVillage): BuildOption[] { return BUILDING_TYPES.map((type) => { const entry = CATALOG[type] const cost = levelCost(type, 1) const blocked = entry.max_per_village !== null && instances(v, type) >= entry.max_per_village ? 'max_per_village' : !spaceFits(v, type) ? 'no_space' : null return { type, space: entry.space, target_level: 1, cost, seconds: levelSeconds(type, 1), blocked, requires: [] } }) } // Build queue: a free builder takes the first waiting order whose building has no earlier order. function startWaiting(v: MockVillage, at: number) { const running = v.orders.filter((o) => o.builder !== null) const busy = new Set(running.map((o) => o.builder)) const blockedBuildings = new Set(running.map((o) => o.building_id).filter((id) => id !== null)) for (const o of v.orders) { if (o.builder !== null) continue if (o.building_id !== null) { if (blockedBuildings.has(o.building_id)) continue blockedBuildings.add(o.building_id) } const builder = Array.from({ length: BUILDERS }, (_, i) => i + 1).find((n) => !busy.has(n)) if (builder === undefined) break busy.add(builder) o.builder = builder o.starts_at = at o.finishes_at = at + o.seconds * 1000 } } function finish(state: MockState, v: MockVillage, o: MockOrder) { if (o.action === 'build') { v.buildings.push({ id: nextId(state), type: o.type, level: 1, priority: DEFAULT_PRIORITY }) return } const b = v.buildings.find((b) => b.id === o.building_id) if (!b) return if (o.action === 'demolish') { refund(v, mapCost(levelCost(b.type, b.level), (n) => Math.floor(n * DEMOLISH_REFUND))) } b.level = o.target_level if (b.level < 1) { v.buildings = v.buildings.filter((x) => x !== b) // Units still in training there go back to work, refunded. for (const r of (v.recruits ?? []).filter((r) => r.building_id === b.id)) { refund(v, mapCost(r.cost, (n) => n * (r.count - r.done))) } v.recruits = (v.recruits ?? []).filter((r) => r.building_id !== b.id) } } // Recruiting: each military building trains its own queue, one unit after another. const doneAt = (o: MockRecruit, at: number) => Math.min(o.count, Math.max(o.done, Math.floor((at - o.starts_at) / (o.seconds_per_unit * 1000)))) /** Move units trained by `at` into the village and drop finished orders. */ function settleRecruits(v: MockVillage, at: number) { v.troops ??= {} for (const o of v.recruits ?? []) { const done = doneAt(o, at) v.troops[o.unit] = (v.troops[o.unit] ?? 0) + done - o.done o.done = done } v.recruits = (v.recruits ?? []).filter((o) => o.done < o.count) } function missingRequirements(v: MockVillage, unit: UnitType) { return Object.entries(UNITS[unit].requires) .filter(([type, level]) => !v.buildings.some((b) => b.type === type && b.level >= (level ?? 0))) .map(([type, level]) => ({ type: type as BuildingType, level: level ?? 0 })) } const secondsPerUnit = (b: MockBuilding, unit: UnitType) => Math.max(1, Math.ceil(UNITS[unit].seconds / (1 + 0.05 * Math.max(0, b.level - 1)))) function military(v: MockVillage, at: number): MilitaryBuilding[] { const pop = villagers(v) - militia(v) return v.buildings .filter((b) => UNIT_TYPES.some((u) => UNITS[u].building === b.type)) .map((b) => ({ building_id: b.id, type: b.type, level: b.level, units: UNIT_TYPES.filter((u) => UNITS[u].building === b.type).map((unit) => { const { cost, upkeep } = UNITS[unit] const requires = missingRequirements(v, unit) const byResources = Math.min(...(['wood', 'clay', 'iron'] as const).map((r) => Math.floor(v.resources[r] / cost[r]))) return { unit, cost, seconds: secondsPerUnit(b, unit), upkeep, max: requires.length ? 0 : Math.max(0, Math.min(byResources, Math.floor(pop / upkeep))), blocked: requires.length ? ('requires' as const) : null, requires, } }), queue: (v.recruits ?? []) .filter((o) => o.building_id === b.id) .map((o) => ({ id: o.id, unit: o.unit, count: o.count, done: doneAt(o, at), seconds_per_unit: o.seconds_per_unit, starts_at: iso(o.starts_at), finishes_at: iso(o.finishes_at), })), })) } /** Process every order that finished before `now`, in order, then settle to `now`. */ function catchUp(state: MockState, v: MockVillage, now: number) { for (;;) { const due = v.orders .filter((o) => o.finishes_at !== null && o.finishes_at <= now) .sort((a, b) => a.finishes_at! - b.finishes_at! || a.id - b.id)[0] const levyEnds = v.levy_until != null && v.levy_until <= now ? v.levy_until : null if (levyEnds !== null && (!due || levyEnds <= due.finishes_at!)) { settle(v, levyEnds) v.militia = 0 v.levy_until = null continue } if (!due) break settle(v, due.finishes_at!) v.orders = v.orders.filter((o) => o !== due) settleRecruits(v, due.finishes_at!) finish(state, v, due) startWaiting(v, due.finishes_at!) } settleRecruits(v, now) settle(v, now) } function enqueue(state: MockState, v: MockVillage, order: Omit, now: number) { v.orders.push({ ...order, id: nextId(state), builder: null, starts_at: null, finishes_at: null }) startWaiting(v, now) } /** Only the warnings: the mock never makes soldiers desert. */ function starvation(v: MockVillage) { const rate = rates(v).food const empty = v.resources.food <= 0.001 return { food_empty_at: rate < 0 && !empty ? iso(v.resources_at + (v.resources.food / -rate) * 3_600_000) : null, since: rate < 0 && empty ? iso(v.resources_at) : null, desertion_at: null, } } function view(v: MockVillage, now: number): VillageState { const assigned = assignWorkers(v) const pop = villagers(v) return { id: v.id, world_id: v.world_id, name: v.name, x: v.x, y: v.y, continent: continentOf(v.x, v.y), points: points(v), space: { used: spaceUsed(v), max: spaceMax(v) }, resources: { ...v.resources }, resources_at: iso(v.resources_at), rates: rates(v), storage_cap: storageCap(v), population: { food_budget: foodBudget(v), upkeep: pop * VILLAGER_UPKEEP + soldierUpkeep(v), villagers: pop, workers: [...assigned.values()].reduce((a, b) => a + b, 0), soldiers: Object.values(v.troops ?? {}).reduce((a, b) => a + (b ?? 0), 0), training: (v.recruits ?? []).reduce((sum, o) => sum + o.count - o.done, 0), }, levy: { militia: militia(v), until: v.levy_until ? iso(v.levy_until) : null, seconds: LEVY_SECONDS }, starvation: starvation(v), troops: Object.fromEntries(Object.entries(v.troops ?? {}).filter(([, n]) => n)), military: military(v, now), builders: BUILDERS, buildings: v.buildings.map( (b): Building => { const p = production(b, assigned) return { id: b.id, type: b.type, level: b.level, space: CATALOG[b.type].space, priority: b.priority, workers: { assigned: assigned.get(b.id) ?? 0, required: requiredWorkers(b) }, staffing: staffing(b, assigned), production: p ? { resource: p.resource, per_hour: round(p.per_hour) } : null, upgrade: upgradeOffer(v, b), demolish: demolishOffer(v, b), } }, ), queue: v.orders.map((o, i) => ({ id: o.id, building_id: o.building_id, type: o.type, action: o.action, target_level: o.target_level, space: CATALOG[o.type].space, cost: o.cost, position: i + 1, builder: o.builder, starts_at: o.starts_at === null ? null : iso(o.starts_at), finishes_at: o.finishes_at === null ? null : iso(o.finishes_at), })), buildable: buildOptions(v), server_time: iso(now), } } const continentOf = (x: number, y: number) => `K${Math.floor(y / 100)}${Math.floor(x / 100)}` /** Placeholder points: 5 per building level. */ const points = (v: MockVillage) => v.buildings.reduce((sum, b) => sum + 5 * b.level, 0) /** Mock map: the stored player villages plus barbarians made up from a hash of the field. */ function mapView(state: MockState, user: AuthUser, data: any): MapView { const size = 1000 const own = state.villages.find((v) => v.world_id === Number(data.world_id) && v.user_id === user.id) const cx = Number.isFinite(Number(data.x)) && data.x !== undefined ? Number(data.x) : (own?.x ?? 500) const cy = Number.isFinite(Number(data.y)) && data.y !== undefined ? Number(data.y) : (own?.y ?? 500) const w = Math.max(1, Math.min(41, Number(data.w) || 15)) const h = Math.max(1, Math.min(41, Number(data.h) || 15)) const x0 = Math.max(0, Math.min(size - w, cx - Math.floor(w / 2))) const y0 = Math.max(0, Math.min(size - h, cy - Math.floor(h / 2))) const villages: MapVillage[] = [] for (let y = y0; y < y0 + h; y++) { for (let x = x0; x < x0 + w; x++) { const player = state.villages.find((v) => v.world_id === Number(data.world_id) && v.x === x && v.y === y) if (player) { const owner = state.users.find((u) => u.id === player.user_id) villages.push({ id: player.id, x, y, name: player.name, points: points(player), continent: continentOf(x, y), player: { id: player.user_id, name: owner?.name ?? '?' }, own: player.user_id === user.id, }) continue } const r = (Math.imul(x * 73856093 ^ y * 19349663, 1274126177) >>> 0) / 4294967296 const near = Math.abs(x - 500) <= 25 && Math.abs(y - 500) <= 25 if (near && r < 0.08) { villages.push({ id: -(y * size + x), x, y, name: 'Barbarian village', points: 20 + Math.floor(r * 1000), continent: continentOf(x, y), player: null, own: false, }) } } } return { world_id: Number(data.world_id), size, center: { x: cx, y: cy }, x: x0, y: y0, w, h, villages } } function createVillage(state: MockState, user: AuthUser, worldId: number, now: number): MockVillage { const taken = new Set(state.villages.filter((v) => v.world_id === worldId).map((v) => `${v.x}|${v.y}`)) let x = 500 let y = 500 while (taken.has(`${x}|${y}`)) { x = 475 + Math.floor(Math.random() * 51) y = 475 + Math.floor(Math.random() * 51) } const v: MockVillage = { id: nextId(state), world_id: worldId, user_id: user.id, name: `${user.name}'s village`, x, y, space_max: MAX_SPACE, resources: { ...START_RESOURCES }, resources_at: now, buildings: [], orders: [], } for (const type of ['headquarters', 'storage', 'farm'] as const) { v.buildings.push({ id: nextId(state), type, level: 1, priority: DEFAULT_PRIORITY }) } return v } // WS intents. type Handler = (state: MockState, user: AuthUser, data: any, now: number) => unknown function ownVillage(state: MockState, user: AuthUser, id: unknown, now: number) { const v = state.villages.find((v) => v.id === Number(id) && v.user_id === user.id) if (!v) fail('not_found') catchUp(state, v, now) return v } function ownBuilding(v: MockVillage, id: unknown) { return v.buildings.find((b) => b.id === Number(id)) ?? fail('not_found') } const handlers: Record = { 'world.index': (state, user): WorldSummary[] => WORLDS.map((w) => ({ ...w, village_id: state.villages.find((v) => v.world_id === w.id && v.user_id === user.id)?.id ?? null, })), 'world.join': (state, user, data, now) => { const world = WORLDS.find((w) => w.id === Number(data.world_id)) ?? fail('not_found') let v = state.villages.find((v) => v.world_id === world.id && v.user_id === user.id) if (!v) { v = createVillage(state, user, world.id, now) state.villages.push(v) } return { village_id: v.id } }, 'village.show': (state, user, data, now) => view(ownVillage(state, user, data.village_id, now), now), 'map.view': (state, user, data) => mapView(state, user, data), 'village.build': (state, user, data, now) => { const v = ownVillage(state, user, data.village_id, now) const type = data.type as BuildingType const entry = CATALOG[type] ?? fail('not_found') if (entry.max_per_village !== null && instances(v, type) >= entry.max_per_village) fail('max_per_village') if (!spaceFits(v, type)) fail('no_space') const cost = levelCost(type, 1) pay(v, cost) enqueue(state, v, { building_id: null, type, action: 'build', target_level: 1, cost, seconds: levelSeconds(type, 1) }, now) return view(v, now) }, 'village.upgrade': (state, user, data, now) => { const v = ownVillage(state, user, data.village_id, now) const b = ownBuilding(v, data.building_id) const offer = upgradeOffer(v, b) ?? fail('max_level') pay(v, offer.cost) enqueue(state, v, { building_id: b.id, type: b.type, action: 'upgrade', target_level: offer.target_level, cost: offer.cost, seconds: offer.seconds }, now) return view(v, now) }, 'village.demolish': (state, user, data, now) => { const v = ownVillage(state, user, data.village_id, now) const b = ownBuilding(v, data.building_id) const offer = demolishOffer(v, b) ?? fail('core_building') enqueue(state, v, { building_id: b.id, type: b.type, action: 'demolish', target_level: offer.target_level, cost: { wood: 0, clay: 0, iron: 0 }, seconds: offer.seconds }, now) return view(v, now) }, // Cancelling also cancels later orders for the same building, since they build on it. 'village.cancel': (state, user, data, now) => { const v = ownVillage(state, user, data.village_id, now) const order = v.orders.find((o) => o.id === Number(data.order_id)) ?? fail('not_found') const index = v.orders.indexOf(order) const cancelled = v.orders.filter( (o, i) => o === order || (i > index && order.building_id !== null && o.building_id === order.building_id), ) v.orders = v.orders.filter((o) => !cancelled.includes(o)) cancelled.forEach((o) => refund(v, o.cost)) startWaiting(v, now) return view(v, now) }, 'village.staff': (state, user, data, now) => { const v = ownVillage(state, user, data.village_id, now) const b = ownBuilding(v, data.building_id) b.priority = Math.min(9, Math.max(0, Math.round(Number(data.priority) || 0))) return view(v, now) }, 'village.recruit': (state, user, data, now) => { const v = ownVillage(state, user, data.village_id, now) const b = ownBuilding(v, data.building_id) const unit = data.unit as UnitType const entry = UNITS[unit] if (!entry || entry.building !== b.type) fail('not_found') const count = Math.floor(Number(data.count) || 0) if (count < 1) fail('count') if (missingRequirements(v, unit).length) fail('requires') if (count * entry.upkeep > villagers(v) - militia(v)) fail('villagers') pay(v, mapCost(entry.cost, (n) => n * count)) const seconds = secondsPerUnit(b, unit) const last = (v.recruits ?? []).filter((o) => o.building_id === b.id).at(-1) const starts = last && last.finishes_at > now ? last.finishes_at : now v.recruits = [ ...(v.recruits ?? []), { id: nextId(state), building_id: b.id, unit, count, done: 0, seconds_per_unit: seconds, cost: entry.cost, starts_at: starts, finishes_at: starts + seconds * count * 1000 }, ] return view(v, now) }, // Refunds the untrained units; later orders at the same building move up. 'village.cancelRecruit': (state, user, data, now) => { const v = ownVillage(state, user, data.village_id, now) const order = (v.recruits ?? []).find((o) => o.id === Number(data.order_id)) ?? fail('not_found') refund(v, mapCost(order.cost, (n) => n * (order.count - order.done))) v.recruits = (v.recruits ?? []).filter((o) => o !== order) let from = now for (const o of v.recruits.filter((o) => o.building_id === order.building_id)) { if (o.id < order.id) { from = Math.max(now, o.finishes_at) continue } o.starts_at = from o.finishes_at = from + o.seconds_per_unit * o.count * 1000 from = o.finishes_at } return view(v, now) }, 'village.levy': (state, user, data, now) => { const v = ownVillage(state, user, data.village_id, now) const count = Math.floor(Number(data.count) || 0) if (v.militia) fail('levy_active') if (count < 1) fail('count') if (count > villagers(v)) fail('villagers') v.militia = count v.levy_until = now + LEVY_SECONDS * 1000 return view(v, now) }, 'village.endLevy': (state, user, data, now) => { const v = ownVillage(state, user, data.village_id, now) if (!v.militia) fail('not_found') v.militia = 0 v.levy_until = null return view(v, now) }, 'mock.reset': (state, user) => { state.villages = state.villages.filter((v) => v.user_id !== user.id) return true }, } export function createMockServer(): { ws: GameWs; auth: GameAuth } { const bus = new EventTarget() const timers = new Map>() const emit = (event: string, data: unknown) => bus.dispatchEvent(new CustomEvent(event, { detail: { event, data, channel: 'websocket' } })) // Fire `village:updated` when a village's next order finishes, like the game:events worker. function schedule(state: MockState) { for (const v of state.villages) { clearTimeout(timers.get(v.id)) const next = Math.min( ...v.orders.map((o) => o.finishes_at ?? Infinity), ...(v.recruits ?? []).map((o) => o.finishes_at), v.levy_until ?? Infinity, ) if (next === Infinity) continue timers.set( v.id, setTimeout(() => { const fresh = load() const village = fresh.villages.find((x) => x.id === v.id) if (!village) return catchUp(fresh, village, Date.now()) save(fresh) schedule(fresh) emit('village:updated', { village_id: v.id }) }, Math.max(0, next - Date.now()) + 20), ) } } function currentUser(state: MockState) { return state.users.find((u) => state.token === `mock-${u.id}`) ?? fail('unauthenticated') } function signIn(state: MockState, user: AuthUser): AuthResult { state.token = `mock-${user.id}` save(state) return { token: state.token, user } } function addUser(state: MockState, name: string, email: string) { const user = { id: nextId(state), name, email } state.users.push(user) return user } function listen(event: string, _channel: string | null | undefined, callback: (data: any) => void) { const handler = (e: Event) => callback((e as CustomEvent).detail.data) bus.addEventListener(event, handler) return () => bus.removeEventListener(event, handler) } const ws: GameWs = { is_setup: ref(true), is_opened: ref(true), resetConnection() {}, listen, listenWhileMounted(event, channel, callback) { const off = listen(event, channel, callback) onUnmounted(off) return off }, async send(event: string, data: object = {}): Promise { await delay() const handler = handlers[event] ?? fail('not_found') const state = load() const now = Date.now() const result = handler(state, currentUser(state), data, now) save(state) schedule(state) return structuredClone(result) as T }, } const auth: GameAuth = { token: () => load().token, async login(email, password) { await delay() if (!email || !password) fail('invalid_credentials') const state = load() const user = state.users.find((u) => u.email.toLowerCase() === email.toLowerCase()) ?? addUser(state, email.split('@')[0] || email, email) return signIn(state, user) }, async register(name, email, password) { await delay() if (!name || !email || !password) fail('invalid_credentials') const state = load() if (state.users.some((u) => u.email.toLowerCase() === email.toLowerCase())) fail('email_taken') return signIn(state, addUser(state, name, email)) }, logout() { const state = load() state.token = null save(state) }, } return { ws, auth } }