@shipload/sdk 2.0.0-rc2 → 2.0.0-rc21

package/src/index-module.ts

@@ -1,13 +1,15 @@
 export * from './contracts'
 export * from './errors'
 export * from './types'
+export * from './data/item-ids'
+export * from './data/recipes-runtime'
 
 import {ServerContract} from './contracts'
 
 export {Shipload} from './shipload'
 export {Ship} from './entities/ship'
-export type {ShipStateInput} from './entities/ship'
-export {Warehouse} from './entities/warehouse'
+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'
@@ -21,9 +23,8 @@ 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 extractor_stats = ServerContract.Types.extractor_stats
-export type mixture_info = ServerContract.Types.mixture_info
-export type mixture_component = ServerContract.Types.mixture_component
+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
@@ -38,55 +39,59 @@ export {
     EntitiesManager,
     PlayersManager,
     LocationsManager,
-    TradesManager,
     EpochsManager,
     ActionsManager,
 } from './managers'
 export type {EntityType} from './managers'
 export type {EntityRefInput} from './managers/actions'
 
-export {getGood, getGoods, goodIds} from './market/goods'
+export {getItem, getItems, itemIds} from './market/items'
 export {getCurrentEpoch, getEpochInfo} from './scheduling/epoch'
 export type {EpochInfo} from './scheduling/epoch'
-export {marketPrice, marketPrices, getRarity, Rarities} from './market/market'
-export type {Rarity} from './market/market'
 export {
     getSystemName,
     hasSystem,
     getLocationType,
-    isExtractableLocation,
+    getLocationTypeName,
+    isGatherableLocation,
     deriveLocationStatic,
     deriveLocationEpoch,
     deriveLocation,
-    deriveLocationMixture,
 } from './utils/system'
 
-export {hash, hash512} from './utils/hash'
+export {
+    deriveStratum,
+    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 {Deal, FindDealsOptions} from './trading/deal'
-export {findDealsForShip, findBestDeal} from './trading/deal'
+export type {StratumInfo, ResourceStats} from './derivation'
 
-export type {
-    CollectActionType,
-    CollectOption,
-    CollectAnalysis,
-    CollectAnalysisOptions,
-    CollectAnalysisCallbacks,
-    BetterSaleLocation,
-    RepositionLocation,
-    DiscountedGoodInfo,
-    PotentialDeal,
-    CargoSaleItem,
-} from './trading/collect'
-export {
-    analyzeCollectOptions,
-    analyzeCargoSale,
-    createSellAndTradeOption,
-    createTravelToSellOption,
-    createSellAndRepositionOption,
-    createSellAndStayOption,
-    createExploreOption,
-} from './trading/collect'
+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,
@@ -125,19 +130,6 @@ export type {
     HasScheduleAndLocation,
 } from './travel/travel'
 
-export {
-    calculateUpdatedCargoCost,
-    calculateMaxTradeQuantity,
-    calculateTradeProfit,
-    calculateProfitPerMass,
-    calculateProfitPerSecond,
-    findBestGoodToTrade,
-    calculateBreakEvenPrice,
-    isProfitable,
-    calculateROI,
-} from './trading/trade'
-export type {TradeCalculation, TradeProfitResult} from './trading/trade'
-
 export * as schedule from './scheduling/schedule'
 export type {Scheduleable, ScheduleData} from './scheduling/schedule'
 export {ScheduleAccessor, createScheduleAccessor} from './scheduling/accessor'
@@ -147,9 +139,155 @@ export type {HasCargo} from './entities/inventory-accessor'
 export * as cargoUtils from './entities/cargo-utils'
 export type {CargoData} from './entities/cargo-utils'
 
-export {projectEntity, projectEntityAt, createProjectedEntity} from './scheduling/projection'
-export type {Projectable, ProjectedEntity} from './scheduling/projection'
+export {
+    createProjectedEntity,
+    projectEntity,
+    projectEntityAt,
+    validateSchedule,
+} from './scheduling/projection'
+export type {Projectable, 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

@@ -1,15 +1,19 @@
-import {Action, Int64, Name, NameType, UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {
+    Action,
+    Int64,
+    Name,
+    NameType,
+    UInt16,
+    UInt16Type,
+    UInt32,
+    UInt32Type,
+    UInt64,
+    UInt64Type,
+} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {Ship} from '../entities/ship'
 import {CoordinatesType, EntityType, EntityTypeName} from '../types'
 import {ServerContract} from '../contracts'
 
-interface SellableCargo {
-    good_id: {toNumber(): number} | number
-    quantity: {toNumber(): number} | number
-    hasCargo: boolean
-}
-
 export type EntityRefInput = {
     entityType: EntityTypeName
     entityId: UInt64Type
@@ -47,11 +51,19 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    resolve(entityId: UInt64Type, entityType: EntityTypeName = EntityType.SHIP): Action {
-        return this.server.action('resolve', {
+    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(
@@ -66,10 +78,10 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    recharge(shipId: UInt64Type): Action {
+    recharge(entityId: UInt64Type, entityType: EntityTypeName = EntityType.SHIP): Action {
         return this.server.action('recharge', {
-            entity_type: EntityType.SHIP,
-            id: UInt64.from(shipId),
+            entity_type: entityType,
+            id: UInt64.from(entityId),
         })
     }
 
@@ -78,7 +90,8 @@ export class ActionsManager extends BaseManager {
         sourceId: UInt64Type,
         destType: EntityTypeName,
         destId: UInt64Type,
-        goodId: UInt64Type,
+        itemId: UInt64Type,
+        stats: UInt64Type,
         quantity: UInt64Type
     ): Action {
         return this.server.action('transfer', {
@@ -86,115 +99,152 @@ export class ActionsManager extends BaseManager {
             source_id: UInt64.from(sourceId),
             dest_type: destType,
             dest_id: UInt64.from(destId),
-            good_id: UInt16.from(goodId),
+            item_id: UInt16.from(itemId),
+            stats: UInt64.from(stats),
             quantity: UInt32.from(quantity),
         })
     }
 
-    buyGoods(
-        entityId: UInt64Type,
-        goodId: UInt64Type,
-        quantity: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP
+    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('buygoods', {
-            entity_type: entityType,
-            id: UInt64.from(entityId),
-            good_id: UInt16.from(goodId),
+        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),
         })
     }
 
-    sellGoods(
+    warp(
         entityId: UInt64Type,
-        goodId: UInt64Type,
-        quantity: UInt64Type,
+        destination: CoordinatesType,
         entityType: EntityTypeName = EntityType.SHIP
     ): Action {
-        return this.server.action('sellgoods', {
+        const x = Int64.from(destination.x)
+        const y = Int64.from(destination.y)
+
+        return this.server.action('warp', {
             entity_type: entityType,
             id: UInt64.from(entityId),
-            good_id: UInt16.from(goodId),
-            quantity: UInt32.from(quantity),
-        })
-    }
-
-    buyShip(account: NameType, name: string): Action {
-        return this.server.action('buyship', {
-            account: Name.from(account),
-            name,
-        })
-    }
-
-    buyWarehouse(account: NameType, shipId: UInt64Type, name: string): Action {
-        return this.server.action('buywarehouse', {
-            account: Name.from(account),
-            ship_id: UInt64.from(shipId),
-            name,
+            x,
+            y,
         })
     }
 
-    buyContainer(account: NameType, shipId: UInt64Type, name: string): Action {
-        return this.server.action('buycontainer', {
-            account: Name.from(account),
-            ship_id: UInt64.from(shipId),
-            name,
+    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,
         })
     }
 
-    takeLoan(account: NameType, amount: UInt64Type): Action {
-        return this.server.action('takeloan', {
-            account: Name.from(account),
-            amount: UInt64.from(amount),
+    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,
         })
     }
 
-    payLoan(account: NameType, amount: UInt64Type): Action {
-        return this.server.action('payloan', {
-            account: Name.from(account),
-            amount: UInt64.from(amount),
+    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),
         })
     }
 
-    foundCompany(account: NameType, name: string): Action {
-        return this.platform.action('foundcompany', {
-            account: Name.from(account),
-            name,
+    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),
         })
     }
 
-    join(account: NameType): Action {
-        return this.server.action('join', {
-            account: Name.from(account),
+    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),
         })
     }
 
-    extract(shipId: UInt64Type): Action {
-        return this.server.action('extract', {
-            ship_id: UInt64.from(shipId),
+    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)]
     }
-
-    sellAllCargo(ship: Ship | UInt64Type, cargo?: SellableCargo[]): Action[] {
-        let shipCargo: SellableCargo[]
-
-        if (ship instanceof Ship) {
-            shipCargo = cargo || ship.inventory
-        } else {
-            if (!cargo) {
-                throw new Error('cargo parameter required when ship is a UInt64Type')
-            }
-            shipCargo = cargo
-        }
-
-        const shipId = ship instanceof Ship ? ship.id : UInt64.from(ship)
-
-        return shipCargo
-            .filter((c) => c.hasCargo)
-            .map((c) => this.sellGoods(shipId, c.good_id, c.quantity, EntityType.SHIP))
-    }
 }

package/src/managers/context.ts

@@ -6,17 +6,18 @@ import {GameState} from '../entities/gamestate'
 import {EntitiesManager} from './entities'
 import {PlayersManager} from './players'
 import {LocationsManager} from './locations'
-import {TradesManager} from './trades'
 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 _trades?: TradesManager
     private _epochs?: EpochsManager
     private _actions?: ActionsManager
+    private _subscriptions?: SubscriptionsManager
+    private _subscriptionsUrl?: string
 
     private _gameCache?: PlatformContract.Types.game_row
     private _stateCache?: GameState
@@ -48,13 +49,6 @@ export class GameContext {
         return this._locations
     }
 
-    get trades(): TradesManager {
-        if (!this._trades) {
-            this._trades = new TradesManager(this)
-        }
-        return this._trades
-    }
-
     get epochs(): EpochsManager {
         if (!this._epochs) {
             this._epochs = new EpochsManager(this)
@@ -69,6 +63,22 @@ export class GameContext {
         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

package/src/managers/index.ts

@@ -4,6 +4,5 @@ export {EntitiesManager} from './entities'
 export type {EntityType} from './entities'
 export {PlayersManager} from './players'
 export {LocationsManager} from './locations'
-export {TradesManager} from './trades'
 export {EpochsManager} from './epochs'
 export {ActionsManager} from './actions'