@shipload/sdk 1.0.0-next.1 → 1.0.0-next.11

package/src/entities/warehouse.ts

@@ -10,6 +10,8 @@ import type {PackedModuleInput} from './ship'
 import {decodeCraftedItemStats} from '../derivation/crafting'
 import {getModuleCapabilityType, MODULE_LOADER} from '../capabilities/modules'
 import {computeLoaderCapabilities} from './ship-deploy'
+import {applySlotMultiplier, clampUint16, getSlotAmp, type InstalledModule} from './slot-multiplier'
+import type {EntitySlot} from '../data/recipes-runtime'
 
 export interface WarehouseStateInput {
     id: UInt64Type
@@ -31,6 +33,14 @@ export class Warehouse extends ServerContract.Types.entity_info {
         return this.entity_name
     }
 
+    get entityClass(): 'planetary' {
+        return 'planetary'
+    }
+
+    get canDemolish(): boolean {
+        return true
+    }
+
     get inv(): InventoryAccessor {
         this._inv ??= new InventoryAccessor(this)
         return this._inv
@@ -96,7 +106,10 @@ export class Warehouse extends ServerContract.Types.entity_info {
     }
 }
 
-export function computeWarehouseCapabilities(modules: {itemId: number; stats: bigint}[]): {
+export function computeWarehouseCapabilities(
+    modules: InstalledModule[],
+    layout: EntitySlot[]
+): {
     loaders?: {mass: number; thrust: number; quantity: number}
 } {
     const warehouse: {loaders?: {mass: number; thrust: number; quantity: number}} = {}
@@ -109,10 +122,14 @@ export function computeWarehouseCapabilities(modules: {itemId: number; stats: bi
         for (const m of loaderModules) {
             const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalMass += caps.mass
-            totalThrust += caps.thrust
+            totalThrust += applySlotMultiplier(caps.thrust, getSlotAmp(layout, m.slotIndex))
             totalQuantity += caps.quantity
         }
-        warehouse.loaders = {mass: totalMass, thrust: totalThrust, quantity: totalQuantity}
+        warehouse.loaders = {
+            mass: totalMass,
+            thrust: clampUint16(totalThrust),
+            quantity: totalQuantity,
+        }
     }
 
     return warehouse

package/src/errors.ts

@@ -18,18 +18,18 @@ 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 ENTITY_ALREADY_THERE = 'Entity cannot travel to the location it is 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 =
+export const ENTITY_INVALID_DESTINATION = 'Cannot travel: no system at specified destination.'
+export const ENTITY_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 ENTITY_NOT_ENOUGH_ENERGY =
+    'Entity does not have enough energy to travel to the destination.'
+export const ENTITY_NOT_ENOUGH_ENERGY_CAPACITY =
+    'Entity 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.'
@@ -38,16 +38,13 @@ 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_INVALID_CARGO = 'Invalid cargo specified for load/unload.'
+export const ENTITY_CARGO_NOT_OWNED = 'Cannot load cargo that is not owned.'
+export const ENTITY_CARGO_NOT_LOADED = 'Cannot unload cargo that is not loaded.'
 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.'

package/src/index-module.ts

@@ -16,9 +16,22 @@ export {Ship} from './entities/ship'
 export type {ShipStateInput, PackedModuleInput} from './entities/ship'
 export {Warehouse, computeWarehouseCapabilities} from './entities/warehouse'
 export type {WarehouseStateInput} from './entities/warehouse'
+export {Extractor, computeExtractorCapabilities} from './entities/extractor'
+export type {ExtractorStateInput, ExtractorCapabilities} from './entities/extractor'
+export {Factory, computeFactoryCapabilities} from './entities/factory'
+export type {FactoryStateInput, FactoryCapabilities} from './entities/factory'
 export {Container} from './entities/container'
 export type {ContainerStateInput} from './entities/container'
-export {makeShip, makeWarehouse, makeContainer} from './entities/makers'
+export {Nexus} from './entities/nexus'
+export type {NexusStateInput} from './entities/nexus'
+export {
+    makeShip,
+    makeWarehouse,
+    makeExtractor,
+    makeFactory,
+    makeContainer,
+    makeNexus,
+} from './entities/makers'
 
 export type movement_stats = ServerContract.Types.movement_stats
 export type energy_stats = ServerContract.Types.energy_stats
@@ -26,14 +39,11 @@ export type loader_stats = ServerContract.Types.loader_stats
 export type schedule = ServerContract.Types.schedule
 export type task = ServerContract.Types.task
 export type cargo_item = ServerContract.Types.cargo_item
-export type warehouse_row = ServerContract.Types.warehouse_row
-export type container_row = ServerContract.Types.container_row
+export type entity_row = ServerContract.Types.entity_row
 export type gatherer_stats = ServerContract.Types.gatherer_stats
 
 export type location_static = ServerContract.Types.location_static
-export type location_epoch = ServerContract.Types.location_epoch
 export type location_derived = ServerContract.Types.location_derived
-export type location_row = ServerContract.Types.location_row
 export {Player} from './entities/player'
 export type {PlayerStateInput} from './entities/player'
 export {EntityInventory} from './entities/entity-inventory'
@@ -63,7 +73,6 @@ export {
     categoryLabel,
     categoryFromIndex,
     categoryLabelFromIndex,
-    tierLabel,
 } from './data/catalog'
 export {getCurrentEpoch, getEpochInfo} from './scheduling/epoch'
 export type {EpochInfo} from './scheduling/epoch'
@@ -73,8 +82,8 @@ export {
     getLocationType,
     getLocationTypeName,
     isGatherableLocation,
+    isLocationBuildable,
     deriveLocationStatic,
-    deriveLocationEpoch,
     deriveLocation,
 } from './utils/system'
 
@@ -86,6 +95,7 @@ export {
     getEligibleResources,
     getResourceWeight,
     getLocationCandidates,
+    getLocationProfile,
     getDepthThreshold,
     getResourceTier,
     DEPTH_THRESHOLD_T1,
@@ -117,30 +127,35 @@ export {
     distanceBetweenCoordinates,
     distanceBetweenPoints,
     findNearbyPlanets,
-    lerp,
-    rotation,
-    calc_ship_mass,
     calc_acceleration,
+    calc_energyusage,
     calc_flighttime,
-    calc_ship_flighttime,
-    calc_ship_acceleration,
-    calc_rechargetime,
-    calc_ship_rechargetime,
-    calc_loader_flighttime,
     calc_loader_acceleration,
-    calc_energyusage,
+    calc_loader_flighttime,
     calc_orbital_altitude,
+    calc_rechargetime,
+    calc_ship_acceleration,
+    calc_ship_flighttime,
+    calc_ship_mass,
+    calc_ship_rechargetime,
     calc_transfer_duration,
-    calculateTransferTime,
+    calculateFlightTime,
     calculateLoadTimeBreakdown,
     calculateRefuelingTime,
-    calculateFlightTime,
-    estimateTravelTime,
+    calculateTransferTime,
+    easeFlightProgress,
     estimateDealTravelTime,
-    hasEnergyForDistance,
-    getFlightOrigin,
+    estimateTravelTime,
+    flightSpeedFactor,
+    type FloatPosition,
     getDestinationLocation,
+    getFlightOrigin,
+    getInterpolatedPosition,
     getPositionAt,
+    hasEnergyForDistance,
+    interpolateFlightPosition,
+    lerp,
+    rotation,
 } from './travel/travel'
 export type {
     LoadTimeBreakdown,
@@ -159,6 +174,8 @@ export type {HasCargo} from './entities/inventory-accessor'
 export * as cargoUtils from './entities/cargo-utils'
 export type {CargoData} from './entities/cargo-utils'
 
+export {cargoRef, cargoItem} from './utils/cargo'
+
 export {
     createProjectedEntity,
     projectEntity,
@@ -174,14 +191,38 @@ export type {
     ProjectionOptions,
 } from './scheduling/projection'
 
+export {taskCargoChanges} from './scheduling/task-cargo'
+export type {TaskCargoChange, TaskCargoDirection} from './scheduling/task-cargo'
+
 export * from './types/capabilities'
 export * from './types/entity'
+export {
+    EntityClass,
+    ENTITY_SHIP,
+    ENTITY_WAREHOUSE,
+    ENTITY_EXTRACTOR,
+    ENTITY_FACTORY,
+    ENTITY_CONTAINER,
+    shipTraits,
+    warehouseTraits,
+    extractorTraits,
+    factoryTraits,
+    containerTraits,
+    getEntityClass,
+    getPackedEntityType,
+    getEntityTraits,
+    isShip,
+    isWarehouse,
+    isExtractor,
+    isFactory,
+    isContainer,
+} from './types/entity-traits'
+export type {EntityTraits, EntityTypeName} from './types/entity-traits'
 export * from './capabilities'
 
 export {
     categoryColors,
     tierColors,
-    tierLabels,
     categoryIcons,
     categoryIconShapes,
     componentIcon,
@@ -202,14 +243,19 @@ export type {PlanetSubtypeInfo} from './data/locations'
 export {
     capabilityNames,
     capabilityAttributes,
-    statMappings,
     isInvertedAttribute,
     getCapabilityAttributes,
+} from './data/capabilities'
+export type {CapabilityAttribute, StatMapping} from './data/capabilities'
+
+export {
+    deriveStatMappings,
     getStatMappings,
     getStatMappingsForStat,
     getStatMappingsForCapability,
-} from './data/capabilities'
-export type {CapabilityAttribute, StatMapping} from './data/capabilities'
+} from './derivation/capability-mappings'
+export {SLOT_FORMULAS} from './data/capability-formulas'
+export type {SlotConsumer, SlotConsumerKind} from './data/capability-formulas'
 
 export {
     encodeStats,
@@ -241,8 +287,11 @@ export {
     computeWarehouseHullCapabilities,
     computeStorageCapabilities,
     computeShipCapabilities,
+    GATHERER_DEPTH_TABLE,
+    GATHERER_DEPTH_MAX_TIER,
+    gathererDepthForTier,
 } from './entities/ship-deploy'
-export type {ShipCapabilities} from './entities/ship-deploy'
+export type {ShipCapabilities, GathererDepthParams} from './entities/ship-deploy'
 
 export {resolveItem} from './resolution/resolve-item'
 export type {
@@ -282,6 +331,9 @@ export type {
     NFTCommonBase,
 } from './nft/deserializers'
 
+export {deserializeAtomicData} from './nft/atomicdata'
+export type {SchemaField, RawData} from './nft/atomicdata'
+
 export {
     buildEntityDescription,
     formatModuleLine,
@@ -302,6 +354,9 @@ export {
     computeLoaderThrust,
     computeCrafterSpeed,
     computeCrafterDrain,
+    computeHaulerCapacity,
+    computeHaulerEfficiency,
+    computeWarpRange,
 } from './nft/description'
 
 export {

package/src/managers/actions.ts

@@ -11,11 +11,11 @@ import {
     type UInt64Type,
 } from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {type CoordinatesType, EntityType, type EntityTypeName} from '../types'
+import type {CoordinatesType} from '../types'
 import {ServerContract} from '../contracts'
 
 export type EntityRefInput = {
-    entityType: EntityTypeName
+    entityType: NameType
     entityId: UInt64Type
 }
 
@@ -25,7 +25,6 @@ export class ActionsManager extends BaseManager {
         const y = Int64.from(destination.y)
 
         return this.server.action('travel', {
-            entity_type: EntityType.SHIP,
             id: UInt64.from(shipId),
             x,
             y,
@@ -51,13 +50,8 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    resolve(
-        entityId: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP,
-        count?: UInt64Type
-    ): Action {
+    resolve(entityId: UInt64Type, count?: UInt64Type): Action {
         const params: ServerContract.ActionParams.resolve = {
-            entity_type: entityType,
             id: UInt64.from(entityId),
         }
         if (count !== undefined) {
@@ -66,42 +60,34 @@ export class ActionsManager extends BaseManager {
         return this.server.action('resolve', params)
     }
 
-    cancel(
-        entityId: UInt64Type,
-        count: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP
-    ): Action {
+    cancel(entityId: UInt64Type, count: UInt64Type): Action {
         return this.server.action('cancel', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
             count: UInt64.from(count),
         })
     }
 
-    recharge(entityId: UInt64Type, entityType: EntityTypeName = EntityType.SHIP): Action {
+    recharge(entityId: UInt64Type): Action {
         return this.server.action('recharge', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
         })
     }
 
+    refrshentity(entityId: UInt64Type): Action {
+        return this.server.action('refrshentity', {
+            entity_id: UInt64.from(entityId),
+        })
+    }
+
     transfer(
-        sourceType: EntityTypeName,
         sourceId: UInt64Type,
-        destType: EntityTypeName,
         destId: UInt64Type,
-        itemId: UInt64Type,
-        stats: UInt64Type,
-        quantity: UInt64Type
+        items: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
         return this.server.action('transfer', {
-            source_type: sourceType,
             source_id: UInt64.from(sourceId),
-            dest_type: destType,
             dest_id: UInt64.from(destId),
-            item_id: UInt16.from(itemId),
-            stats: UInt64.from(stats),
-            quantity: UInt32.from(quantity),
+            items,
         })
     }
 
@@ -119,35 +105,24 @@ export class ActionsManager extends BaseManager {
     }
 
     gather(
-        source: EntityRefInput,
-        destination: EntityRefInput,
+        sourceId: UInt64Type,
+        destinationId: UInt64Type,
         stratum: UInt16Type,
         quantity: UInt32Type
     ): Action {
         return this.server.action('gather', {
-            source: ServerContract.Types.entity_ref.from({
-                entity_type: source.entityType,
-                entity_id: UInt64.from(source.entityId),
-            }),
-            destination: ServerContract.Types.entity_ref.from({
-                entity_type: destination.entityType,
-                entity_id: UInt64.from(destination.entityId),
-            }),
+            source_id: UInt64.from(sourceId),
+            destination_id: UInt64.from(destinationId),
             stratum: UInt16.from(stratum),
             quantity: UInt32.from(quantity),
         })
     }
 
-    warp(
-        entityId: UInt64Type,
-        destination: CoordinatesType,
-        entityType: EntityTypeName = EntityType.SHIP
-    ): Action {
+    warp(entityId: UInt64Type, destination: CoordinatesType): Action {
         const x = Int64.from(destination.x)
         const y = Int64.from(destination.y)
 
         return this.server.action('warp', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
             x,
             y,
@@ -155,92 +130,90 @@ export class ActionsManager extends BaseManager {
     }
 
     craft(
-        entityType: EntityTypeName,
         entityId: UInt64Type,
         recipeId: number,
         quantity: number,
         inputs: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
-        const cargoInputs = inputs.map((i) => ServerContract.Types.cargo_item.from(i))
         return this.server.action('craft', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
             recipe_id: UInt16.from(recipeId),
             quantity: UInt32.from(quantity),
-            inputs: cargoInputs,
+            inputs,
         })
     }
 
-    blend(
-        entityType: EntityTypeName,
-        entityId: UInt64Type,
-        inputs: ServerContract.ActionParams.Type.cargo_item[]
-    ): Action {
-        const cargoInputs = inputs.map((i) => ServerContract.Types.cargo_item.from(i))
+    blend(entityId: UInt64Type, inputs: ServerContract.ActionParams.Type.cargo_item[]): Action {
         return this.server.action('blend', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
-            inputs: cargoInputs,
+            inputs,
         })
     }
 
-    deploy(
-        entityType: EntityTypeName,
-        entityId: UInt64Type,
-        packedItemId: number,
-        stats: bigint
-    ): Action {
+    deploy(entityId: UInt64Type, ref: ServerContract.ActionParams.Type.cargo_ref): Action {
         return this.server.action('deploy', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
-            packed_item_id: UInt16.from(packedItemId),
-            stats: UInt64.from(stats),
+            ref,
         })
     }
 
     addmodule(
-        entityType: EntityTypeName,
         entityId: UInt64Type,
         moduleIndex: number,
-        moduleCargoId: UInt64Type,
-        targetCargoId: UInt64Type = UInt64.from(0)
+        moduleRef: ServerContract.ActionParams.Type.cargo_ref,
+        targetRef: ServerContract.ActionParams.Type.cargo_ref | null = null
     ): Action {
         return this.server.action('addmodule', {
-            entity_type: entityType,
             entity_id: UInt64.from(entityId),
             module_index: moduleIndex,
-            module_cargo_id: UInt64.from(moduleCargoId),
-            target_cargo_id: UInt64.from(targetCargoId),
+            module_ref: moduleRef,
+            target_ref: targetRef ?? undefined,
         })
     }
 
     rmmodule(
-        entityType: EntityTypeName,
         entityId: UInt64Type,
         moduleIndex: number,
-        targetCargoId: UInt64Type = UInt64.from(0)
+        targetRef: ServerContract.ActionParams.Type.cargo_ref | null = null
     ): Action {
         return this.server.action('rmmodule', {
-            entity_type: entityType,
             entity_id: UInt64.from(entityId),
             module_index: moduleIndex,
-            target_cargo_id: UInt64.from(targetCargoId),
+            target_ref: targetRef ?? undefined,
         })
     }
 
     wrap(
         owner: NameType,
-        entityType: EntityTypeName,
         entityId: UInt64Type,
-        cargoId: UInt64Type,
-        quantity: UInt64Type
+        nexusId: UInt64Type,
+        items: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
         return this.server.action('wrap', {
             owner: Name.from(owner),
-            entity_type: entityType,
             entity_id: UInt64.from(entityId),
-            cargo_id: UInt64.from(cargoId),
-            quantity: UInt64.from(quantity),
+            nexus_id: UInt64.from(nexusId),
+            items,
+        })
+    }
+
+    undeploy(hostId: UInt64Type, targetId: UInt64Type): Action {
+        return this.server.action('undeploy', {
+            host_id: UInt64.from(hostId),
+            target_id: UInt64.from(targetId),
+        })
+    }
+
+    wrapEntity(entityId: UInt64Type, nexusId: UInt64Type): Action {
+        return this.server.action('wrapentity', {
+            entity_id: UInt64.from(entityId),
+            nexus_id: UInt64.from(nexusId),
+        })
+    }
+
+    demolish(entityId: UInt64Type): Action {
+        return this.server.action('demolish', {
+            entity_id: UInt64.from(entityId),
         })
     }