@shipload/sdk 0.7.1 → 1.0.0-beta1

package/src/scheduling/projection.ts

@@ -0,0 +1,463 @@
+import {Name, TimePoint, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {Coordinates, PRECISION, TaskType} from '../types'
+import {
+    capsHasLoaders,
+    capsHasMovement,
+    capsHasStorage,
+    type EntityCapabilities,
+    type EntityState,
+} from '../types/capabilities'
+import {
+    ENTITY_CAPACITY_EXCEEDED,
+    RECIPE_INPUTS_EXCESS,
+    RECIPE_INPUTS_INSUFFICIENT,
+    RECIPE_INPUTS_INVALID,
+    RECIPE_NOT_FOUND,
+    SHIP_CARGO_NOT_LOADED,
+} from '../errors'
+import {getRecipe, type RecipeInput} from '../data/recipes-runtime'
+import {getItem} from '../data/catalog'
+import {distanceBetweenCoordinates, lerp} from '../travel/travel'
+import {
+    calcStacksMass,
+    cargoItemToStack,
+    type CargoStack,
+    mergeStacks,
+    removeFromStacks,
+    stackToCargoItem,
+} from '../capabilities/storage'
+import * as schedule from './schedule'
+import type {ScheduleData} from './schedule'
+
+export interface ProjectedEntity {
+    location: Coordinates
+    energy: UInt16
+    cargo: CargoStack[]
+    shipMass: UInt32
+    capacity?: UInt64
+    engines?: ServerContract.Types.movement_stats
+    loaders?: ServerContract.Types.loader_stats
+    generator?: ServerContract.Types.energy_stats
+    hauler?: ServerContract.Types.hauler_stats
+    readonly cargoMass: UInt64
+    readonly totalMass: UInt64
+
+    hasMovement(): boolean
+    hasStorage(): boolean
+    hasLoaders(): boolean
+
+    capabilities(): EntityCapabilities
+    state(): EntityState
+}
+
+export interface Projectable extends ScheduleData {
+    coordinates: Coordinates | ServerContract.Types.coordinates
+    energy?: UInt16
+    hullmass?: UInt32
+    generator?: ServerContract.Types.energy_stats
+    engines?: ServerContract.Types.movement_stats
+    loaders?: ServerContract.Types.loader_stats
+    hauler?: ServerContract.Types.hauler_stats
+    capacity?: UInt32
+    cargo: ServerContract.Types.cargo_item[]
+    cargomass: UInt32
+    owner?: Name
+}
+
+function getHullMass(entity: Projectable): UInt32 {
+    return UInt32.from(entity.hullmass ?? 0)
+}
+
+export function createProjectedEntity(entity: Projectable): ProjectedEntity {
+    const shipMass = getHullMass(entity)
+    const loaders = entity.loaders
+    const engines = entity.engines
+    const generator = entity.generator
+    const hauler = entity.hauler
+    const capacity = entity.capacity
+
+    const cargo: CargoStack[] = entity.cargo.map(cargoItemToStack)
+
+    const projected: ProjectedEntity = {
+        location: Coordinates.from(entity.coordinates),
+        energy: UInt16.from(entity.energy ?? 0),
+        cargo,
+        shipMass,
+        capacity: capacity ? UInt64.from(capacity) : undefined,
+        engines,
+        generator,
+        hauler,
+        loaders,
+
+        get cargoMass() {
+            return calcStacksMass(this.cargo)
+        },
+
+        get totalMass() {
+            let mass = UInt64.from(this.shipMass).adding(this.cargoMass)
+            if (this.loaders) {
+                mass = mass.adding(this.loaders.mass.multiplying(this.loaders.quantity))
+            }
+            return mass
+        },
+
+        hasMovement() {
+            return capsHasMovement(this.capabilities())
+        },
+
+        hasStorage() {
+            return capsHasStorage(this.capabilities())
+        },
+
+        hasLoaders() {
+            return capsHasLoaders(this.capabilities())
+        },
+
+        capabilities(): EntityCapabilities {
+            return {
+                hullmass: this.shipMass,
+                capacity: this.capacity ? UInt32.from(this.capacity) : undefined,
+                engines: this.engines,
+                generator: this.generator,
+                loaders: this.loaders,
+            }
+        },
+
+        state(): EntityState {
+            return {
+                owner: entity.owner ?? Name.from(''),
+                location: ServerContract.Types.coordinates.from(this.location),
+                energy: this.energy,
+                cargomass: UInt32.from(this.cargoMass),
+                cargo: this.cargo.map(stackToCargoItem),
+            }
+        },
+    }
+
+    return projected
+}
+
+function applyRechargeTask(
+    projected: ProjectedEntity,
+    _task: ServerContract.Types.task,
+    options: {complete: boolean; progress?: number}
+): void {
+    if (!projected.generator) return
+
+    if (options.complete) {
+        projected.energy = UInt16.from(projected.generator.capacity)
+    } else if (options.progress !== undefined) {
+        const capacity = Number(projected.generator.capacity)
+        const currentEnergy = Number(projected.energy)
+        const rechargeAmount = (capacity - currentEnergy) * options.progress
+        projected.energy = UInt16.from(Math.min(capacity, currentEnergy + rechargeAmount))
+    }
+}
+
+function applyFlightTask(
+    projected: ProjectedEntity,
+    task: ServerContract.Types.task,
+    options: {complete: boolean; progress?: number}
+): void {
+    if (!task.coordinates || !projected.engines) return
+
+    const origin = projected.location
+    const destination = Coordinates.from(task.coordinates)
+    const distance = distanceBetweenCoordinates(origin, task.coordinates)
+    const energyUsage = distance.dividing(PRECISION).multiplying(projected.engines.drain)
+
+    if (options.complete) {
+        projected.energy = projected.energy.gt(energyUsage)
+            ? UInt16.from(projected.energy.subtracting(energyUsage))
+            : UInt16.from(0)
+        projected.location = destination
+    } else if (options.progress !== undefined) {
+        const interpolated = lerp(origin, destination, options.progress)
+        projected.location = Coordinates.from({
+            x: Math.round(interpolated.x),
+            y: Math.round(interpolated.y),
+        })
+        const partialEnergy = UInt64.from(Math.floor(Number(energyUsage) * options.progress))
+        projected.energy = projected.energy.gt(partialEnergy)
+            ? UInt16.from(projected.energy.subtracting(partialEnergy))
+            : UInt16.from(0)
+    }
+}
+
+function addCargoItem(projected: ProjectedEntity, item: ServerContract.Types.cargo_item): void {
+    projected.cargo = mergeStacks(projected.cargo, cargoItemToStack(item))
+}
+
+function removeCargoItem(projected: ProjectedEntity, item: ServerContract.Types.cargo_item): void {
+    projected.cargo = removeFromStacks(projected.cargo, cargoItemToStack(item))
+}
+
+function applyAddCargoTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    for (const item of task.cargo) {
+        addCargoItem(projected, item)
+    }
+}
+
+function applyRemoveCargoTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    for (const item of task.cargo) {
+        removeCargoItem(projected, item)
+    }
+}
+
+function applyEnergyCost(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    if (!task.energy_cost) return
+    const energyCost = UInt16.from(task.energy_cost)
+    projected.energy = projected.energy.gt(energyCost)
+        ? UInt16.from(projected.energy.subtracting(energyCost))
+        : UInt16.from(0)
+}
+
+function applyGatherTask(
+    projected: ProjectedEntity,
+    task: ServerContract.Types.task,
+    options: {complete: boolean}
+): void {
+    if (!options.complete) return
+    applyEnergyCost(projected, task)
+    if (!task.entitytarget) {
+        applyAddCargoTask(projected, task)
+    }
+}
+
+function applyCraftTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    applyEnergyCost(projected, task)
+    if (task.cargo.length === 0) return
+
+    for (let i = 0; i < task.cargo.length - 1; i++) {
+        removeCargoItem(projected, task.cargo[i])
+    }
+    addCargoItem(projected, task.cargo[task.cargo.length - 1])
+}
+
+function applyDeployTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    applyEnergyCost(projected, task)
+    if (task.cargo.length > 0) {
+        removeCargoItem(projected, task.cargo[0])
+    }
+}
+
+function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    switch (task.type.toNumber()) {
+        case TaskType.RECHARGE:
+            applyRechargeTask(projected, task, {complete: true})
+            break
+        case TaskType.TRAVEL:
+            applyFlightTask(projected, task, {complete: true})
+            break
+        case TaskType.LOAD:
+        case TaskType.UNWRAP:
+            applyAddCargoTask(projected, task)
+            break
+        case TaskType.UNLOAD:
+        case TaskType.WRAP:
+            applyRemoveCargoTask(projected, task)
+            break
+        case TaskType.GATHER:
+            applyGatherTask(projected, task, {complete: true})
+            break
+        case TaskType.CRAFT:
+            applyCraftTask(projected, task)
+            break
+        case TaskType.DEPLOY:
+            applyDeployTask(projected, task)
+            break
+    }
+}
+
+export interface ProjectionOptions {
+    upToTaskIndex?: number
+}
+
+export function projectEntity(entity: Projectable, options?: ProjectionOptions): ProjectedEntity {
+    const projected = createProjectedEntity(entity)
+    if (!entity.schedule || entity.schedule.tasks.length === 0) return projected
+
+    const tasks = entity.schedule.tasks
+    const taskCount =
+        options?.upToTaskIndex !== undefined
+            ? Math.max(0, Math.min(options.upToTaskIndex, tasks.length))
+            : tasks.length
+
+    for (let i = 0; i < taskCount; i++) {
+        applyTask(projected, tasks[i])
+    }
+    return projected
+}
+
+export interface ProjectableSnapshot extends Projectable {
+    current_task?: ServerContract.Types.task
+    pending_tasks?: ServerContract.Types.task[]
+}
+
+function buildRemainingProjectable(snapshot: ProjectableSnapshot): Projectable | null {
+    if (!snapshot.schedule) return null
+    const remainingTasks: ServerContract.Types.task[] = []
+    if (snapshot.current_task) remainingTasks.push(snapshot.current_task)
+    if (snapshot.pending_tasks?.length) remainingTasks.push(...snapshot.pending_tasks)
+    if (remainingTasks.length === 0) return null
+
+    const completedCount = snapshot.schedule.tasks.length - remainingTasks.length
+    let startedMs = snapshot.schedule.started.toMilliseconds()
+    for (let i = 0; i < completedCount; i++) {
+        startedMs += snapshot.schedule.tasks[i].duration.toNumber() * 1000
+    }
+
+    return {
+        ...snapshot,
+        schedule: ServerContract.Types.schedule.from({
+            started: TimePoint.fromMilliseconds(startedMs),
+            tasks: remainingTasks,
+        }),
+    }
+}
+
+export function projectFromCurrentState(snapshot: ProjectableSnapshot): ProjectedEntity {
+    const projectable = buildRemainingProjectable(snapshot)
+    return projectable ? projectEntity(projectable) : createProjectedEntity(snapshot)
+}
+
+function getRecipeInputsForOutput(outputItemId: number): RecipeInput[] | undefined {
+    const recipe = getRecipe(outputItemId)
+    return recipe?.inputs
+}
+
+function validateCraftTask(task: ServerContract.Types.task, projected: ProjectedEntity): void {
+    if (task.cargo.length === 0) return
+
+    const output = task.cargo[task.cargo.length - 1]
+    const inputs = task.cargo.slice(0, -1)
+    const craftQuantity = output.quantity.toNumber()
+
+    const recipe = getRecipeInputsForOutput(output.item_id.toNumber())
+    if (!recipe) throw new Error(RECIPE_NOT_FOUND)
+
+    const groupedInputs: ServerContract.Types.cargo_item[][] = recipe.map(() => [])
+    for (const input of inputs) {
+        let matched = false
+        for (let ri = 0; ri < recipe.length; ri++) {
+            const req = recipe[ri]
+            if ('itemId' in req) {
+                if (input.item_id.toNumber() === req.itemId) {
+                    groupedInputs[ri].push(input)
+                    matched = true
+                    break
+                }
+            } else {
+                const item = getItem(input.item_id)
+                if (item.category === req.category && item.tier === req.tier) {
+                    groupedInputs[ri].push(input)
+                    matched = true
+                    break
+                }
+            }
+        }
+        if (!matched) throw new Error(RECIPE_INPUTS_INVALID)
+    }
+
+    for (let ri = 0; ri < recipe.length; ri++) {
+        const stacks = groupedInputs[ri]
+        let provided = 0
+        for (const stack of stacks) {
+            provided += stack.quantity.toNumber()
+        }
+        const required = recipe[ri].quantity * craftQuantity
+        if (provided < required) throw new Error(RECIPE_INPUTS_INSUFFICIENT)
+        if (provided !== required) throw new Error(RECIPE_INPUTS_EXCESS)
+    }
+
+    for (const input of inputs) {
+        let found = false
+        for (const pc of projected.cargo) {
+            if (
+                pc.item_id.toNumber() === input.item_id.toNumber() &&
+                pc.stats.toString() === input.stats.toString()
+            ) {
+                if (pc.quantity.toNumber() < input.quantity.toNumber()) {
+                    throw new Error(RECIPE_INPUTS_INSUFFICIENT)
+                }
+                found = true
+                break
+            }
+        }
+        if (!found) throw new Error(SHIP_CARGO_NOT_LOADED)
+    }
+}
+
+export function validateSchedule(entity: Projectable): void {
+    if (!entity.schedule || entity.schedule.tasks.length === 0) return
+
+    const projected = createProjectedEntity(entity)
+    for (const task of entity.schedule.tasks) {
+        if (task.type.toNumber() === TaskType.CRAFT) {
+            validateCraftTask(task, projected)
+        }
+        applyTask(projected, task)
+        if (projected.capacity && projected.cargoMass.gt(projected.capacity)) {
+            throw new Error(ENTITY_CAPACITY_EXCEEDED)
+        }
+    }
+}
+
+export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity {
+    const projected = createProjectedEntity(entity)
+
+    if (!entity.schedule || entity.schedule.tasks.length === 0) {
+        return projected
+    }
+
+    for (let i = 0; i < entity.schedule.tasks.length; i++) {
+        const task = entity.schedule.tasks[i]
+        const taskComplete = schedule.isTaskComplete(entity, i, now)
+        const taskInProgress = schedule.isTaskInProgress(entity, i, now)
+
+        if (!taskComplete && !taskInProgress) {
+            break
+        }
+
+        const progress = taskInProgress
+            ? schedule.getTaskElapsed(entity, i, now) / task.duration.toNumber()
+            : undefined
+
+        switch (task.type.toNumber()) {
+            case TaskType.RECHARGE:
+                applyRechargeTask(projected, task, {complete: taskComplete, progress})
+                break
+            case TaskType.TRAVEL:
+                applyFlightTask(projected, task, {complete: taskComplete, progress})
+                break
+            case TaskType.LOAD:
+            case TaskType.UNWRAP:
+                if (taskComplete) applyAddCargoTask(projected, task)
+                break
+            case TaskType.UNLOAD:
+            case TaskType.WRAP:
+                if (taskComplete) applyRemoveCargoTask(projected, task)
+                break
+            case TaskType.GATHER:
+                if (taskComplete) applyGatherTask(projected, task, {complete: true})
+                break
+            case TaskType.CRAFT:
+                if (taskComplete) applyCraftTask(projected, task)
+                break
+            case TaskType.DEPLOY:
+                if (taskComplete) applyDeployTask(projected, task)
+                break
+        }
+    }
+
+    return projected
+}
+
+export function projectFromCurrentStateAt(
+    snapshot: ProjectableSnapshot,
+    now: Date
+): ProjectedEntity {
+    const projectable = buildRemainingProjectable(snapshot)
+    return projectable ? projectEntityAt(projectable, now) : createProjectedEntity(snapshot)
+}

package/src/scheduling/schedule.ts

@@ -0,0 +1,179 @@
+import type {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+
+type Schedule = ServerContract.Types.schedule
+type Task = ServerContract.Types.task
+
+export interface ScheduleData {
+    schedule?: Schedule
+}
+
+export interface Scheduleable extends ScheduleData {
+    hasSchedule: boolean
+    isIdle: boolean
+    tasks: Task[]
+    scheduleDuration(): number
+    scheduleElapsed(now: Date): number
+    scheduleRemaining(now: Date): number
+    scheduleComplete(now: Date): boolean
+    currentTaskIndex(now: Date): number
+    currentTask(now: Date): Task | undefined
+    currentTaskType(now: Date): TaskType | undefined
+    getTaskStartTime(index: number): number
+    getTaskElapsed(index: number, now: Date): number
+    getTaskRemaining(index: number, now: Date): number
+    isTaskComplete(index: number, now: Date): boolean
+    isTaskInProgress(index: number, now: Date): boolean
+    currentTaskProgress(now: Date): number
+    scheduleProgress(now: Date): number
+}
+
+export function hasSchedule(entity: ScheduleData): boolean {
+    return !!entity.schedule && entity.schedule.tasks.length > 0
+}
+
+export function isIdle(entity: ScheduleData): boolean {
+    return !hasSchedule(entity)
+}
+
+export function getTasks(entity: ScheduleData): Task[] {
+    return entity.schedule?.tasks || []
+}
+
+export function scheduleDuration(entity: ScheduleData): number {
+    if (!entity.schedule) return 0
+    return entity.schedule.tasks.reduce((sum, task) => sum + task.duration.toNumber(), 0)
+}
+
+export function scheduleElapsed(entity: ScheduleData, now: Date): number {
+    if (!entity.schedule) return 0
+    const started = entity.schedule.started.toDate()
+    const elapsed = Math.floor((now.getTime() - started.getTime()) / 1000)
+    return Math.max(0, elapsed)
+}
+
+export function scheduleRemaining(entity: ScheduleData, now: Date): number {
+    if (!entity.schedule) return 0
+    const duration = scheduleDuration(entity)
+    const elapsed = scheduleElapsed(entity, now)
+    return Math.max(0, duration - elapsed)
+}
+
+export function scheduleComplete(entity: ScheduleData, now: Date): boolean {
+    return hasSchedule(entity) && scheduleRemaining(entity, now) === 0
+}
+
+export function currentTaskIndex(entity: ScheduleData, now: Date): number {
+    if (!entity.schedule || entity.schedule.tasks.length === 0) return -1
+
+    const elapsed = scheduleElapsed(entity, now)
+    let timeAccum = 0
+
+    for (let i = 0; i < entity.schedule.tasks.length; i++) {
+        const taskDuration = entity.schedule.tasks[i].duration.toNumber()
+        if (elapsed < timeAccum + taskDuration) {
+            return i
+        }
+        timeAccum += taskDuration
+    }
+
+    return entity.schedule.tasks.length - 1
+}
+
+export function currentTask(entity: ScheduleData, now: Date): Task | undefined {
+    const index = currentTaskIndex(entity, now)
+    if (index < 0 || !entity.schedule) return undefined
+    return entity.schedule.tasks[index]
+}
+
+export function currentTaskType(entity: ScheduleData, now: Date): TaskType | undefined {
+    const task = currentTask(entity, now)
+    if (!task) return undefined
+    return task.type.toNumber() as TaskType
+}
+
+export function getTaskStartTime(entity: ScheduleData, index: number): number {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return 0
+    let timeAccum = 0
+    for (let i = 0; i < index; i++) {
+        timeAccum += entity.schedule.tasks[i].duration.toNumber()
+    }
+    return timeAccum
+}
+
+export function getTaskElapsed(entity: ScheduleData, index: number, now: Date): number {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return 0
+
+    const elapsed = scheduleElapsed(entity, now)
+    const taskStart = getTaskStartTime(entity, index)
+    const taskDuration = entity.schedule.tasks[index].duration.toNumber()
+
+    if (elapsed <= taskStart) return 0
+    const elapsedInTask = elapsed - taskStart
+    return Math.min(elapsedInTask, taskDuration)
+}
+
+export function getTaskRemaining(entity: ScheduleData, index: number, now: Date): number {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return 0
+
+    const taskDuration = entity.schedule.tasks[index].duration.toNumber()
+    const taskElapsed = getTaskElapsed(entity, index, now)
+    return Math.max(0, taskDuration - taskElapsed)
+}
+
+export function isTaskComplete(entity: ScheduleData, index: number, now: Date): boolean {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return false
+
+    const taskDuration = entity.schedule.tasks[index].duration.toNumber()
+    const taskElapsed = getTaskElapsed(entity, index, now)
+    return taskElapsed >= taskDuration
+}
+
+export function isTaskInProgress(entity: ScheduleData, index: number, now: Date): boolean {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return false
+
+    const taskElapsed = getTaskElapsed(entity, index, now)
+    const taskDuration = entity.schedule.tasks[index].duration.toNumber()
+    return taskElapsed > 0 && taskElapsed < taskDuration
+}
+
+export function currentTaskProgress(entity: ScheduleData, now: Date): number {
+    const task = currentTask(entity, now)
+    if (!task) return 0
+    const index = currentTaskIndex(entity, now)
+    const elapsed = getTaskElapsed(entity, index, now)
+    const duration = task.duration.toNumber()
+    if (duration === 0) return 1
+    return Math.min(1, elapsed / duration)
+}
+
+export function scheduleProgress(entity: ScheduleData, now: Date): number {
+    const duration = scheduleDuration(entity)
+    if (duration === 0) return hasSchedule(entity) ? 1 : 0
+    const elapsed = scheduleElapsed(entity, now)
+    return Math.min(1, elapsed / duration)
+}
+
+export function isTaskType(entity: ScheduleData, taskType: TaskType, now: Date): boolean {
+    return currentTaskType(entity, now) === taskType
+}
+
+export function isInFlight(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.TRAVEL, now)
+}
+
+export function isRecharging(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.RECHARGE, now)
+}
+
+export function isLoading(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.LOAD, now)
+}
+
+export function isUnloading(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.UNLOAD, now)
+}
+
+export function isGathering(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.GATHER, now)
+}