217 lines
6.0 KiB
TypeScript
217 lines
6.0 KiB
TypeScript
// Payloads exchanged with the server. Every number in here is computed server-side;
|
|
// the client only projects resources and countdowns forward from the timestamps.
|
|
|
|
export type Resource = 'wood' | 'clay' | 'iron' | 'food'
|
|
export type Resources = Record<Resource, number>
|
|
export type Cost = Record<Exclude<Resource, 'food'>, number>
|
|
|
|
export type BuildingType =
|
|
| 'headquarters'
|
|
| 'storage'
|
|
| 'farm'
|
|
| 'timber_camp'
|
|
| 'clay_pit'
|
|
| 'iron_mine'
|
|
| 'hiding_place'
|
|
| 'wall'
|
|
| 'rally_point'
|
|
| 'barracks'
|
|
| 'stable'
|
|
| 'workshop'
|
|
| 'academy'
|
|
|
|
export type UnitType =
|
|
| 'spear'
|
|
| 'sword'
|
|
| 'archer'
|
|
| 'light_cavalry'
|
|
| 'heavy_cavalry'
|
|
| 'ram'
|
|
| 'catapult'
|
|
| 'nobleman'
|
|
|
|
/** Why the server refuses an offer. The client shows `village.blocked.<reason>`; no_space means not enough free building space. */
|
|
export type BlockedReason = 'max_per_village' | 'no_space' | 'max_level' | 'requires'
|
|
|
|
export interface AuthUser {
|
|
id: number
|
|
name: string
|
|
email: string
|
|
}
|
|
|
|
/** `POST auth/login` and `POST auth/register`. */
|
|
export interface AuthResult {
|
|
token: string
|
|
user: AuthUser
|
|
}
|
|
|
|
/** One row of `world.index`. */
|
|
export interface WorldSummary {
|
|
id: number
|
|
name: string
|
|
slug: string
|
|
speed: number
|
|
village_id: number | null
|
|
}
|
|
|
|
/** `village.show`, and the reply to every `village.*` mutation. */
|
|
export interface VillageState {
|
|
id: number
|
|
world_id: number
|
|
name: string
|
|
x: number
|
|
y: number
|
|
/** Map continent, e.g. K55 for 500|500. */
|
|
continent: string
|
|
/** Sum of the buildings' level points, as shown on the map. */
|
|
points: number
|
|
/** Building space: what buildings and queued new buildings take, out of the village maximum. */
|
|
space: { used: number; max: number }
|
|
/** Amounts stored at `resources_at`. */
|
|
resources: Resources
|
|
resources_at: string
|
|
/** Net change per hour. Food is farm output minus upkeep, so it can be negative. */
|
|
rates: Resources
|
|
storage_cap: number
|
|
population: Population
|
|
/** Villagers drafted as militia: they eat but don't work until `until`. */
|
|
levy: Levy
|
|
starvation: Starvation
|
|
/** Own units standing in the village. */
|
|
troops: Partial<Record<UnitType, number>>
|
|
/** One entry per building that trains units, in building order. */
|
|
military: MilitaryBuilding[]
|
|
builders: number
|
|
buildings: Building[]
|
|
queue: BuildOrder[]
|
|
buildable: BuildOption[]
|
|
/** Lets the client correct for its own clock being off. */
|
|
server_time: string
|
|
}
|
|
|
|
export interface Population {
|
|
/** Food per hour the village can feed. */
|
|
food_budget: number
|
|
/** Food per hour eaten by villagers and soldiers. */
|
|
upkeep: number
|
|
villagers: number
|
|
/** Villagers assigned to buildings. */
|
|
workers: number
|
|
soldiers: number
|
|
/** Units queued but not trained yet; they already eat instead of working. */
|
|
training: number
|
|
}
|
|
|
|
export interface Levy {
|
|
/** 0 when no levy is under way. */
|
|
militia: number
|
|
/** When the militia go back to work on their own. */
|
|
until: string | null
|
|
/** How long a new levy would last. */
|
|
seconds: number
|
|
}
|
|
|
|
/** Upkeep above income drains the food stock; once it is empty, soldiers desert after a grace time. */
|
|
export interface Starvation {
|
|
/** When the stock runs out at the current rates; null while food isn't draining. */
|
|
food_empty_at: string | null
|
|
/** Set while the stock is empty and the village eats more than it harvests. */
|
|
since: string | null
|
|
/** The next desertion wave, while starving. */
|
|
desertion_at: string | null
|
|
}
|
|
|
|
/** A barracks, stable, workshop or academy: what it trains and its own queue. */
|
|
export interface MilitaryBuilding {
|
|
building_id: number
|
|
type: BuildingType
|
|
level: number
|
|
units: RecruitOption[]
|
|
queue: RecruitOrder[]
|
|
}
|
|
|
|
export interface RecruitOption {
|
|
unit: UnitType
|
|
/** Per unit. */
|
|
cost: Cost
|
|
/** Per unit at this building, from its level and staffing. */
|
|
seconds: number
|
|
/** Food per hour one unit eats. */
|
|
upkeep: number
|
|
/** Most units that resources and villagers allowed when the snapshot was taken. */
|
|
max: number
|
|
blocked: 'requires' | null
|
|
requires: { type: BuildingType; level: number }[]
|
|
}
|
|
|
|
export interface RecruitOrder {
|
|
id: number
|
|
unit: UnitType
|
|
count: number
|
|
/** Units trained by the snapshot; the rest arrive every seconds_per_unit after starts_at. */
|
|
done: number
|
|
seconds_per_unit: number
|
|
starts_at: string
|
|
finishes_at: string
|
|
}
|
|
|
|
export interface Building {
|
|
id: number
|
|
type: BuildingType
|
|
level: number
|
|
/** Building space this instance takes, fixed per type (0 for the wall). */
|
|
space: number
|
|
priority: number
|
|
workers: { assigned: number; required: number }
|
|
/** assigned / required, 0..1. */
|
|
staffing: number
|
|
production: { resource: Resource; per_hour: number } | null
|
|
/** Next level after everything already queued; null at max level. */
|
|
upgrade: Offer | null
|
|
/** null when the building cannot go lower (core buildings at level 1); target level 0 removes it. */
|
|
demolish: { target_level: number; refund: Cost; seconds: number } | null
|
|
}
|
|
|
|
/** Whether it is affordable is left to the client, which compares the cost to projected resources. */
|
|
export interface Offer {
|
|
target_level: number
|
|
cost: Cost
|
|
seconds: number
|
|
blocked: BlockedReason | null
|
|
}
|
|
|
|
export interface BuildOption extends Offer {
|
|
type: BuildingType
|
|
space: number
|
|
/** Requirements no building meets yet; only advanced buildings have any. */
|
|
requires: { type: BuildingType; level: number }[]
|
|
}
|
|
|
|
export interface BuildOrder {
|
|
id: number
|
|
/** null for a new instance that does not exist yet. */
|
|
building_id: number | null
|
|
type: BuildingType
|
|
action: 'build' | 'upgrade' | 'demolish'
|
|
/** 0 means the instance is removed; levels start at 1. */
|
|
target_level: number
|
|
space: number
|
|
cost: Cost
|
|
position: number
|
|
/** Builder slot working on it, or null while it waits. */
|
|
builder: number | null
|
|
starts_at: string | null
|
|
finishes_at: string | null
|
|
}
|
|
|
|
/** Push `village:updated` after the server processed an event for this village. */
|
|
export interface VillageUpdated {
|
|
village_id: number
|
|
}
|
|
|
|
/** What a rejected `ws.send` carries. */
|
|
export interface GameError {
|
|
message: string
|
|
code?: string
|
|
}
|