@shipload/sdk 0.7.0 → 1.0.0-beta1

package/src/entities/ship.ts

@@ -0,0 +1,204 @@
+import {type UInt16, type UInt16Type, UInt32, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {Coordinates, type CoordinatesType} from '../types'
+import {
+    getDestinationLocation,
+    getPositionAt,
+    getFlightOrigin as travelGetFlightOrigin,
+} from '../travel/travel'
+import {
+    type ProjectedEntity,
+    projectFromCurrentState as sharedProjectFromCurrentState,
+    projectFromCurrentStateAt as sharedProjectFromCurrentStateAt,
+} from '../scheduling/projection'
+import {Location} from './location'
+import {ScheduleAccessor} from '../scheduling/accessor'
+import {InventoryAccessor} from './inventory-accessor'
+import type {EntityInventory} from './entity-inventory'
+import {
+    energyPercent as calcEnergyPercent,
+    needsRecharge as calcNeedsRecharge,
+    hasEnergyForDistance,
+    maxTravelDistance,
+} from '../capabilities/movement'
+import * as schedule from '../scheduling/schedule'
+
+export interface PackedModuleInput {
+    itemId: UInt16Type
+    stats: UInt64Type
+}
+
+export interface ShipStateInput {
+    id: UInt64Type
+    owner: string
+    name: string
+    coordinates: CoordinatesType | {x: number; y: number; z?: number}
+    hullmass?: number
+    capacity?: number
+    energy?: number
+    modules?: PackedModuleInput[]
+    schedule?: ServerContract.Types.schedule
+    cargo?: ServerContract.Types.cargo_item[]
+}
+
+type MovementEntity = {
+    engines: ServerContract.Types.movement_stats
+    generator: ServerContract.Types.energy_stats
+    energy: UInt16
+}
+
+export class Ship extends ServerContract.Types.entity_info {
+    private _sched?: ScheduleAccessor
+    private _inv?: InventoryAccessor
+
+    get name(): string {
+        return this.entity_name
+    }
+
+    get inv(): InventoryAccessor {
+        this._inv ??= new InventoryAccessor(this)
+        return this._inv
+    }
+
+    get inventory(): EntityInventory[] {
+        return this.inv.items
+    }
+
+    get sched(): ScheduleAccessor {
+        this._sched ??= new ScheduleAccessor(this)
+        return this._sched
+    }
+
+    get maxDistance(): UInt32 {
+        if (!this.generator || !this.engines) return UInt32.from(0)
+        return maxTravelDistance(this as MovementEntity)
+    }
+
+    get isIdle(): boolean {
+        return this.is_idle
+    }
+
+    getFlightOrigin(flightTaskIndex: number): Coordinates {
+        return Coordinates.from(travelGetFlightOrigin(this, flightTaskIndex))
+    }
+
+    destinationLocation(): Coordinates | undefined {
+        const dest = getDestinationLocation(this)
+        return dest ? Coordinates.from(dest) : undefined
+    }
+
+    positionAt(now: Date): Coordinates {
+        const taskIndex = this.sched.currentTaskIndex(now)
+        const progress = this.sched.currentTaskProgress(now)
+        return Coordinates.from(getPositionAt(this, taskIndex, progress))
+    }
+
+    isInFlight(now: Date): boolean {
+        return schedule.isInFlight(this, now)
+    }
+
+    isRecharging(now: Date): boolean {
+        return schedule.isRecharging(this, now)
+    }
+
+    isLoading(now: Date): boolean {
+        return schedule.isLoading(this, now)
+    }
+
+    isUnloading(now: Date): boolean {
+        return schedule.isUnloading(this, now)
+    }
+
+    isGathering(now: Date): boolean {
+        return schedule.isGathering(this, now)
+    }
+
+    get hasEngines(): boolean {
+        return this.engines !== undefined
+    }
+
+    get hasGenerator(): boolean {
+        return this.generator !== undefined
+    }
+
+    get hasGatherer(): boolean {
+        return this.gatherer !== undefined
+    }
+
+    get hasWarp(): boolean {
+        return this.warp !== undefined
+    }
+
+    project(): ProjectedEntity {
+        return sharedProjectFromCurrentState(this)
+    }
+
+    projectAt(now: Date): ProjectedEntity {
+        return sharedProjectFromCurrentStateAt(this, now)
+    }
+
+    get location(): Location {
+        return Location.from(this.coordinates)
+    }
+
+    get totalCargoMass(): UInt64 {
+        return this.inv.totalMass
+    }
+
+    get totalMass(): UInt64 {
+        let mass = UInt64.from(this.hullmass ?? 0).adding(this.totalCargoMass)
+        if (this.loaders) {
+            mass = mass.adding(UInt64.from(this.loaders.mass).multiplying(this.loaders.quantity))
+        }
+        return mass
+    }
+
+    get maxCapacity(): UInt64 {
+        return UInt64.from(this.capacity)
+    }
+
+    hasSpace(goodMass: UInt64, quantity: number): boolean {
+        return this.totalMass.adding(goodMass.multiplying(quantity)).lte(this.maxCapacity)
+    }
+
+    get availableCapacity(): UInt64 {
+        return this.totalMass.gte(this.maxCapacity)
+            ? UInt64.from(0)
+            : this.maxCapacity.subtracting(this.totalMass)
+    }
+
+    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined {
+        return this.inv.forItem(goodId)
+    }
+
+    get sellableCargo(): EntityInventory[] {
+        return this.inv.sellable
+    }
+
+    get hasSellableCargo(): boolean {
+        return this.inv.hasSellable
+    }
+
+    get sellableGoodsCount(): number {
+        return this.inv.sellableCount
+    }
+
+    get isFull(): boolean {
+        return this.totalMass.gte(this.maxCapacity)
+    }
+
+    get energyPercent(): number {
+        if (!this.generator || this.energy === undefined) return 0
+        return calcEnergyPercent(this as MovementEntity)
+    }
+
+    get needsRecharge(): boolean {
+        if (!this.generator || this.energy === undefined) return false
+        return calcNeedsRecharge(this as MovementEntity)
+    }
+
+    hasEnergyFor(distance: UInt64): boolean {
+        if (!this.engines || !this.generator || this.energy === undefined) return false
+        return hasEnergyForDistance(this as MovementEntity, distance)
+    }
+}

package/src/entities/warehouse.ts

@@ -0,0 +1,119 @@
+import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import type {CoordinatesType} from '../types'
+import {Location} from './location'
+import {ScheduleAccessor} from '../scheduling/accessor'
+import {InventoryAccessor} from './inventory-accessor'
+import type {EntityInventory} from './entity-inventory'
+import * as schedule from '../scheduling/schedule'
+import type {PackedModuleInput} from './ship'
+import {decodeCraftedItemStats} from '../derivation/crafting'
+import {getModuleCapabilityType, MODULE_LOADER} from '../capabilities/modules'
+import {computeLoaderCapabilities} from './ship-deploy'
+
+export interface WarehouseStateInput {
+    id: UInt64Type
+    owner: string
+    name: string
+    coordinates: CoordinatesType | {x: number; y: number; z?: number}
+    hullmass?: number
+    capacity: number
+    modules?: PackedModuleInput[]
+    schedule?: ServerContract.Types.schedule
+    cargo?: ServerContract.Types.cargo_item[]
+}
+
+export class Warehouse extends ServerContract.Types.entity_info {
+    private _sched?: ScheduleAccessor
+    private _inv?: InventoryAccessor
+
+    get name(): string {
+        return this.entity_name
+    }
+
+    get inv(): InventoryAccessor {
+        this._inv ??= new InventoryAccessor(this)
+        return this._inv
+    }
+
+    get inventory(): EntityInventory[] {
+        return this.inv.items
+    }
+
+    get sched(): ScheduleAccessor {
+        this._sched ??= new ScheduleAccessor(this)
+        return this._sched
+    }
+
+    get isIdle(): boolean {
+        return this.is_idle
+    }
+
+    isLoading(now: Date): boolean {
+        return schedule.isLoading(this, now)
+    }
+
+    isUnloading(now: Date): boolean {
+        return schedule.isUnloading(this, now)
+    }
+
+    get location(): Location {
+        return Location.from(this.coordinates)
+    }
+
+    get totalCargoMass(): UInt64 {
+        return this.inv.totalMass
+    }
+
+    get maxCapacity(): UInt64 {
+        return UInt64.from(this.capacity)
+    }
+
+    get availableCapacity(): UInt64 {
+        const cargo = this.totalCargoMass
+        return cargo.gte(this.maxCapacity) ? UInt64.from(0) : this.maxCapacity.subtracting(cargo)
+    }
+
+    hasSpace(goodMass: UInt64, quantity: number): boolean {
+        return this.totalCargoMass.adding(goodMass.multiplying(quantity)).lte(this.maxCapacity)
+    }
+
+    get isFull(): boolean {
+        return this.totalCargoMass.gte(this.maxCapacity)
+    }
+
+    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined {
+        return this.inv.forItem(goodId)
+    }
+
+    get orbitalAltitude(): number {
+        return this.coordinates.z?.toNumber() || 0
+    }
+
+    get totalMass(): UInt64 {
+        const hull = this.hullmass ? UInt64.from(this.hullmass) : UInt64.from(0)
+        return hull.adding(this.totalCargoMass)
+    }
+}
+
+export function computeWarehouseCapabilities(modules: {itemId: number; stats: bigint}[]): {
+    loaders?: {mass: number; thrust: number; quantity: number}
+} {
+    const warehouse: {loaders?: {mass: number; thrust: number; quantity: number}} = {}
+
+    const loaderModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_LOADER)
+    if (loaderModules.length > 0) {
+        let totalMass = 0
+        let totalThrust = 0
+        let totalQuantity = 0
+        for (const m of loaderModules) {
+            const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            totalMass += caps.mass
+            totalThrust += caps.thrust
+            totalQuantity += caps.quantity
+        }
+        warehouse.loaders = {mass: totalMass, thrust: totalThrust, quantity: totalQuantity}
+    }
+
+    return warehouse
+}

package/src/errors.ts

@@ -1,9 +1,100 @@
-export const ERROR_SYSTEM_NOT_INITIALIZED = 'System not initialized'
-export const GOOD_DOES_NOT_EXIST = 'Good does not exist'
-export const GOOD_NOT_AVAILABLE_AT_LOCATION = 'Good not available at location'
-export const PLAYER_NOT_FOUND = 'Player not found'
-export const SHIP_NOT_FOUND = 'Ship not found'
-export const SHIP_CANNOT_BUY_TRAVELING = 'Ship cannot buy while traveling'
-export const INSUFFICIENT_BALANCE = 'Insufficient balance'
-export const INSUFFICIENT_GOOD_QUANTITY = 'Insufficient good quantity'
-export const REQUIRES_MORE_THAN_ONE = 'Requires more than one'
+export const COMPANY_NOT_FOUND = 'Cannot find company for given account.'
+export const COMMIT_ALREADY_SET = 'Commit has already been set.'
+export const COMMIT_CANNOT_MATCH = 'Next commit cannot match current commit.'
+export const COMMIT_NOT_SET = 'Commit has not been set.'
+export const EPOCH_NON_ZERO = 'Epoch must be greater than zero.'
+export const EPOCH_NOT_READY = 'Current epoch is not ready to advance'
+export const ERROR_SYSTEM_ALREADY_INITIALIZED = 'This game has already been initialized.'
+export const ERROR_SYSTEM_DISABLED = 'This game is currently disabled.'
+export const ERROR_SYSTEM_NOT_INITIALIZED = 'This game has not been initialized.'
+export const GAME_NOT_FOUND = 'Cannot find game for given account name.'
+export const GAME_SEED_NOT_SET = 'This game has not initialized an epoch seed value.'
+export const ITEM_DOES_NOT_EXIST = 'Item does not exist.'
+export const INVALID_AMOUNT = 'Invalid amount.'
+export const REQUIRES_MORE_THAN_ONE = 'A value greater than one is required.'
+export const REQUIRES_POSITIVE_VALUE = 'Value must be greater than zero.'
+export const PLAYER_ALREADY_JOINED = 'Player has already joined the game.'
+export const PLAYER_NOT_JOINED = 'Player has not joined the game.'
+export const PLAYER_NOT_FOUND = 'Cannot find player for given account name.'
+export const STARTER_ALREADY_CLAIMED =
+    'Starter ship already claimed; destroy existing ships to re-claim.'
+export const SHIP_ALREADY_THERE = 'Ship cannot travel to the location its already at.'
+export const SHIP_ALREADY_TRAVELING = 'Ship is already traveling.'
+export const SHIP_CANNOT_BUY_TRAVELING = 'Ship cannot buy goods while traveling.'
+export const SHIP_CANNOT_UPDATE_TRAVELING = 'Ship cannot be updated while traveling.'
+export const SHIP_INVALID_DESTINATION = 'Ship cannot travel, no system at specified destination.'
+export const SHIP_INVALID_TRAVEL_DURATION =
+    'This trip cannot be made as it would exceed the maximum travel duration.'
+export const SHIP_NOT_ARRIVED = 'Ship has not yet arrived at its destination.'
+export const SHIP_NOT_ENOUGH_ENERGY =
+    'Ship does not have enough energy to travel to the destination.'
+export const SHIP_NOT_ENOUGH_ENERGY_CAPACITY =
+    'Ship does not have enough energy capacity to travel.'
+export const SHIP_NOT_FOUND = 'Cannot find ship for given account.'
+export const SHIP_NOT_OWNED = 'Ship is not owned by this account.'
+export const NO_SCHEDULE = 'No scheduled tasks.'
+export const SHIP_NOT_IDLE = 'Ship must be idle (no active schedule) for this action.'
+export const SHIP_NO_COMPLETED_TASKS = 'No completed tasks to resolve.'
+export const RESOLVE_COUNT_EXCEEDS_COMPLETED = 'Requested resolve count exceeds completed tasks.'
+export const SHIP_CANNOT_CANCEL_TASK = 'Cannot cancel task that is immutable or in progress.'
+export const SHIP_NO_TASKS_TO_CANCEL = 'No tasks to cancel.'
+export const SHIP_INVALID_CARGO = 'Invalid cargo specified for load/unload.'
+export const SHIP_CARGO_NOT_OWNED = 'Cannot load cargo that is not owned.'
+export const SHIP_CARGO_NOT_LOADED = 'Cannot unload cargo that is not loaded.'
+export const SHIP_CAPACITY_EXCEEDED = 'Ship cargo capacity would be exceeded.'
+export const ENTITY_CAPACITY_EXCEEDED = 'Entity cargo capacity would be exceeded.'
+export const WAREHOUSE_NOT_FOUND = 'Cannot find warehouse for given id.'
+export const WAREHOUSE_ALREADY_AT_LOCATION = 'Warehouse already exists at this location.'
+export const WAREHOUSE_CAPACITY_EXCEEDED = 'Warehouse capacity would be exceeded.'
+export const CONTAINER_NOT_FOUND = 'Cannot find container for given id.'
+export const CONTAINER_CAPACITY_EXCEEDED = 'Container capacity would be exceeded.'
+export const DESTINATION_CAPACITY_EXCEEDED =
+    'Destination entity does not have enough capacity for the gather.'
+export const CANCEL_PAIRED_HAS_PENDING = 'Cannot cancel transfer, paired entity has pending tasks.'
+export const GROUP_EMPTY = 'Group travel requires at least one entity.'
+export const GROUP_NO_THRUST = 'Group travel requires at least one entity with engines.'
+export const GROUP_NOT_SAME_LOCATION = 'All entities must be at the same location for group travel.'
+export const GROUP_NOT_SAME_OWNER = 'All entities must have the same owner for group travel.'
+export const GROUP_ENTITY_NOT_MOVABLE = 'Entity cannot participate in group travel.'
+export const GROUP_NOT_FOUND = 'Entity group not found.'
+export const GROUP_DUPLICATE_ENTITY = 'Duplicate entity in group.'
+export const GROUP_HAUL_CAPACITY_EXCEEDED =
+    'Group travel requires sufficient hauler capacity for all non-self-propelled entities.'
+export const CANCEL_CONTAINS_GROUPED_TASK =
+    'Cannot cancel range containing grouped task - cancel non-grouped tasks first.'
+export const WARP_NO_CAPABILITY = 'Entity does not have warp capability.'
+export const WARP_HAS_SCHEDULE = 'Entity must be idle to warp.'
+export const WARP_HAS_CARGO = 'Entity must have no cargo to warp.'
+export const WARP_NOT_FULL_ENERGY = 'Entity must have full energy to warp.'
+export const WARP_OUT_OF_RANGE = 'Destination exceeds warp range.'
+
+export const ENTITY_NO_CRAFTER = 'Entity does not have crafting capability.'
+export const RECIPE_NOT_FOUND = 'Recipe does not exist.'
+export const RECIPE_INPUTS_INSUFFICIENT = 'Insufficient inputs for recipe.'
+export const RECIPE_INPUTS_INVALID = 'Input cargo does not match recipe requirements.'
+export const RECIPE_INPUTS_EXCESS = 'Provided inputs exceed recipe requirements.'
+export const RECIPE_INPUTS_MIXED = 'All stacks for a recipe input must be the same resource.'
+export const ITEM_NOT_DEPLOYABLE = 'Item cannot be deployed as an entity.'
+export const DEPLOY_ENTITY_HAS_SCHEDULE = 'Entity must be idle to deploy.'
+export const BLEND_INPUTS_MUST_MATCH = 'All blend inputs must be the same item.'
+export const GATHER_NOT_ENOUGH_ENERGY = 'Gather requires more energy than entity has.'
+export const GATHER_EXCEEDS_ENERGY_CAPACITY = "Gather drain exceeds entity's energy capacity."
+export const CRAFT_NOT_ENOUGH_ENERGY = 'Craft requires more energy than entity has.'
+export const CRAFT_EXCEEDS_ENERGY_CAPACITY = "Craft drain exceeds entity's energy capacity."
+export const BLEND_REQUIRES_MULTIPLE = 'Blend requires at least two input stacks.'
+export const BLEND_STAT_LESS_NOT_SUPPORTED = 'Stat-less items cannot be blended.'
+
+export const MODULE_SLOT_INVALID = 'Module slot index is invalid.'
+export const MODULE_SLOT_OCCUPIED = 'Module slot is already occupied.'
+export const MODULE_SLOT_EMPTY = 'Module slot is empty.'
+export const MODULE_TYPE_MISMATCH = 'Module type not allowed in this slot.'
+export const MODULE_CARGO_NOT_FOUND = 'Module cargo not found.'
+export const MODULE_NOT_MODULE = 'Item is not a module.'
+export const MODULE_ENTITY_BUSY = 'Entity must be idle to modify modules.'
+export const ITEM_NOT_PACKED_ENTITY = 'Item is not a packed entity.'
+
+// SDK-only market errors (no contract counterpart yet)
+export const ITEM_NOT_AVAILABLE_AT_LOCATION = 'Item is not tradeable at ship location.'
+export const INSUFFICIENT_BALANCE = 'Insufficient balance.'
+export const INSUFFICIENT_ITEM_QUANTITY = 'Insufficient quantity in cargo.'
+export const INSUFFICIENT_ITEM_SUPPLY = 'Insufficient supply of item at location.'

package/src/format.ts

@@ -0,0 +1,12 @@
+export function formatMass(kg: number): string {
+    const t = kg / 1000
+    const fixed = t.toFixed(2)
+    const trimmed = fixed.replace(/\.?0+$/, '')
+    return `${trimmed} t`
+}
+
+export function formatMassDelta(kg: number): string {
+    if (kg === 0) return '0 t'
+    const sign = kg > 0 ? '+' : '-'
+    return `${sign}${formatMass(Math.abs(kg))}`
+}