game-village-politics-frontend/app/mock/market.ts

518 lines
23 KiB
TypeScript
Raw Permalink Normal View History

// The mock's market: merchants, deliveries, offers and trade routes, a crude stand-in for
// the backend's market. Its numbers are placeholders; the backend is the source of truth.
// A few made-up traders of other players live round 0|0, so the world's market has offers
// and sends can go somewhere; they take a unit of the player's own offers now and then.
import type {
AuthUser,
Cost,
GameError,
MarketOffers,
MarketState,
Trade,
TradePlan,
TradeReport,
TradeResource,
TradeRoute,
TradeSide,
VillageMarket,
VillageRef,
WorldOffer,
} from '~/types/game'
import type { MockState, MockVillage } from './server'
/** What one merchant carries. */
const CARRY = 1000
/** Merchants walk fast in the mock, so deliveries arrive while you watch: 6 s per field. */
const MINUTES_PER_FIELD = 0.1
const MAX_RATIO = 3
const ROUTE_MIN_EVERY = 600
const ROUTE_MAX_EVERY = 86_400
/** A trader takes one unit of an own offer this long after it was posted, then again and again. */
const TAKE_AFTER_MS = 90_000
const TAKE_EVERY_MS = 150_000
const RESOURCES: TradeResource[] = ['wood', 'clay', 'iron']
export const merchantsAt = (level: number) => 2 * Math.max(1, level)
const maxRoutes = (level: number) => 2 + Math.floor(level / 5)
/** Merchants carrying one load: the backend's ceil(amount / carry). */
const merchantsFor = (amount: number) => Math.ceil(amount / CARRY)
const sum = (c: Cost) => c.wood + c.clay + c.iron
const none = (): Cost => ({ wood: 0, clay: 0, iron: 0 })
const one = (side: TradeSide, times = 1): Cost => ({ ...none(), [side.resource]: side.amount * times })
/** Merchants under way: a delivery with its cargo, or the way home. */
export interface MockTrade {
id: number
world_id: number
/** Village whose merchants these are. */
owner_id: number
kind: 'deliver' | 'return'
from_id: number
to_id: number
cargo: Cost | null
merchants: number
sent_at: number
arrives_at: number
route_id: number | null
offer: boolean
}
export interface MockOffer {
id: number
world_id: number
village_id: number
give: TradeSide
want: TradeSide
count: number
/** Per unit of count. */
merchants: number
created_at: number
/** Own offers only: when a trader takes the next unit. */
next_take_at?: number
}
export interface MockRoute {
id: number
world_id: number
village_id: number
to_id: number
resources: Cost
every: number
next_at: number
paused: boolean
paused_reason: null | 'owner_changed'
last_sent_at: number | null
last_cargo: Cost | null
}
export interface MockMarket {
trades: MockTrade[]
offers: MockOffer[]
routes: MockRoute[]
}
/** What the market needs from the rest of the mock server. */
export interface MarketHost {
ownVillage: (state: MockState, user: AuthUser, id: unknown, now: number) => MockVillage
villageRef: (state: MockState, id: number) => VillageRef
villageAt: (state: MockState, worldId: number, x: number, y: number) => VillageRef | null
/** Catch a village up to `at`, never backwards. */
advance: (state: MockState, v: MockVillage, at: number) => void
/** Add to the stock, up to the storage cap. */
refund: (v: MockVillage, amount: Cost) => void
/** Take from the stock; fails with `resources`. */
pay: (v: MockVillage, cost: Cost) => void
nextId: (state: MockState) => number
writeReport: (state: MockState, userId: number, worldId: number, at: number, body: { type: 'trade'; payload: TradeReport }) => void
}
function fail(code: string): never {
throw { code, message: code } satisfies GameError
}
const iso = (ms: number) => new Date(ms).toISOString()
const amount = (n: unknown) => Math.max(0, Math.floor(Number(n) || 0))
const distance = (a: { x: number; y: number }, b: { x: number; y: number }) => Math.hypot(a.x - b.x, a.y - b.y)
const tripSeconds = (fields: number) => Math.max(1, Math.round(fields * MINUTES_PER_FIELD * 60))
// The made-up traders: other players' villages round 0|0, below the barbarians' ids.
const TRADERS: VillageRef[] = [
{ id: -2_000_001, name: 'Eichenau', x: 7, y: -14, player: { id: -101, name: 'Hagen' } },
{ id: -2_000_002, name: 'Rabenfeld', x: -13, y: 5, player: { id: -102, name: 'Brunhild' } },
{ id: -2_000_003, name: 'Moorbach', x: 16, y: 12, player: { id: -103, name: 'Wendel' } },
{ id: -2_000_004, name: 'Steinach', x: -18, y: -16, player: { id: -104, name: 'Gerlind' } },
{ id: -2_000_005, name: 'Aschental', x: 21, y: -4, player: { id: -105, name: 'Ortwin' } },
]
export const traderRef = (id: number) => TRADERS.find((t) => t.id === id) ?? null
export const traderAt = (x: number, y: number) => TRADERS.find((t) => t.x === x && t.y === y) ?? null
const data = (state: MockState): MockMarket => (state.market ??= { trades: [], offers: [], routes: [] })
const marketOf = (v: MockVillage) => v.buildings.find((b) => b.type === 'market') ?? null
const ownerOf = (state: MockState, villageId: number) => state.villages.find((v) => v.id === villageId)
/** Merchants out with trades, home-bound included, and held back for open offers. */
function busy(state: MockState, v: MockVillage) {
const m = data(state)
return (
m.trades.filter((t) => t.owner_id === v.id).reduce((n, t) => n + t.merchants, 0) +
m.offers.filter((o) => o.village_id === v.id).reduce((n, o) => n + o.count * o.merchants, 0)
)
}
function freeMerchants(state: MockState, v: MockVillage) {
const b = marketOf(v)
return b ? Math.max(0, merchantsAt(b.level) - busy(state, v)) : 0
}
/** The village payload's market. */
export function villageMarket(state: MockState, v: MockVillage): VillageMarket | null {
const b = marketOf(v)
if (!b) return null
return { building_id: b.id, level: b.level, merchants: merchantsAt(b.level), free: freeMerchants(state, v), carry: CARRY }
}
/** The market's effects for the building list: merchants now and one level up. */
export const marketEffects = (level: number) => ({
effects: [{ key: 'merchants' as const, value: merchantsAt(level) }],
next_effects: [{ key: 'merchants' as const, value: merchantsAt(level + 1) }],
})
function view(state: MockState, host: MarketHost, v: MockVillage, now: number): MarketState {
const b = marketOf(v)
const m = data(state)
const ref = (id: number) => host.villageRef(state, id)
const trades = m.trades
.filter((t) => t.owner_id === v.id || (t.kind === 'deliver' && t.to_id === v.id))
.sort((a, b) => a.arrives_at - b.arrives_at || a.id - b.id)
.map(
(t): Trade => ({
id: t.id,
kind: t.owner_id === v.id ? (t.kind === 'deliver' ? 'out' : 'back') : 'in',
from: ref(t.from_id),
to: ref(t.to_id),
cargo: t.kind === 'deliver' ? t.cargo : null,
merchants: t.merchants,
sent_at: iso(t.sent_at),
arrives_at: iso(t.arrives_at),
route_id: t.route_id,
offer: t.offer,
}),
)
return {
server_time: iso(now),
market: b
? {
building_id: b.id,
level: b.level,
merchants: merchantsAt(b.level),
free: freeMerchants(state, v),
busy: busy(state, v),
carry: CARRY,
minutes_per_field: MINUTES_PER_FIELD,
resources: [...RESOURCES],
max_ratio: MAX_RATIO,
route: { min_every: ROUTE_MIN_EVERY, max_every: ROUTE_MAX_EVERY, max_routes: maxRoutes(b.level) },
}
: null,
trades,
offers: m.offers
.filter((o) => o.village_id === v.id)
.map((o) => ({ id: o.id, give: o.give, want: o.want, count: o.count, merchants: o.merchants, created_at: iso(o.created_at) })),
routes: m.routes
.filter((r) => r.village_id === v.id)
.map(
(r): TradeRoute => ({
id: r.id,
to: ref(r.to_id),
resources: r.resources,
every: r.every,
next_at: iso(r.next_at),
paused: r.paused,
paused_reason: r.paused_reason,
last_sent_at: r.last_sent_at === null ? null : iso(r.last_sent_at),
last_cargo: r.last_cargo,
}),
),
}
}
/** The village on a field for a delivery: not this one, not barbarian. */
function target(state: MockState, host: MarketHost, v: MockVillage, x: unknown, y: unknown) {
const ref = host.villageAt(state, v.world_id, Math.trunc(Number(x) || 0), Math.trunc(Number(y) || 0)) ?? fail('not_found')
if (ref.id === v.id) fail('same_village')
if (!ref.player) fail('barbarian')
return ref
}
function deliver(state: MockState, host: MarketHost, t: Omit<MockTrade, 'id' | 'kind' | 'arrives_at'>, fields: number) {
const trade: MockTrade = { ...t, id: host.nextId(state), kind: 'deliver', arrives_at: t.sent_at + tripSeconds(fields) * 1000 }
data(state).trades.push(trade)
return trade
}
/** Pick up to the amounts from the cargo picked, as far as the stock and `merchants` carry. */
function load(v: MockVillage, wanted: Cost, merchants: number): Cost {
const cargo = Object.fromEntries(RESOURCES.map((r) => [r, Math.min(wanted[r], Math.floor(v.resources[r]))])) as Cost
const room = merchants * CARRY
const total = sum(cargo)
if (total <= room) return cargo
const k = room / total
return Object.fromEntries(RESOURCES.map((r) => [r, Math.floor(cargo[r] * k)])) as Cost
}
function runRoute(state: MockState, host: MarketHost, r: MockRoute, at: number) {
r.next_at = at + r.every * 1000
const v = state.villages.find((x) => x.id === r.village_id)
if (!v || !marketOf(v)) return
const to = host.villageRef(state, r.to_id)
// The target was taken or vanished: the route stops until the player looks at it.
if (!to.player || (r.to_id > 0 && !ownerOf(state, r.to_id))) {
r.paused = true
r.paused_reason = 'owner_changed'
return
}
host.advance(state, v, at)
const cargo = load(v, r.resources, freeMerchants(state, v))
// Like the backend, a run that sends nothing still counts as the last run, with an empty cargo.
r.last_sent_at = at
r.last_cargo = cargo
if (sum(cargo) <= 0) return
host.pay(v, cargo)
deliver(state, host, { world_id: v.world_id, owner_id: v.id, from_id: v.id, to_id: r.to_id, cargo, merchants: merchantsFor(sum(cargo)), sent_at: at, route_id: r.id, offer: false }, distance(v, to))
}
/** Merchants arrive: cargo into the stock and a report, then the way home. */
function arrive(state: MockState, host: MarketHost, t: MockTrade, touched: Set<number>) {
const m = data(state)
m.trades = m.trades.filter((x) => x !== t)
touched.add(t.owner_id)
if (t.kind === 'return') return
const to = ownerOf(state, t.to_id)
if (to && t.cargo) {
host.advance(state, to, t.arrives_at)
host.refund(to, t.cargo)
touched.add(to.id)
}
const report: TradeReport = { from: host.villageRef(state, t.from_id), to: host.villageRef(state, t.to_id), cargo: t.cargo ?? none(), offer: t.offer }
const users = new Set([ownerOf(state, t.from_id)?.user_id, to?.user_id].filter((u): u is number => u !== undefined))
users.forEach((userId) => host.writeReport(state, userId, t.world_id, t.arrives_at, { type: 'trade', payload: report }))
// Merchants of a real village walk home; the traders' are of no interest.
if (ownerOf(state, t.owner_id)) {
m.trades.push({ ...t, id: host.nextId(state), kind: 'return', from_id: t.to_id, to_id: t.owner_id, cargo: null, sent_at: t.arrives_at, arrives_at: t.arrives_at + (t.arrives_at - t.sent_at) })
}
}
/** A trader takes one unit of an own offer: both sides' merchants set out. */
function take(state: MockState, host: MarketHost, o: MockOffer, at: number, touched: Set<number>) {
const v = ownerOf(state, o.village_id)
const m = data(state)
if (!v) {
m.offers = m.offers.filter((x) => x !== o)
return
}
const trader = [...TRADERS].sort((a, b) => distance(v, a) - distance(v, b))[o.id % 3]!
const fields = distance(v, trader)
deliver(state, host, { world_id: v.world_id, owner_id: v.id, from_id: v.id, to_id: trader.id, cargo: one(o.give), merchants: o.merchants, sent_at: at, route_id: null, offer: true }, fields)
deliver(state, host, { world_id: v.world_id, owner_id: trader.id, from_id: trader.id, to_id: v.id, cargo: one(o.want), merchants: merchantsFor(o.want.amount), sent_at: at, route_id: null, offer: true }, fields)
o.count -= 1
o.next_take_at = at + TAKE_EVERY_MS
if (o.count <= 0) m.offers = m.offers.filter((x) => x !== o)
touched.add(v.id)
}
/** When the next trade arrives, route runs or trader takes an offer. */
export function nextMarketDue(state: MockState) {
const m = data(state)
return Math.min(
...m.trades.map((t) => t.arrives_at),
...m.routes.filter((r) => !r.paused).map((r) => r.next_at),
...m.offers.flatMap((o) => (o.next_take_at === undefined ? [] : [o.next_take_at])),
)
}
/** Everything due by `now`, oldest first; returns the villages touched. */
export function processMarket(state: MockState, host: MarketHost, now: number): number[] {
const touched = new Set<number>()
const m = data(state)
for (;;) {
const trade = [...m.trades].sort((a, b) => a.arrives_at - b.arrives_at || a.id - b.id)[0]
const route = m.routes.filter((r) => !r.paused).sort((a, b) => a.next_at - b.next_at || a.id - b.id)[0]
const offer = m.offers.filter((o) => o.next_take_at !== undefined).sort((a, b) => a.next_take_at! - b.next_take_at!)[0]
const at = Math.min(trade?.arrives_at ?? Infinity, route?.next_at ?? Infinity, offer?.next_take_at ?? Infinity)
if (at > now) break
if (trade && trade.arrives_at === at) arrive(state, host, trade, touched)
else if (route && route.next_at === at) {
runRoute(state, host, route, at)
touched.add(route.village_id)
} else if (offer) take(state, host, offer, at, touched)
}
return [...touched].filter((id) => id > 0)
}
/** The traders keep a handful of offers on every world. */
function stock(state: MockState, host: MarketHost, worldId: number, now: number) {
const m = data(state)
const traders = new Set(TRADERS.map((t) => t.id))
let open = m.offers.filter((o) => o.world_id === worldId && traders.has(o.village_id)).length
for (; open < 6; open++) {
const n = m.offers.length + open
const trader = TRADERS[n % TRADERS.length]!
const give = RESOURCES[n % 3]!
const want = RESOURCES[(n + 1 + (n % 2)) % 3]!
const giveAmount = 200 * (1 + ((open * 3 + 1) % 5))
const wantAmount = Math.max(100, Math.round((giveAmount * (0.7 + 0.15 * (open % 4))) / 50) * 50)
m.offers.push({
id: host.nextId(state),
world_id: worldId,
village_id: trader.id,
give: { resource: give, amount: giveAmount },
want: { resource: want, amount: wantAmount },
count: 1 + (open % 4),
merchants: merchantsFor(giveAmount),
created_at: now - open * 600_000,
})
}
}
/** One side of an offer; an untraded resource (food) is not found, like on the backend. */
const side = (raw: any): TradeSide => ({ resource: RESOURCES.find((r) => r === raw?.resource) ?? fail('not_found'), amount: amount(raw?.amount) })
function withMarket(v: MockVillage) {
return marketOf(v) ?? fail('no_market')
}
/** Drop the market data of villages that are gone (mock.reset). */
export function dropMarket(state: MockState, gone: Set<number>) {
const m = data(state)
m.trades = m.trades.filter((t) => !gone.has(t.owner_id))
m.offers = m.offers.filter((o) => !gone.has(o.village_id))
m.routes = m.routes.filter((r) => !gone.has(r.village_id))
}
type Handler = (state: MockState, user: AuthUser, data: any, now: number) => unknown
export function marketHandlers(host: MarketHost): Record<string, Handler> {
const show = (state: MockState, v: MockVillage, now: number) => view(state, host, v, now)
return {
'market.show': (state, user, d, now) => show(state, host.ownVillage(state, user, d.village_id, now), now),
'market.preview': (state, user, d, now): TradePlan => {
const v = host.ownVillage(state, user, d.village_id, now)
const to = target(state, host, v, d.x, d.y)
const seconds = tripSeconds(distance(v, to))
return { target: to, distance: Math.round(distance(v, to) * 100) / 100, seconds, arrives_at: iso(now + seconds * 1000) }
},
'market.send': (state, user, d, now) => {
const v = host.ownVillage(state, user, d.village_id, now)
withMarket(v)
const to = target(state, host, v, d.x, d.y)
const cargo: Cost = { wood: amount(d.wood), clay: amount(d.clay), iron: amount(d.iron) }
if (sum(cargo) <= 0) fail('nothing')
if (RESOURCES.some((r) => cargo[r] > v.resources[r])) fail('resources')
const merchants = merchantsFor(sum(cargo))
if (merchants > freeMerchants(state, v)) fail('merchants')
host.pay(v, cargo)
deliver(state, host, { world_id: v.world_id, owner_id: v.id, from_id: v.id, to_id: to.id, cargo, merchants, sent_at: now, route_id: null, offer: false }, distance(v, to))
return show(state, v, now)
},
'market.offers': (state, user, d, now): MarketOffers => {
const v = host.ownVillage(state, user, d.village_id, now)
stock(state, host, v.world_id, now)
const own = new Set(state.villages.filter((x) => x.user_id === user.id).map((x) => x.id))
const offers = data(state)
.offers.filter((o) => o.world_id === v.world_id && (!d.give || o.give.resource === d.give) && (!d.want || o.want.resource === d.want))
.map((o): WorldOffer => {
const village = host.villageRef(state, o.village_id)
const fields = distance(v, village)
return { id: o.id, village, give: o.give, want: o.want, count: o.count, distance: Math.round(fields * 100) / 100, seconds: tripSeconds(fields), own: own.has(o.village_id) }
})
.sort((a, b) => a.distance - b.distance || a.id - b.id)
return { server_time: iso(now), offers }
},
'market.offer': (state, user, d, now) => {
const v = host.ownVillage(state, user, d.village_id, now)
withMarket(v)
// The backend's order: no_market, not_found, same_resource, amount, count, ratio, resources, merchants.
const give = side(d.give)
const want = side(d.want)
if (give.resource === want.resource) fail('same_resource')
if (give.amount < 1 || want.amount < 1) fail('amount')
const count = amount(d.count)
if (count < 1) fail('count')
if (want.amount > give.amount * MAX_RATIO || give.amount > want.amount * MAX_RATIO) fail('ratio')
if (give.amount * count > v.resources[give.resource]) fail('resources')
const merchants = merchantsFor(give.amount)
if (merchants * count > freeMerchants(state, v)) fail('merchants')
host.pay(v, one(give, count))
data(state).offers.push({ id: host.nextId(state), world_id: v.world_id, village_id: v.id, give, want, count, merchants, created_at: now, next_take_at: now + TAKE_AFTER_MS })
return show(state, v, now)
},
'market.cancelOffer': (state, user, d, now) => {
const v = host.ownVillage(state, user, d.village_id, now)
const m = data(state)
const o = m.offers.find((x) => x.id === Number(d.offer_id) && x.village_id === v.id) ?? fail('not_found')
host.refund(v, one(o.give, o.count))
m.offers = m.offers.filter((x) => x !== o)
return show(state, v, now)
},
'market.accept': (state, user, d, now) => {
const v = host.ownVillage(state, user, d.village_id, now)
withMarket(v)
const m = data(state)
const o = m.offers.find((x) => x.id === Number(d.offer_id) && x.world_id === v.world_id) ?? fail('not_found')
if (state.villages.some((x) => x.id === o.village_id && x.user_id === user.id)) fail('own_offer')
const count = amount(d.count)
if (count < 1 || count > o.count) fail('count')
if (o.want.amount * count > v.resources[o.want.resource]) fail('resources')
const merchants = merchantsFor(o.want.amount) * count
if (merchants > freeMerchants(state, v)) fail('merchants')
host.pay(v, one(o.want, count))
const other = host.villageRef(state, o.village_id)
const fields = distance(v, other)
deliver(state, host, { world_id: v.world_id, owner_id: v.id, from_id: v.id, to_id: other.id, cargo: one(o.want, count), merchants, sent_at: now, route_id: null, offer: true }, fields)
deliver(state, host, { world_id: v.world_id, owner_id: other.id, from_id: other.id, to_id: v.id, cargo: one(o.give, count), merchants: o.merchants * count, sent_at: now, route_id: null, offer: true }, fields)
o.count -= count
if (o.count <= 0) m.offers = m.offers.filter((x) => x !== o)
return show(state, v, now)
},
// A new route first runs `every` seconds after it was made, like the backend's.
'market.routeCreate': (state, user, d, now) => {
const v = host.ownVillage(state, user, d.village_id, now)
const b = withMarket(v)
const to = target(state, host, v, d.x, d.y)
const resources: Cost = { wood: amount(d.wood), clay: amount(d.clay), iron: amount(d.iron) }
if (sum(resources) <= 0) fail('nothing')
const every = amount(d.every)
if (every < ROUTE_MIN_EVERY || every > ROUTE_MAX_EVERY) fail('every')
const m = data(state)
if (m.routes.filter((r) => r.village_id === v.id).length >= maxRoutes(b.level)) fail('max_routes')
const route: MockRoute = { id: host.nextId(state), world_id: v.world_id, village_id: v.id, to_id: to.id, resources, every, next_at: now + every * 1000, paused: false, paused_reason: null, last_sent_at: null, last_cargo: null }
m.routes.push(route)
return show(state, v, now)
},
'market.routeUpdate': (state, user, d, now) => {
const v = host.ownVillage(state, user, d.village_id, now)
const r = data(state).routes.find((x) => x.id === Number(d.route_id) && x.village_id === v.id) ?? fail('not_found')
const resources = { ...r.resources }
for (const res of RESOURCES) if (d[res] !== undefined) resources[res] = amount(d[res])
if (sum(resources) <= 0) fail('nothing')
let every = r.every
if (d.every !== undefined) {
every = amount(d.every)
if (every < ROUTE_MIN_EVERY || every > ROUTE_MAX_EVERY) fail('every')
}
// Resuming takes the target's owner as it is now; a target turned barbarian is refused.
const resuming = d.paused !== undefined && !d.paused && r.paused
if (resuming && !host.villageRef(state, r.to_id).player) fail('barbarian')
r.resources = resources
if (d.paused !== undefined) {
r.paused = !!d.paused
r.paused_reason = null
}
// A new interval on an active route, or resuming, starts the clock again from now.
if ((every !== r.every || resuming) && !r.paused) r.next_at = now + every * 1000
r.every = every
return show(state, v, now)
},
'market.routeDelete': (state, user, d, now) => {
const v = host.ownVillage(state, user, d.village_id, now)
const m = data(state)
const r = m.routes.find((x) => x.id === Number(d.route_id) && x.village_id === v.id) ?? fail('not_found')
m.routes = m.routes.filter((x) => x !== r)
return show(state, v, now)
},
}
}