@shipload/sdk 0.7.1 → 2.0.0-rc10

package/src/scheduling/projection.ts

@@ -0,0 +1,322 @@
+import {Name, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {Coordinates, PRECISION, TaskType} from '../types'
+import {
+    capsHasLoaders,
+    capsHasMovement,
+    capsHasStorage,
+    EntityCapabilities,
+    EntityState,
+} from '../types/capabilities'
+import {distanceBetweenCoordinates, lerp} from '../travel/travel'
+import {calcCargoItemMass, calcCargoMass} from '../capabilities/storage'
+import * as schedule from './schedule'
+import {ScheduleData} from './schedule'
+
+export interface ProjectedEntity {
+    location: Coordinates
+    energy: UInt16
+    cargoMass: UInt64
+    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 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 cargoMass = calcCargoMass(entity)
+    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 projected: ProjectedEntity = {
+        location: Coordinates.from(entity.coordinates),
+        energy: UInt16.from(entity.energy ?? 0),
+        cargoMass,
+        shipMass,
+        capacity: capacity ? UInt64.from(capacity) : undefined,
+        engines,
+        generator,
+        hauler,
+        loaders,
+
+        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: entity.cargo,
+            }
+        },
+    }
+
+    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 applyLoadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    for (const item of task.cargo) {
+        projected.cargoMass = projected.cargoMass.adding(calcCargoItemMass(item))
+    }
+}
+
+function applyUnloadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    for (const item of task.cargo) {
+        const cargoMass = calcCargoItemMass(item)
+        projected.cargoMass = projected.cargoMass.gt(cargoMass)
+            ? projected.cargoMass.subtracting(cargoMass)
+            : UInt64.from(0)
+    }
+}
+
+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 applyExtractTask(
+    projected: ProjectedEntity,
+    task: ServerContract.Types.task,
+    options: {complete: boolean}
+): void {
+    if (!options.complete) return
+
+    applyEnergyCost(projected, task)
+
+    for (const item of task.cargo) {
+        projected.cargoMass = projected.cargoMass.adding(calcCargoItemMass(item))
+    }
+}
+
+function applyCraftTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    applyEnergyCost(projected, task)
+
+    if (task.cargo.length > 0) {
+        for (let i = 0; i < task.cargo.length - 1; i++) {
+            const inputMass = calcCargoItemMass(task.cargo[i])
+            projected.cargoMass = projected.cargoMass.gt(inputMass)
+                ? projected.cargoMass.subtracting(inputMass)
+                : UInt64.from(0)
+        }
+        const output = task.cargo[task.cargo.length - 1]
+        projected.cargoMass = projected.cargoMass.adding(calcCargoItemMass(output))
+    }
+}
+
+function applyDeployTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    applyEnergyCost(projected, task)
+
+    if (task.cargo.length > 0) {
+        const mass = calcCargoItemMass(task.cargo[0])
+        projected.cargoMass = projected.cargoMass.gt(mass)
+            ? projected.cargoMass.subtracting(mass)
+            : UInt64.from(0)
+    }
+}
+
+export function projectEntity(entity: Projectable): ProjectedEntity {
+    const projected = createProjectedEntity(entity)
+
+    if (!entity.schedule) {
+        return projected
+    }
+
+    for (const task of entity.schedule.tasks) {
+        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:
+                applyLoadTask(projected, task)
+                break
+            case TaskType.UNLOAD:
+                applyUnloadTask(projected, task)
+                break
+            case TaskType.EXTRACT:
+                applyExtractTask(projected, task, {complete: true})
+                break
+            case TaskType.CRAFT:
+                applyCraftTask(projected, task)
+                break
+            case TaskType.DEPLOY:
+            case TaskType.DEPLOY_SHIP:
+                applyDeployTask(projected, task)
+                break
+        }
+    }
+
+    return projected
+}
+
+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:
+                if (taskComplete) {
+                    applyLoadTask(projected, task)
+                }
+                break
+            case TaskType.UNLOAD:
+                if (taskComplete) {
+                    applyUnloadTask(projected, task)
+                }
+                break
+            case TaskType.EXTRACT:
+                if (taskComplete) {
+                    applyExtractTask(projected, task, {complete: true})
+                }
+                break
+            case TaskType.CRAFT:
+                if (taskComplete) {
+                    applyCraftTask(projected, task)
+                }
+                break
+            case TaskType.DEPLOY:
+            case TaskType.DEPLOY_SHIP:
+                if (taskComplete) {
+                    applyDeployTask(projected, task)
+                }
+                break
+        }
+    }
+
+    return projected
+}

package/src/scheduling/schedule.ts

@@ -0,0 +1,179 @@
+import {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 isExtracting(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.EXTRACT, now)
+}