game-village-politics-frontend/app/composables/useVillage.ts

143 lines
5.8 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import type { BuildingType, Cost, MarchPlan, MovementType, Resource, Resources, TravelMode, Units, UnitType, VillageState, VillageUpdated } from '~/types/game'
import type { InjectionKey } from 'vue'
const RESOURCES: Resource[] = ['wood', 'clay', 'iron', 'food']
/**
* One village: the last server snapshot, resources projected to now, and the intents.
* Call it from a page's setup(), since it listens for pushes while that page is mounted.
*/
export function useVillage(villageId: number) {
const village = ref<VillageState | null>(null)
const error = ref<string | null>(null)
const busy = ref(false)
const errorText = useErrorText()
const unreadReports = useUnreadReports()
// Projections and countdowns run on the server's clock.
const { now, sync } = useServerClock()
async function run(event: string, data: object = {}) {
busy.value = true
error.value = null
try {
const state = await ws.send<VillageState>(event, { village_id: villageId, ...data })
sync(state.server_time)
village.value = state
unreadReports.value = state.unread_reports
return true
} catch (e) {
error.value = errorText(e)
return false
} finally {
busy.value = false
}
}
const refresh = () => run('village.show')
/** stored + rate × elapsed, kept between 0 and the storage cap. */
const resources = computed<Resources | null>(() => {
const v = village.value
if (!v) return null
const hours = (now.value - Date.parse(v.resources_at)) / 3_600_000
const project = (r: Resource) => Math.min(v.storage_cap, Math.max(0, v.resources[r] + v.rates[r] * hours))
return Object.fromEntries(RESOURCES.map((r) => [r, project(r)])) as Resources
})
const canAfford = (cost: Cost) =>
!!resources.value &&
resources.value.wood >= cost.wood &&
resources.value.clay >= cost.clay &&
resources.value.iron >= cost.iron
/** Whole seconds until a server timestamp, never below zero. */
const secondsUntil = (iso: string) => Math.max(0, Math.ceil((Date.parse(iso) - now.value) / 1000))
// Refetch once when the next build order, unit in training or group under way is due,
// so new buildings, trained troops and arrivals show up without waiting for a push.
const nextDue = computed(() => {
const v = village.value
if (!v) return null
const times = [
...v.queue.flatMap((o) => (o.finishes_at ? [Date.parse(o.finishes_at)] : [])),
...[v.levy.until, v.starvation.food_empty_at, v.starvation.desertion_at].flatMap((at) => (at ? [Date.parse(at)] : [])),
...v.movements.map((m) => Date.parse(m.arrives_at)),
...v.military.flatMap((m) =>
m.queue.filter((o) => o.done < o.count).map((o) => Date.parse(o.starts_at) + (o.done + 1) * o.seconds_per_unit * 1000),
),
]
return times.length ? Math.min(...times) : null
})
watch(
() => nextDue.value !== null && now.value >= nextDue.value,
(due) => {
if (due) refresh()
},
)
ws.listenWhileMounted<VillageUpdated>('village:updated', null, (data) => {
if (data.village_id === villageId) refresh()
})
return {
village,
resources,
/** Milliseconds on the server clock, ticking. */
now,
error,
busy,
canAfford,
secondsUntil,
refresh,
build: (type: BuildingType) => run('village.build', { type }),
upgrade: (buildingId: number) => run('village.upgrade', { building_id: buildingId }),
demolish: (buildingId: number) => run('village.demolish', { building_id: buildingId }),
cancel: (orderId: number) => run('village.cancel', { order_id: orderId }),
setPriority: (buildingId: number, priority: number) => run('village.staff', { building_id: buildingId, priority }),
/** One order per unit type, sent one after another; stops at the first refusal. */
recruit: async (buildingId: number, orders: { unit: UnitType; count: number }[]) => {
for (const o of orders) {
await run('village.recruit', { building_id: buildingId, unit: o.unit, count: o.count })
if (error.value) return false
}
return true
},
cancelRecruit: (orderId: number) => run('village.cancelRecruit', { order_id: orderId }),
levy: (count: number) => run('village.levy', { count }),
endLevy: () => run('village.endLevy'),
/** Target, distance and travel time for the send form; null when the server refuses. */
preview: async (x: number, y: number, units: Units, mode: TravelMode) => {
try {
return await ws.send<MarchPlan>('rally.preview', { village_id: villageId, x, y, units, mode })
} catch {
return null
}
},
send: (type: Exclude<MovementType, 'return'>, x: number, y: number, units: Units, mode: TravelMode, catapultTarget: BuildingType | null) =>
run('rally.send', { type, x, y, units, mode, catapult_target: catapultTarget }),
cancelMovement: (movementId: number) => run('rally.cancel', { movement_id: movementId }),
sendHome: (homeVillageId: number) => run('rally.sendHome', { home_village_id: homeVillageId }),
withdraw: (hostVillageId: number) => run('rally.withdraw', { host_village_id: hostVillageId }),
rename: (name: string) => run('village.rename', { name }),
}
}
export type VillageContext = ReturnType<typeof useVillage>
const VILLAGE: InjectionKey<VillageContext> = Symbol('village')
/** The village page shares its one useVillage() with every screen in it. */
export function provideVillage(context: VillageContext) {
provide(VILLAGE, context)
}
export function useVillageContext(): VillageContext {
const context = inject(VILLAGE)
if (!context) throw new Error('useVillageContext() needs the village page around it.')
return context
}
/** The village of the bar on top, where a page may also stand without one (the map). */
export function useVillageContextOrNull(): VillageContext | null {
return inject(VILLAGE, null)
}