@shipload/sdk 2.0.0-rc1 → 2.0.0-rc2

package/src/scheduling/accessor.ts

@@ -0,0 +1,82 @@
+import {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+import {ScheduleData} from './schedule'
+import * as schedule from './schedule'
+
+type Task = ServerContract.Types.task
+
+export class ScheduleAccessor {
+    constructor(private entity: ScheduleData) {}
+
+    get hasSchedule(): boolean {
+        return schedule.hasSchedule(this.entity)
+    }
+
+    get isIdle(): boolean {
+        return schedule.isIdle(this.entity)
+    }
+
+    get tasks(): Task[] {
+        return schedule.getTasks(this.entity)
+    }
+
+    duration(): number {
+        return schedule.scheduleDuration(this.entity)
+    }
+
+    elapsed(now: Date): number {
+        return schedule.scheduleElapsed(this.entity, now)
+    }
+
+    remaining(now: Date): number {
+        return schedule.scheduleRemaining(this.entity, now)
+    }
+
+    complete(now: Date): boolean {
+        return schedule.scheduleComplete(this.entity, now)
+    }
+
+    currentTaskIndex(now: Date): number {
+        return schedule.currentTaskIndex(this.entity, now)
+    }
+
+    currentTask(now: Date): Task | undefined {
+        return schedule.currentTask(this.entity, now)
+    }
+
+    currentTaskType(now: Date): TaskType | undefined {
+        return schedule.currentTaskType(this.entity, now)
+    }
+
+    taskStartTime(index: number): number {
+        return schedule.getTaskStartTime(this.entity, index)
+    }
+
+    taskElapsed(index: number, now: Date): number {
+        return schedule.getTaskElapsed(this.entity, index, now)
+    }
+
+    taskRemaining(index: number, now: Date): number {
+        return schedule.getTaskRemaining(this.entity, index, now)
+    }
+
+    taskComplete(index: number, now: Date): boolean {
+        return schedule.isTaskComplete(this.entity, index, now)
+    }
+
+    taskInProgress(index: number, now: Date): boolean {
+        return schedule.isTaskInProgress(this.entity, index, now)
+    }
+
+    currentTaskProgress(now: Date): number {
+        return schedule.currentTaskProgress(this.entity, now)
+    }
+
+    progress(now: Date): number {
+        return schedule.scheduleProgress(this.entity, now)
+    }
+}
+
+export function createScheduleAccessor(entity: ScheduleData): ScheduleAccessor {
+    return new ScheduleAccessor(entity)
+}

package/src/scheduling/projection.ts

@@ -1,15 +1,19 @@
-import {UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+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 {calcCargoMass} from '../capabilities/storage'
 import {getGood} from '../market/goods'
 import * as schedule from './schedule'
 import {ScheduleData} from './schedule'
 
-/**
- * Projected state of an entity after scheduled tasks complete.
- * Mirrors contract's projected_entity struct.
- */
 export interface ProjectedEntity {
     location: Coordinates
     energy: UInt16
@@ -19,41 +23,56 @@ export interface ProjectedEntity {
     engines?: ServerContract.Types.movement_stats
     loaders?: ServerContract.Types.loader_stats
     generator?: ServerContract.Types.energy_stats
+    trade?: ServerContract.Types.trade_stats
     readonly totalMass: UInt64
+
+    hasMovement(): boolean
+    hasStorage(): boolean
+    hasLoaders(): boolean
+    hasTrade(): boolean
+
+    capabilities(): EntityCapabilities
+    state(): EntityState
 }
 
-/**
- * Interface for entities that can be projected.
- * Ships and Warehouses both implement this.
- */
 export interface Projectable extends ScheduleData {
-    location: Coordinates
-    energy: UInt16
-    mass: UInt32
+    coordinates: Coordinates | ServerContract.Types.coordinates
+    energy?: UInt16
+    hullmass?: UInt32
     generator?: ServerContract.Types.energy_stats
     engines?: ServerContract.Types.movement_stats
     loaders?: ServerContract.Types.loader_stats
-    capacity?: UInt64
-    calcCargoMass(): UInt64
+    trade?: ServerContract.Types.trade_stats
+    capacity?: UInt32
+    cargo: ServerContract.Types.cargo_item[]
+    cargomass: UInt32
+    owner?: Name
+}
+
+function getHullMass(entity: Projectable): UInt32 {
+    return UInt32.from(entity.hullmass ?? 0)
 }
 
-/**
- * Create initial projected entity state from a projectable entity.
- */
 export function createProjectedEntity(entity: Projectable): ProjectedEntity {
-    const cargoMass = entity.calcCargoMass()
-    const shipMass = UInt32.from(entity.mass)
+    const cargoMass = calcCargoMass(entity)
+    const shipMass = getHullMass(entity)
     const loaders = entity.loaders
+    const engines = entity.engines
+    const generator = entity.generator
+    const trade = entity.trade
+    const capacity = entity.capacity
 
-    return {
-        location: Coordinates.from(entity.location),
-        energy: UInt16.from(entity.energy),
+    const projected: ProjectedEntity = {
+        location: Coordinates.from(entity.coordinates),
+        energy: UInt16.from(entity.energy ?? 0),
         cargoMass,
         shipMass,
-        capacity: entity.capacity,
-        engines: entity.engines,
-        generator: entity.generator,
+        capacity: capacity ? UInt64.from(capacity) : undefined,
+        engines,
+        generator,
         loaders,
+        trade,
+
         get totalMass() {
             let mass = UInt64.from(this.shipMass).adding(this.cargoMass)
             if (this.loaders) {
@@ -61,12 +80,48 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
             }
             return mass
         },
+
+        hasMovement() {
+            return capsHasMovement(this.capabilities())
+        },
+
+        hasStorage() {
+            return capsHasStorage(this.capabilities())
+        },
+
+        hasLoaders() {
+            return capsHasLoaders(this.capabilities())
+        },
+
+        hasTrade() {
+            return this.trade !== undefined
+        },
+
+        capabilities(): EntityCapabilities {
+            return {
+                hullmass: this.shipMass,
+                capacity: this.capacity ? UInt32.from(this.capacity) : undefined,
+                engines: this.engines,
+                generator: this.generator,
+                loaders: this.loaders,
+                trade: this.trade,
+            }
+        },
+
+        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
 }
 
-/**
- * Apply a recharge task to projected state.
- */
 function applyRechargeTask(
     projected: ProjectedEntity,
     _task: ServerContract.Types.task,
@@ -84,19 +139,16 @@ function applyRechargeTask(
     }
 }
 
-/**
- * Apply a flight task to projected state.
- */
 function applyFlightTask(
     projected: ProjectedEntity,
     task: ServerContract.Types.task,
     options: {complete: boolean; progress?: number}
 ): void {
-    if (!task.location || !projected.engines) return
+    if (!task.coordinates || !projected.engines) return
 
     const origin = projected.location
-    const destination = Coordinates.from(task.location)
-    const distance = distanceBetweenCoordinates(origin, task.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) {
@@ -117,33 +169,48 @@ function applyFlightTask(
     }
 }
 
-/**
- * Apply a load task to projected state.
- */
+function getGoodMass(good_id: UInt16 | number): UInt32 {
+    const good = getGood(good_id)
+    return good.mass
+}
+
 function applyLoadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     for (const item of task.cargo) {
-        const good = getGood(item.good_id)
-        projected.cargoMass = projected.cargoMass.adding(good.mass.multiplying(item.quantity))
+        const good_mass = getGoodMass(item.good_id)
+        projected.cargoMass = projected.cargoMass.adding(good_mass.multiplying(item.quantity))
     }
 }
 
-/**
- * Apply an unload task to projected state.
- */
 function applyUnloadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     for (const item of task.cargo) {
-        const good = getGood(item.good_id)
-        const cargoMass = good.mass.multiplying(item.quantity)
+        const good_mass = getGoodMass(item.good_id)
+        const cargoMass = good_mass.multiplying(item.quantity)
         projected.cargoMass = projected.cargoMass.gt(cargoMass)
             ? projected.cargoMass.subtracting(cargoMass)
             : UInt64.from(0)
     }
 }
 
-/**
- * Project entity state after all scheduled tasks complete.
- * Mirrors contract's project_ship/project_warehouse methods.
- */
+function applyExtractTask(
+    projected: ProjectedEntity,
+    task: ServerContract.Types.task,
+    options: {complete: boolean}
+): void {
+    if (!options.complete) return
+
+    if (task.energy_cost) {
+        const energyCost = UInt16.from(task.energy_cost)
+        projected.energy = projected.energy.gt(energyCost)
+            ? UInt16.from(projected.energy.subtracting(energyCost))
+            : UInt16.from(0)
+    }
+
+    for (const item of task.cargo) {
+        const good_mass = getGoodMass(item.good_id)
+        projected.cargoMass = projected.cargoMass.adding(good_mass.multiplying(item.quantity))
+    }
+}
+
 export function projectEntity(entity: Projectable): ProjectedEntity {
     const projected = createProjectedEntity(entity)
 
@@ -156,7 +223,7 @@ export function projectEntity(entity: Projectable): ProjectedEntity {
             case TaskType.RECHARGE:
                 applyRechargeTask(projected, task, {complete: true})
                 break
-            case TaskType.FLIGHT:
+            case TaskType.TRAVEL:
                 applyFlightTask(projected, task, {complete: true})
                 break
             case TaskType.LOAD:
@@ -165,15 +232,15 @@ export function projectEntity(entity: Projectable): ProjectedEntity {
             case TaskType.UNLOAD:
                 applyUnloadTask(projected, task)
                 break
+            case TaskType.EXTRACT:
+                applyExtractTask(projected, task, {complete: true})
+                break
         }
     }
 
     return projected
 }
 
-/**
- * Project entity state at a specific time (partial task execution).
- */
 export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity {
     const projected = createProjectedEntity(entity)
 
@@ -198,7 +265,7 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
             case TaskType.RECHARGE:
                 applyRechargeTask(projected, task, {complete: taskComplete, progress})
                 break
-            case TaskType.FLIGHT:
+            case TaskType.TRAVEL:
                 applyFlightTask(projected, task, {complete: taskComplete, progress})
                 break
             case TaskType.LOAD:
@@ -211,6 +278,11 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
                     applyUnloadTask(projected, task)
                 }
                 break
+            case TaskType.EXTRACT:
+                if (taskComplete) {
+                    applyExtractTask(projected, task, {complete: true})
+                }
+                break
         }
     }
 

package/src/scheduling/schedule.ts

@@ -153,3 +153,27 @@ export function scheduleProgress(entity: ScheduleData, now: Date): number {
     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)
+}

package/src/trading/collect.ts

@@ -10,7 +10,6 @@ import {
     distanceBetweenCoordinates,
     EstimatedTravelTime,
     estimateTravelTime,
-    hasEnergyForDistance,
 } from '../travel/travel'
 import {getGood, getGoods} from '../market/goods'
 import {getRarity, Rarities} from '../market/market'

package/src/trading/deal.ts

@@ -6,7 +6,6 @@ import {
     distanceBetweenCoordinates,
     type EstimatedTravelTime,
     estimateTravelTime,
-    hasEnergyForDistance,
 } from '../travel/travel'
 import {calculateProfitPerSecond, calculateTradeProfit, isProfitable} from './trade'
 

package/src/travel/travel.ts

@@ -29,6 +29,7 @@ import {
     MIN_ORBITAL_ALTITUDE,
     PRECISION,
     ShipLike,
+    TaskType,
 } from '../types'
 import {getGood} from '../market/goods'
 import {hasSystem} from '../utils/system'
@@ -133,7 +134,7 @@ export function calc_flighttime(distance: UInt64Type, acceleration: number): UIn
 }
 
 export function calc_loader_flighttime(ship: ShipLike, mass: UInt64, altitude?: number): UInt32 {
-    const z = altitude ?? ship.location.z?.toNumber() ?? calc_orbital_altitude(Number(mass))
+    const z = altitude ?? ship.coordinates.z?.toNumber() ?? calc_orbital_altitude(Number(mass))
     return calc_flighttime(z, calc_loader_acceleration(ship, mass))
 }
 
@@ -157,7 +158,7 @@ export function calc_acceleration(thrust: number, mass: number): number {
 export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64 {
     const mass = UInt64.from(0)
 
-    mass.add(ship.mass)
+    mass.add(ship.hullmass)
 
     if (ship.loaders.quantity.gt(UInt32.zero)) {
         mass.add(ship.loaders.mass.multiplying(ship.loaders.quantity))
@@ -358,6 +359,66 @@ export interface TransferEntity {
     }
 }
 
+export interface HasScheduleAndLocation {
+    coordinates: ServerContract.ActionParams.Type.coordinates
+    schedule?: ServerContract.Types.schedule
+}
+
+export function getFlightOrigin(
+    entity: HasScheduleAndLocation,
+    flightTaskIndex: number
+): ServerContract.ActionParams.Type.coordinates {
+    if (!entity.schedule) return entity.coordinates
+
+    let origin = entity.coordinates
+    for (let i = 0; i < flightTaskIndex && i < entity.schedule.tasks.length; i++) {
+        const task = entity.schedule.tasks[i]
+        if (task.type.equals(TaskType.TRAVEL) && task.coordinates) {
+            origin = task.coordinates
+        }
+    }
+    return origin
+}
+
+export function getDestinationLocation(
+    entity: HasScheduleAndLocation
+): ServerContract.ActionParams.Type.coordinates | undefined {
+    if (!entity.schedule) return undefined
+
+    for (let i = entity.schedule.tasks.length - 1; i >= 0; i--) {
+        const task = entity.schedule.tasks[i]
+        if (task.type.equals(TaskType.TRAVEL) && task.coordinates) {
+            return task.coordinates
+        }
+    }
+    return undefined
+}
+
+export function getPositionAt(
+    entity: HasScheduleAndLocation,
+    taskIndex: number,
+    taskProgress: number
+): ServerContract.ActionParams.Type.coordinates {
+    if (!entity.schedule || entity.schedule.tasks.length === 0 || taskIndex < 0) {
+        return entity.coordinates
+    }
+
+    const task = entity.schedule.tasks[taskIndex]
+
+    if (!task.type.equals(TaskType.TRAVEL) || !task.coordinates) {
+        return getFlightOrigin(entity, taskIndex)
+    }
+
+    const origin = getFlightOrigin(entity, taskIndex)
+    const destination = task.coordinates
+
+    const interpolated = lerp(origin, destination, taskProgress)
+    return {
+        x: Math.round(interpolated.x),
+        y: Math.round(interpolated.y),
+    }
+}
+
 export function calc_transfer_duration(
     source: TransferEntity,
     dest: TransferEntity,

package/src/types/capabilities.ts

@@ -0,0 +1,79 @@
+import {Name, UInt16, UInt32} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+
+export interface MovementCapability {
+    engines: ServerContract.Types.movement_stats
+    generator: ServerContract.Types.energy_stats
+}
+
+export interface EnergyCapability {
+    energy: UInt16
+}
+
+export interface StorageCapability {
+    capacity: UInt32
+    cargomass: UInt32
+    cargo: ServerContract.Types.cargo_item[]
+}
+
+export interface LoaderCapability {
+    loaders: ServerContract.Types.loader_stats
+}
+
+export interface TradeCapability {
+    trade: ServerContract.Types.trade_stats
+}
+
+export interface ExtractorCapability {
+    extractor: ServerContract.Types.extractor_stats
+}
+
+export interface MassCapability {
+    hullmass: UInt32
+}
+
+export interface ScheduleCapability {
+    schedule?: ServerContract.Types.schedule
+}
+
+export interface EntityCapabilities {
+    hullmass?: UInt32
+    capacity?: UInt32
+    engines?: ServerContract.Types.movement_stats
+    generator?: ServerContract.Types.energy_stats
+    loaders?: ServerContract.Types.loader_stats
+    trade?: ServerContract.Types.trade_stats
+    extractor?: ServerContract.Types.extractor_stats
+}
+
+export interface EntityState {
+    owner: Name
+    location: ServerContract.Types.coordinates
+    energy?: UInt16
+    cargomass: UInt32
+    cargo: ServerContract.Types.cargo_item[]
+}
+
+export function capsHasMovement(caps: EntityCapabilities): boolean {
+    return caps.engines !== undefined && caps.generator !== undefined
+}
+
+export function capsHasStorage(caps: EntityCapabilities): boolean {
+    return caps.capacity !== undefined
+}
+
+export function capsHasLoaders(caps: EntityCapabilities): boolean {
+    return caps.loaders !== undefined
+}
+
+export function capsHasTrade(caps: EntityCapabilities): boolean {
+    return caps.trade !== undefined
+}
+
+export function capsHasExtractor(caps: EntityCapabilities): boolean {
+    return caps.extractor !== undefined
+}
+
+export function capsHasMass(caps: EntityCapabilities): boolean {
+    return caps.hullmass !== undefined
+}

package/src/types/entity-traits.ts

@@ -0,0 +1,70 @@
+import {Name} from '@wharfkit/antelope'
+
+export const ENTITY_SHIP = Name.from('ship')
+export const ENTITY_WAREHOUSE = Name.from('warehouse')
+export const ENTITY_CONTAINER = Name.from('container')
+
+export type EntityTypeName = 'ship' | 'warehouse' | 'container'
+
+export interface EntityTraits {
+    typeName: Name
+    isMovable: boolean
+    hasEnergy: boolean
+    hasLoaders: boolean
+    hasTrade: boolean
+    notFoundError: string
+}
+
+export const shipTraits: EntityTraits = {
+    typeName: ENTITY_SHIP,
+    isMovable: true,
+    hasEnergy: true,
+    hasLoaders: true,
+    hasTrade: true,
+    notFoundError: 'ship not found',
+}
+
+export const warehouseTraits: EntityTraits = {
+    typeName: ENTITY_WAREHOUSE,
+    isMovable: false,
+    hasEnergy: false,
+    hasLoaders: true,
+    hasTrade: false,
+    notFoundError: 'warehouse not found',
+}
+
+export const containerTraits: EntityTraits = {
+    typeName: ENTITY_CONTAINER,
+    isMovable: true,
+    hasEnergy: false,
+    hasLoaders: false,
+    hasTrade: false,
+    notFoundError: 'container not found',
+}
+
+export function getEntityTraits(entityType: Name | EntityTypeName): EntityTraits {
+    const typeName = typeof entityType === 'string' ? entityType : entityType.toString()
+
+    switch (typeName) {
+        case 'ship':
+            return shipTraits
+        case 'warehouse':
+            return warehouseTraits
+        case 'container':
+            return containerTraits
+        default:
+            throw new Error(`Unknown entity type: ${typeName}`)
+    }
+}
+
+export function isShip(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_SHIP) ?? false
+}
+
+export function isWarehouse(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_WAREHOUSE) ?? false
+}
+
+export function isContainer(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_CONTAINER) ?? false
+}

package/src/types/entity.ts

@@ -0,0 +1,36 @@
+import {Name, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {Coordinates} from '../types'
+import {
+    EnergyCapability,
+    LoaderCapability,
+    MassCapability,
+    MovementCapability,
+    ScheduleCapability,
+    StorageCapability,
+} from './capabilities'
+
+export interface Entity {
+    id: UInt64
+    type: Name
+    owner: Name
+    entity_name: string
+    location: Coordinates | ServerContract.Types.coordinates
+}
+
+export type ShipEntity = Entity &
+    MovementCapability &
+    EnergyCapability &
+    StorageCapability &
+    LoaderCapability &
+    MassCapability &
+    ScheduleCapability & {
+        trade?: ServerContract.Types.trade_stats
+        extractor?: ServerContract.Types.extractor_stats
+    }
+
+export type WarehouseEntity = Entity & StorageCapability & LoaderCapability & ScheduleCapability
+
+export type ContainerEntity = Entity & StorageCapability & MassCapability & ScheduleCapability
+
+export type AnyEntity = ShipEntity | WarehouseEntity | ContainerEntity

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './capabilities'
+export * from './entity'
+export * from './entity-traits'