@shipload/sdk 0.7.0 → 1.0.0-beta1

package/src/index-module.ts

@@ -1,10 +1,320 @@
 export * from './contracts'
-export * from './epoch'
 export * from './errors'
-export * from './goods'
-export * from './hash'
-export * from './system'
-export * from './market'
-export * from './ship'
-export * from './travel'
 export * from './types'
+export * from './data/item-ids'
+export * from './data/recipes-runtime'
+
+// Direct namespace re-exports for flat `Types` access without going through ServerContract.
+// Preserves both value and type sides through rollup-plugin-dts bundling.
+export {Types as ServerTypes} from './contracts/server'
+export {Types as PlatformTypes} from './contracts/platform'
+
+import type {ServerContract} from './contracts'
+
+export {Shipload} from './shipload'
+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 {Container} from './entities/container'
+export type {ContainerStateInput} from './entities/container'
+export {makeShip, makeWarehouse, makeContainer} from './entities/makers'
+
+export type movement_stats = ServerContract.Types.movement_stats
+export type energy_stats = ServerContract.Types.energy_stats
+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 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'
+export {Location, toLocation} from './entities/location'
+export {GameState} from './entities/gamestate'
+
+export {
+    EntitiesManager,
+    PlayersManager,
+    LocationsManager,
+    EpochsManager,
+    ActionsManager,
+} from './managers'
+export type {EntityType, LocationStratum} from './managers'
+export type {EntityRefInput} from './managers/actions'
+
+export {
+    getItem,
+    getItems,
+    itemIds,
+    getResources,
+    getComponents,
+    getModules,
+    getEntityItems,
+    resolveItemCategory,
+    typeLabel,
+    categoryLabel,
+    categoryFromIndex,
+    categoryLabelFromIndex,
+    tierLabel,
+} from './data/catalog'
+export {getCurrentEpoch, getEpochInfo} from './scheduling/epoch'
+export type {EpochInfo} from './scheduling/epoch'
+export {
+    getSystemName,
+    hasSystem,
+    getLocationType,
+    getLocationTypeName,
+    isGatherableLocation,
+    deriveLocationStatic,
+    deriveLocationEpoch,
+    deriveLocation,
+} from './utils/system'
+
+export {
+    deriveStratum,
+    deriveStrata,
+    deriveResourceStats,
+    deriveLocationSize,
+    getEligibleResources,
+    getResourceWeight,
+    getLocationCandidates,
+    getDepthThreshold,
+    getResourceTier,
+    DEPTH_THRESHOLD_T1,
+    DEPTH_THRESHOLD_T2,
+    DEPTH_THRESHOLD_T3,
+    DEPTH_THRESHOLD_T4,
+    DEPTH_THRESHOLD_T5,
+    LOCATION_MIN_DEPTH,
+    LOCATION_MAX_DEPTH,
+    PLANET_SUBTYPE_GAS_GIANT,
+    PLANET_SUBTYPE_ROCKY,
+    PLANET_SUBTYPE_TERRESTRIAL,
+    PLANET_SUBTYPE_ICY,
+    PLANET_SUBTYPE_OCEAN,
+    PLANET_SUBTYPE_INDUSTRIAL,
+} from './derivation'
+
+export type {StratumInfo, ResourceStats, DerivedStratum} from './derivation'
+
+export {RESERVE_TIERS, TIER_ROLL_MAX, rollTier, rollWithinTier} from './derivation'
+export type {ReserveTier, TierRange} from './derivation'
+
+export {getStatDefinitions, getStatName, resolveStats} from './derivation'
+export type {StatDefinition, NamedStats} from './derivation'
+
+export {hash, hash512} from './utils/hash'
+
+export {
+    distanceBetweenCoordinates,
+    distanceBetweenPoints,
+    findNearbyPlanets,
+    lerp,
+    rotation,
+    calc_ship_mass,
+    calc_acceleration,
+    calc_flighttime,
+    calc_ship_flighttime,
+    calc_ship_acceleration,
+    calc_rechargetime,
+    calc_ship_rechargetime,
+    calc_loader_flighttime,
+    calc_loader_acceleration,
+    calc_energyusage,
+    calc_orbital_altitude,
+    calc_transfer_duration,
+    calculateTransferTime,
+    calculateLoadTimeBreakdown,
+    calculateRefuelingTime,
+    calculateFlightTime,
+    estimateTravelTime,
+    estimateDealTravelTime,
+    hasEnergyForDistance,
+    getFlightOrigin,
+    getDestinationLocation,
+    getPositionAt,
+} from './travel/travel'
+export type {
+    LoadTimeBreakdown,
+    EstimatedTravelTime,
+    EstimateTravelTimeOptions,
+    TransferEntity,
+    HasScheduleAndLocation,
+} from './travel/travel'
+
+export * as schedule from './scheduling/schedule'
+export type {Scheduleable, ScheduleData} from './scheduling/schedule'
+export {ScheduleAccessor, createScheduleAccessor} from './scheduling/accessor'
+export {InventoryAccessor, createInventoryAccessor} from './entities/inventory-accessor'
+export type {HasCargo} from './entities/inventory-accessor'
+
+export * as cargoUtils from './entities/cargo-utils'
+export type {CargoData} from './entities/cargo-utils'
+
+export {
+    createProjectedEntity,
+    projectEntity,
+    projectEntityAt,
+    projectFromCurrentState,
+    projectFromCurrentStateAt,
+    validateSchedule,
+} from './scheduling/projection'
+export type {
+    Projectable,
+    ProjectableSnapshot,
+    ProjectedEntity,
+    ProjectionOptions,
+} from './scheduling/projection'
+
+export * from './types/capabilities'
+export * from './types/entity'
+export * from './capabilities'
+
+export {
+    categoryColors,
+    tierColors,
+    tierLabels,
+    categoryIcons,
+    categoryIconShapes,
+    componentIcon,
+    moduleIcon,
+    itemAbbreviations,
+} from './data/colors'
+export type {CategoryIconShape} from './data/colors'
+
+export {itemTier, itemOffset, itemCategory, isRelatedItem, isCraftedItem} from './data/tiers'
+export type {CraftedItemCategory} from './data/tiers'
+
+export {getCategoryInfo} from './data/categories'
+export type {CategoryInfo} from './data/categories'
+
+export {getPlanetSubtypes, getPlanetSubtype} from './data/locations'
+export type {PlanetSubtypeInfo} from './data/locations'
+
+export {
+    capabilityNames,
+    capabilityAttributes,
+    statMappings,
+    isInvertedAttribute,
+    getCapabilityAttributes,
+    getStatMappings,
+    getStatMappingsForStat,
+    getStatMappingsForCapability,
+} from './data/capabilities'
+export type {CapabilityAttribute, StatMapping} from './data/capabilities'
+
+export {
+    encodeStats,
+    encodeGatheredCargoStats,
+    decodeStat,
+    decodeStats,
+    decodeCraftedItemStats,
+    blendStacks,
+    computeComponentStats,
+    blendComponentStacks,
+    computeEntityStats,
+    blendCargoStacks,
+    blendCrossGroup,
+    computeInputMass,
+    computeCraftedOutputStats,
+} from './derivation/crafting'
+export type {StackInput, CategoryStacks, RecipeSlotInput} from './derivation/crafting'
+
+export {computeContainerCapabilities, computeContainerT2Capabilities} from './entities/container'
+
+export {
+    computeShipHullCapabilities,
+    computeEngineCapabilities,
+    computeGeneratorCapabilities,
+    computeGathererCapabilities,
+    computeHaulerCapabilities,
+    computeLoaderCapabilities,
+    computeCrafterCapabilities,
+    computeWarehouseHullCapabilities,
+    computeStorageCapabilities,
+    computeShipCapabilities,
+} from './entities/ship-deploy'
+export type {ShipCapabilities} from './entities/ship-deploy'
+
+export {resolveItem} from './resolution/resolve-item'
+export type {
+    ResolvedItem,
+    ResolvedItemStat,
+    ResolvedAttributeGroup,
+    ResolvedModuleSlot,
+    ResolvedItemType,
+} from './resolution/resolve-item'
+
+export {
+    describeModule,
+    describeModuleForItem,
+    describeModuleForSlot,
+    renderDescription,
+} from './resolution/describe-module'
+export type {
+    TextSpan,
+    CapabilityInput,
+    ModuleDescription,
+    RenderDescriptionOptions,
+} from './resolution/describe-module'
+
+export * as NFT from './nft'
+export {
+    deserializeAsset,
+    deserializeResource,
+    deserializeComponent,
+    deserializeModule,
+    deserializeEntity,
+    readCommonBase,
+} from './nft/deserializers'
+export type {
+    NFTCargoItem,
+    NFTModuleSlot,
+    NFTInstalledModule,
+    NFTCommonBase,
+} from './nft/deserializers'
+
+export {
+    buildEntityDescription,
+    formatModuleLine,
+    entityDisplayName,
+    moduleDisplayName,
+    computeBaseHullmass,
+    computeBaseCapacityShip,
+    computeBaseCapacityWarehouse,
+    computeEngineThrust,
+    computeEngineDrain,
+    computeGeneratorCap,
+    computeGeneratorRech,
+    computeGathererYield,
+    computeGathererDrain,
+    computeGathererDepth,
+    computeGathererSpeed,
+    computeLoaderMass,
+    computeLoaderThrust,
+    computeCrafterSpeed,
+    computeCrafterDrain,
+} from './nft/description'
+
+export {
+    ITEM_TYPE_RESOURCE,
+    ITEM_TYPE_COMPONENT,
+    ITEM_TYPE_MODULE,
+    ITEM_TYPE_ENTITY,
+    itemTypeCode,
+} from './data/tiers'
+
+export {formatMass, formatMassDelta} from './format'
+
+export {displayName, describeItem} from './resolution/display-name'
+export type {DescribeOptions} from './resolution/display-name'
+
+export * from './subscriptions'

package/src/managers/actions.ts

@@ -0,0 +1,250 @@
+import {
+    type Action,
+    Int64,
+    Name,
+    type NameType,
+    UInt16,
+    type UInt16Type,
+    UInt32,
+    type UInt32Type,
+    UInt64,
+    type UInt64Type,
+} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import {type CoordinatesType, EntityType, type EntityTypeName} from '../types'
+import {ServerContract} from '../contracts'
+
+export type EntityRefInput = {
+    entityType: EntityTypeName
+    entityId: UInt64Type
+}
+
+export class ActionsManager extends BaseManager {
+    travel(shipId: UInt64Type, destination: CoordinatesType, recharge = true): Action {
+        const x = Int64.from(destination.x)
+        const y = Int64.from(destination.y)
+
+        return this.server.action('travel', {
+            entity_type: EntityType.SHIP,
+            id: UInt64.from(shipId),
+            x,
+            y,
+            recharge,
+        })
+    }
+
+    grouptravel(entities: EntityRefInput[], destination: CoordinatesType, recharge = true): Action {
+        const entityRefs = entities.map((e) =>
+            ServerContract.Types.entity_ref.from({
+                entity_type: e.entityType,
+                entity_id: UInt64.from(e.entityId),
+            })
+        )
+        const x = Int64.from(destination.x)
+        const y = Int64.from(destination.y)
+
+        return this.server.action('grouptravel', {
+            entities: entityRefs,
+            x,
+            y,
+            recharge,
+        })
+    }
+
+    resolve(
+        entityId: UInt64Type,
+        entityType: EntityTypeName = EntityType.SHIP,
+        count?: UInt64Type
+    ): Action {
+        const params: ServerContract.ActionParams.resolve = {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+        }
+        if (count !== undefined) {
+            params.count = UInt64.from(count)
+        }
+        return this.server.action('resolve', params)
+    }
+
+    cancel(
+        entityId: UInt64Type,
+        count: UInt64Type,
+        entityType: EntityTypeName = EntityType.SHIP
+    ): 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 {
+        return this.server.action('recharge', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+        })
+    }
+
+    transfer(
+        sourceType: EntityTypeName,
+        sourceId: UInt64Type,
+        destType: EntityTypeName,
+        destId: UInt64Type,
+        itemId: UInt64Type,
+        stats: UInt64Type,
+        quantity: UInt64Type
+    ): 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),
+        })
+    }
+
+    foundCompany(account: NameType, name: string): Action {
+        return this.platform.action('foundcompany', {
+            account: Name.from(account),
+            name,
+        })
+    }
+
+    join(account: NameType): Action {
+        return this.server.action('join', {
+            account: Name.from(account),
+        })
+    }
+
+    gather(
+        source: EntityRefInput,
+        destination: EntityRefInput,
+        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),
+            }),
+            stratum: UInt16.from(stratum),
+            quantity: UInt32.from(quantity),
+        })
+    }
+
+    warp(
+        entityId: UInt64Type,
+        destination: CoordinatesType,
+        entityType: EntityTypeName = EntityType.SHIP
+    ): 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,
+        })
+    }
+
+    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,
+        })
+    }
+
+    blend(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        inputs: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        const cargoInputs = inputs.map((i) => ServerContract.Types.cargo_item.from(i))
+        return this.server.action('blend', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            inputs: cargoInputs,
+        })
+    }
+
+    deploy(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        packedItemId: number,
+        stats: bigint
+    ): Action {
+        return this.server.action('deploy', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            packed_item_id: UInt16.from(packedItemId),
+            stats: UInt64.from(stats),
+        })
+    }
+
+    addmodule(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        moduleIndex: number,
+        moduleCargoId: UInt64Type,
+        targetCargoId: UInt64Type = UInt64.from(0)
+    ): 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),
+        })
+    }
+
+    rmmodule(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        moduleIndex: number,
+        targetCargoId: UInt64Type = UInt64.from(0)
+    ): Action {
+        return this.server.action('rmmodule', {
+            entity_type: entityType,
+            entity_id: UInt64.from(entityId),
+            module_index: moduleIndex,
+            target_cargo_id: UInt64.from(targetCargoId),
+        })
+    }
+
+    wrap(
+        owner: NameType,
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        cargoId: UInt64Type,
+        quantity: UInt64Type
+    ): 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),
+        })
+    }
+
+    joinGame(account: NameType, companyName: string): Action[] {
+        return [this.foundCompany(account, companyName), this.join(account)]
+    }
+}

package/src/managers/base.ts

@@ -0,0 +1,25 @@
+import type {GameContext} from './context'
+
+export abstract class BaseManager {
+    constructor(protected readonly context: GameContext) {}
+
+    protected get client() {
+        return this.context.client
+    }
+
+    protected get server() {
+        return this.context.server
+    }
+
+    protected get platform() {
+        return this.context.platform
+    }
+
+    protected async getGame() {
+        return this.context.getGame()
+    }
+
+    protected async getState() {
+        return this.context.getState()
+    }
+}

package/src/managers/context.ts

@@ -0,0 +1,114 @@
+import type {APIClient} from '@wharfkit/antelope'
+import type {Contract} from '@wharfkit/contract'
+import type {PlatformContract} from '../contracts'
+import {GameState} from '../entities/gamestate'
+
+import {EntitiesManager} from './entities'
+import {PlayersManager} from './players'
+import {LocationsManager} from './locations'
+import {EpochsManager} from './epochs'
+import {ActionsManager} from './actions'
+import {SubscriptionsManager} from '../subscriptions/manager'
+
+export class GameContext {
+    private _entities?: EntitiesManager
+    private _players?: PlayersManager
+    private _locations?: LocationsManager
+    private _epochs?: EpochsManager
+    private _actions?: ActionsManager
+    private _subscriptions?: SubscriptionsManager
+    private _subscriptionsUrl?: string
+
+    private _gameCache?: PlatformContract.Types.game_row
+    private _stateCache?: GameState
+
+    constructor(
+        public readonly client: APIClient,
+        public readonly server: Contract,
+        public readonly platform: Contract
+    ) {}
+
+    get entities(): EntitiesManager {
+        if (!this._entities) {
+            this._entities = new EntitiesManager(this)
+        }
+        return this._entities
+    }
+
+    get players(): PlayersManager {
+        if (!this._players) {
+            this._players = new PlayersManager(this)
+        }
+        return this._players
+    }
+
+    get locations(): LocationsManager {
+        if (!this._locations) {
+            this._locations = new LocationsManager(this)
+        }
+        return this._locations
+    }
+
+    get epochs(): EpochsManager {
+        if (!this._epochs) {
+            this._epochs = new EpochsManager(this)
+        }
+        return this._epochs
+    }
+
+    get actions(): ActionsManager {
+        if (!this._actions) {
+            this._actions = new ActionsManager(this)
+        }
+        return this._actions
+    }
+
+    setSubscriptionsUrl(url: string) {
+        this._subscriptionsUrl = url
+    }
+
+    get subscriptions(): SubscriptionsManager {
+        if (!this._subscriptions) {
+            if (!this._subscriptionsUrl) {
+                throw new Error(
+                    'subscriptions requires a subscriptionsUrl passed to Shipload constructor'
+                )
+            }
+            this._subscriptions = new SubscriptionsManager({url: this._subscriptionsUrl})
+        }
+        return this._subscriptions
+    }
+
+    async getGame(reload = false): Promise<PlatformContract.Types.game_row> {
+        if (!reload && this._gameCache) {
+            return this._gameCache
+        }
+        const game = await this.platform.table('games').get()
+        if (!game) {
+            throw new Error('Game not initialized')
+        }
+        this._gameCache = game
+        return game
+    }
+
+    async getState(reload = false): Promise<GameState> {
+        if (!reload && this._stateCache) {
+            return this._stateCache
+        }
+        const state = await this.server.table('state').get()
+        if (!state) {
+            throw new Error('Game state not initialized')
+        }
+        const game = this._gameCache
+        this._stateCache = GameState.from(state, game)
+        return this._stateCache
+    }
+
+    get cachedGame(): PlatformContract.Types.game_row | undefined {
+        return this._gameCache
+    }
+
+    get cachedState(): GameState | undefined {
+        return this._stateCache
+    }
+}