@shipload/sdk 0.7.1 → 2.0.0-rc10

package/src/entities/ship-deploy.ts

@@ -0,0 +1,263 @@
+import {decodeCraftedItemStats} from '../derivation/crafting'
+import {
+    getModuleCapabilityType,
+    MODULE_CRAFTER,
+    MODULE_ENGINE,
+    MODULE_EXTRACTOR,
+    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 ductility = stats.ductility ?? 500
+    const purity = stats.purity ?? 500
+
+    const hullmass = 25000 + 75 * density
+    const statSum = strength + ductility + purity
+    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 clr = stats.clarity ?? 500
+
+    return {
+        capacity: 300 + Math.floor(res / 6),
+        recharge: 5 + Math.floor((clr * 15) / 1000),
+    }
+}
+
+export function computeExtractorCapabilities(stats: Record<string, number>): {
+    rate: number
+    drain: number
+    depth: number
+    drill: number
+} {
+    const str = stats.strength ?? 500
+    const con = stats.conductivity ?? 500
+    const ref = stats.reflectivity ?? 500
+    const tol = stats.tolerance ?? 500
+
+    return {
+        rate: 200 + str,
+        drain: Math.max(10, 50 - Math.floor(con / 20)),
+        depth: 200 + Math.floor((tol * 3) / 2),
+        drill: 100 + Math.floor((ref * 4) / 5),
+    }
+}
+
+export function computeLoaderCapabilities(stats: Record<string, number>): {
+    mass: number
+    thrust: number
+    quantity: number
+} {
+    const duc = stats.ductility ?? 500
+    const pla = stats.plasticity ?? 500
+
+    return {
+        mass: Math.max(200, 2000 - Math.floor(duc * 2)),
+        thrust: 1 + Math.floor(pla / 500),
+        quantity: 1,
+    }
+}
+
+export function computeManufacturingCapabilities(stats: Record<string, number>): {
+    speed: number
+    drain: number
+} {
+    const rea = stats.reactivity ?? 500
+    const clr = stats.clarity ?? 500
+
+    return {
+        speed: 100 + Math.floor((rea * 4) / 5),
+        drain: Math.max(5, 30 - Math.floor(clr / 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 clr = stats.clarity ?? 500
+
+    return {
+        capacity: Math.max(1, 1 + Math.floor(res / 400)),
+        efficiency: 2000 + con * 6,
+        drain: Math.max(3, 15 - Math.floor(clr / 80)),
+    }
+}
+
+export function computeStorageCapabilities(
+    stats: Record<string, number>,
+    baseCapacity: number
+): {
+    capacityBonus: number
+} {
+    const strength = stats.strength ?? 500
+    const ductility = stats.ductility ?? 500
+    const purity = stats.purity ?? 500
+
+    const statSum = strength + ductility + purity
+    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 ductility = stats.ductility ?? 500
+    const purity = stats.purity ?? 500
+
+    const hullmass = 25000 + 75 * density
+    const statSum = strength + ductility + purity
+    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}
+    extractor?: {rate: number; drain: number; depth: number; drill: 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; seed: 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.seed))
+            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.seed))
+            totalCapacity += caps.capacity
+            totalRecharge += caps.recharge
+        }
+        ship.generator = {capacity: totalCapacity, recharge: totalRecharge}
+    }
+
+    const extractorModules = modules.filter(
+        (m) => getModuleCapabilityType(m.itemId) === MODULE_EXTRACTOR
+    )
+    if (extractorModules.length > 0) {
+        let totalRate = 0
+        let totalDrain = 0
+        let totalDepth = 0
+        let totalDrill = 0
+        for (const m of extractorModules) {
+            const caps = computeExtractorCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            totalRate += caps.rate
+            totalDrain += caps.drain
+            totalDepth += caps.depth
+            totalDrill += caps.drill
+        }
+        ship.extractor = {rate: totalRate, drain: totalDrain, depth: totalDepth, drill: totalDrill}
+    }
+
+    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 decoded = decodeCraftedItemStats(m.itemId, m.seed)
+            const caps = computeHaulerCapabilities({
+                resonance: decoded.capacity,
+                conductivity: decoded.efficiency,
+                clarity: decoded.drain,
+            })
+            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.seed))
+            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 = computeManufacturingCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            totalSpeed += caps.speed
+            totalDrain += caps.drain
+        }
+        ship.crafter = {speed: totalSpeed, drain: totalDrain}
+    }
+
+    return ship
+}

package/src/entities/ship.ts

@@ -0,0 +1,199 @@
+import {UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {Coordinates, CoordinatesType} from '../types'
+import {
+    getDestinationLocation,
+    getPositionAt,
+    getFlightOrigin as travelGetFlightOrigin,
+} from '../travel/travel'
+import {
+    ProjectedEntity,
+    projectEntity as sharedProjectEntity,
+    projectEntityAt as sharedProjectEntityAt,
+} from '../scheduling/projection'
+import {Location} from './location'
+import {ScheduleAccessor} from '../scheduling/accessor'
+import {InventoryAccessor} from './inventory-accessor'
+import {EntityInventory} from './entity-inventory'
+import {
+    energyPercent as calcEnergyPercent,
+    needsRecharge as calcNeedsRecharge,
+    hasEnergyForDistance,
+    maxTravelDistance,
+} from '../capabilities/movement'
+import * as schedule from '../scheduling/schedule'
+
+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
+    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 {
+        return (this._inv ??= new InventoryAccessor(this))
+    }
+
+    get inventory(): EntityInventory[] {
+        return this.inv.items
+    }
+
+    get sched(): ScheduleAccessor {
+        return (this._sched ??= new ScheduleAccessor(this))
+    }
+
+    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)
+    }
+
+    isExtracting(now: Date): boolean {
+        return schedule.isExtracting(this, now)
+    }
+
+    get hasEngines(): boolean {
+        return this.engines !== undefined
+    }
+
+    get hasGenerator(): boolean {
+        return this.generator !== undefined
+    }
+
+    get hasExtractor(): boolean {
+        return this.extractor !== undefined
+    }
+
+    get hasWarp(): boolean {
+        return this.warp !== undefined
+    }
+
+    project(): ProjectedEntity {
+        return sharedProjectEntity(this)
+    }
+
+    projectAt(now: Date): ProjectedEntity {
+        return sharedProjectEntityAt(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,91 @@
+import {UInt64, UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {CoordinatesType} from '../types'
+import {Location} from './location'
+import {ScheduleAccessor} from '../scheduling/accessor'
+import {InventoryAccessor} from './inventory-accessor'
+import {EntityInventory} from './entity-inventory'
+import * as schedule from '../scheduling/schedule'
+
+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
+    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 {
+        return (this._inv ??= new InventoryAccessor(this))
+    }
+
+    get inventory(): EntityInventory[] {
+        return this.inv.items
+    }
+
+    get sched(): ScheduleAccessor {
+        return (this._sched ??= new ScheduleAccessor(this))
+    }
+
+    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)
+    }
+}

package/src/errors.ts

@@ -1,9 +1,46 @@
-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 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.'
+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_FOUND = 'Cannot find player for given account name.'
+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 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 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.'