@shipload/sdk 2.0.0-rc2 → 2.0.0-rc20

package/src/entities/ship-deploy.ts

@@ -0,0 +1,258 @@
+import {decodeCraftedItemStats} from '../derivation/crafting'
+import {
+    getModuleCapabilityType,
+    MODULE_CRAFTER,
+    MODULE_ENGINE,
+    MODULE_GATHERER,
+    MODULE_GENERATOR,
+    MODULE_HAULER,
+    MODULE_LOADER,
+} from '../capabilities/modules'
+
+export function computeShipHullCapabilities(stats: Record<string, number>): {
+    hullmass: number
+    capacity: number
+} {
+    const density = stats.density ?? 500
+    const strength = stats.strength ?? 500
+    const fineness = stats.fineness ?? 500
+    const saturation = stats.saturation ?? 500
+
+    const hullmass = 25000 + 75 * density
+    const statSum = strength + fineness + saturation
+    const exponent = statSum / 2997.0
+    const capacity = Math.floor(1000000 * Math.pow(10, exponent))
+
+    return {hullmass, capacity}
+}
+
+export function computeEngineCapabilities(stats: Record<string, number>): {
+    thrust: number
+    drain: number
+} {
+    const vol = stats.volatility ?? 500
+    const thm = stats.thermal ?? 500
+
+    return {
+        thrust: 400 + Math.floor((vol * 3) / 4),
+        drain: Math.max(30, 50 - Math.floor(thm / 70)),
+    }
+}
+
+export function computeGeneratorCapabilities(stats: Record<string, number>): {
+    capacity: number
+    recharge: number
+} {
+    const res = stats.resonance ?? 500
+    const ref = stats.reflectivity ?? 500
+
+    return {
+        capacity: 300 + Math.floor(res / 6),
+        recharge: 1 + Math.floor((ref * 3) / 1000),
+    }
+}
+
+export function computeGathererCapabilities(stats: Record<string, number>): {
+    yield: number
+    drain: number
+    depth: number
+    speed: number
+} {
+    const str = stats.strength ?? 500
+    const con = stats.conductivity ?? 500
+    const ref = stats.reflectivity ?? 500
+    const tol = stats.tolerance ?? 500
+
+    return {
+        yield: 200 + str,
+        drain: Math.max(250, 1250 - Math.floor((con * 25) / 20)),
+        depth: 200 + Math.floor((tol * 3) / 2),
+        speed: 100 + Math.floor((ref * 4) / 5),
+    }
+}
+
+export function computeLoaderCapabilities(stats: Record<string, number>): {
+    mass: number
+    thrust: number
+    quantity: number
+} {
+    const fin = stats.fineness ?? 500
+    const pla = stats.plasticity ?? 500
+
+    return {
+        mass: Math.max(200, 2000 - Math.floor(fin * 2)),
+        thrust: 1 + Math.floor(pla / 500),
+        quantity: 1,
+    }
+}
+
+export function computeCrafterCapabilities(stats: Record<string, number>): {
+    speed: number
+    drain: number
+} {
+    const rea = stats.reactivity ?? 500
+    const com = stats.composition ?? 500
+
+    return {
+        speed: 100 + Math.floor((rea * 4) / 5),
+        drain: Math.max(5, 30 - Math.floor(com / 33)),
+    }
+}
+
+export function computeHaulerCapabilities(stats: Record<string, number>): {
+    capacity: number
+    efficiency: number
+    drain: number
+} {
+    const res = stats.resonance ?? 500
+    const con = stats.conductivity ?? 500
+    const ref = stats.reflectivity ?? 500
+
+    return {
+        capacity: Math.max(1, 1 + Math.floor(res / 400)),
+        efficiency: 2000 + con * 6,
+        drain: Math.max(3, 15 - Math.floor(ref / 80)),
+    }
+}
+
+export function computeStorageCapabilities(
+    stats: Record<string, number>,
+    baseCapacity: number
+): {
+    capacityBonus: number
+} {
+    const strength = stats.strength ?? 500
+    const fineness = stats.fineness ?? 500
+    const saturation = stats.saturation ?? 500
+
+    const statSum = strength + fineness + saturation
+    const capacityBonus = Math.floor(
+        (baseCapacity * (10 + Math.floor((statSum * 10) / 2997))) / 100
+    )
+
+    return {capacityBonus}
+}
+
+export function computeWarehouseHullCapabilities(stats: Record<string, number>): {
+    hullmass: number
+    capacity: number
+} {
+    const density = stats.density ?? 500
+    const strength = stats.strength ?? 500
+    const fineness = stats.fineness ?? 500
+    const saturation = stats.saturation ?? 500
+
+    const hullmass = 25000 + 75 * density
+    const statSum = strength + fineness + saturation
+    const exponent = statSum / 2997.0
+    const capacity = Math.floor(20000000 * Math.pow(10, exponent))
+
+    return {hullmass, capacity}
+}
+
+export interface ShipCapabilities {
+    engines?: {thrust: number; drain: number}
+    generator?: {capacity: number; recharge: number}
+    gatherer?: {yield: number; drain: number; depth: number; speed: number}
+    hauler?: {capacity: number; efficiency: number; drain: number}
+    loaders?: {mass: number; thrust: number; quantity: number}
+    crafter?: {speed: number; drain: number}
+}
+
+export function computeShipCapabilities(
+    modules: {itemId: number; stats: bigint}[]
+): ShipCapabilities {
+    const ship: ShipCapabilities = {}
+
+    const engineModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_ENGINE)
+    if (engineModules.length > 0) {
+        let totalThrust = 0
+        let totalDrain = 0
+        for (const m of engineModules) {
+            const caps = computeEngineCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            totalThrust += caps.thrust
+            totalDrain += caps.drain
+        }
+        ship.engines = {thrust: totalThrust, drain: totalDrain}
+    }
+
+    const generatorModules = modules.filter(
+        (m) => getModuleCapabilityType(m.itemId) === MODULE_GENERATOR
+    )
+    if (generatorModules.length > 0) {
+        let totalCapacity = 0
+        let totalRecharge = 0
+        for (const m of generatorModules) {
+            const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            totalCapacity += caps.capacity
+            totalRecharge += caps.recharge
+        }
+        ship.generator = {capacity: totalCapacity, recharge: totalRecharge}
+    }
+
+    const gathererModules = modules.filter(
+        (m) => getModuleCapabilityType(m.itemId) === MODULE_GATHERER
+    )
+    if (gathererModules.length > 0) {
+        let totalYield = 0
+        let totalDrain = 0
+        let totalDepth = 0
+        let totalSpeed = 0
+        for (const m of gathererModules) {
+            const caps = computeGathererCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            totalYield += caps.yield
+            totalDrain += caps.drain
+            totalDepth += caps.depth
+            totalSpeed += caps.speed
+        }
+        ship.gatherer = {yield: totalYield, drain: totalDrain, depth: totalDepth, speed: totalSpeed}
+    }
+
+    const haulerModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_HAULER)
+    if (haulerModules.length > 0) {
+        let totalCapacity = 0
+        let weightedEffNum = 0
+        let totalDrain = 0
+        for (const m of haulerModules) {
+            const caps = computeHaulerCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            totalCapacity += caps.capacity
+            weightedEffNum += caps.efficiency * caps.capacity
+            totalDrain += caps.drain
+        }
+        ship.hauler = {
+            capacity: totalCapacity,
+            efficiency: totalCapacity > 0 ? Math.floor(weightedEffNum / totalCapacity) : 0,
+            drain: totalDrain,
+        }
+    }
+
+    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
+        }
+        ship.loaders = {mass: totalMass, thrust: totalThrust, quantity: totalQuantity}
+    }
+
+    const crafterModules = modules.filter(
+        (m) => getModuleCapabilityType(m.itemId) === MODULE_CRAFTER
+    )
+    if (crafterModules.length > 0) {
+        let totalSpeed = 0
+        let totalDrain = 0
+        for (const m of crafterModules) {
+            const caps = computeCrafterCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            totalSpeed += caps.speed
+            totalDrain += caps.drain
+        }
+        ship.crafter = {speed: totalSpeed, drain: totalDrain}
+    }
+
+    return ship
+}

package/src/entities/ship.ts

@@ -1,4 +1,4 @@
-import {UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {UInt16, UInt16Type, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import {Coordinates, CoordinatesType} from '../types'
 import {
@@ -21,20 +21,22 @@ import {
     hasEnergyForDistance,
     maxTravelDistance,
 } from '../capabilities/movement'
-import * as cargoUtils from './cargo-utils'
 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
-    engines: ServerContract.Types.movement_stats
-    generator: ServerContract.Types.energy_stats
-    loaders: ServerContract.Types.loader_stats
+    hullmass?: number
+    capacity?: number
+    energy?: number
+    modules?: PackedModuleInput[]
     schedule?: ServerContract.Types.schedule
     cargo?: ServerContract.Types.cargo_item[]
 }
@@ -105,12 +107,24 @@ export class Ship extends ServerContract.Types.entity_info {
         return schedule.isUnloading(this, now)
     }
 
-    isExtracting(now: Date): boolean {
-        return schedule.isExtracting(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 hasExtractor(): boolean {
-        return this.extractor !== undefined
+    get hasWarp(): boolean {
+        return this.warp !== undefined
     }
 
     project(): ProjectedEntity {
@@ -129,10 +143,6 @@ export class Ship extends ServerContract.Types.entity_info {
         return this.inv.totalMass
     }
 
-    get cargoValue(): UInt64 {
-        return this.inv.totalValue
-    }
-
     get totalMass(): UInt64 {
         let mass = UInt64.from(this.hullmass ?? 0).adding(this.totalCargoMass)
         if (this.loaders) {
@@ -155,8 +165,8 @@ export class Ship extends ServerContract.Types.entity_info {
             : this.maxCapacity.subtracting(this.totalMass)
     }
 
-    getCargoForGood(goodId: UInt64Type): EntityInventory | undefined {
-        return this.inv.forGood(goodId)
+    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined {
+        return this.inv.forItem(goodId)
     }
 
     get sellableCargo(): EntityInventory[] {
@@ -189,20 +199,4 @@ export class Ship extends ServerContract.Types.entity_info {
         if (!this.engines || !this.generator || this.energy === undefined) return false
         return hasEnergyForDistance(this as MovementEntity, distance)
     }
-
-    calculateSaleValue(prices: Map<number, UInt64>): cargoUtils.SaleValue {
-        return cargoUtils.calculateSaleValue(this.cargo, prices)
-    }
-
-    calculateSaleValueFromArray(prices: UInt64[]): cargoUtils.SaleValue {
-        return cargoUtils.calculateSaleValueFromArray(this.cargo, prices)
-    }
-
-    afterSellGoods(goodsToSell: Array<{goodId: number; quantity: number}>): EntityInventory[] {
-        return cargoUtils.afterSellGoods(this.cargo, goodsToSell)
-    }
-
-    afterSellAllGoods(): EntityInventory[] {
-        return cargoUtils.afterSellAllGoods(this.cargo)
-    }
 }

package/src/entities/warehouse.ts

@@ -6,14 +6,19 @@ import {ScheduleAccessor} from '../scheduling/accessor'
 import {InventoryAccessor} from './inventory-accessor'
 import {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
-    loaders: ServerContract.Types.loader_stats
+    modules?: PackedModuleInput[]
     schedule?: ServerContract.Types.schedule
     cargo?: ServerContract.Types.cargo_item[]
 }
@@ -58,10 +63,6 @@ export class Warehouse extends ServerContract.Types.entity_info {
         return this.inv.totalMass
     }
 
-    get cargoValue(): UInt64 {
-        return this.inv.totalValue
-    }
-
     get maxCapacity(): UInt64 {
         return UInt64.from(this.capacity)
     }
@@ -79,11 +80,38 @@ export class Warehouse extends ServerContract.Types.entity_info {
         return this.totalCargoMass.gte(this.maxCapacity)
     }
 
-    getCargoForGood(goodId: UInt64Type): EntityInventory | undefined {
-        return this.inv.forGood(goodId)
+    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

@@ -9,16 +9,15 @@ 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 GOOD_DOES_NOT_EXIST = 'Good does not exist.'
-export const GOOD_NOT_AVAILABLE_AT_LOCATION = 'Good is not tradeable at ship location.'
-export const INSUFFICIENT_BALANCE = 'Insufficient balance.'
-export const INSUFFICIENT_GOOD_QUANTITY = 'Insufficient quantity in cargo.'
-export const INSUFFICIENT_GOOD_SUPPLY = 'Insufficient supply of good at location.'
+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.'
@@ -36,11 +35,66 @@ 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))}`
+}