@shipload/sdk 0.7.1 → 2.0.0-rc10

package/src/index-module.ts

@@ -1,10 +1,305 @@
 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'
+
+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 {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 extractor_stats = ServerContract.Types.extractor_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} from './managers'
+export type {EntityRefInput} from './managers/actions'
+
+export {getItem, getItems, itemIds} from './market/items'
+export {getCurrentEpoch, getEpochInfo} from './scheduling/epoch'
+export type {EpochInfo} from './scheduling/epoch'
+export {
+    getSystemName,
+    hasSystem,
+    getLocationType,
+    isExtractableLocation,
+    deriveLocationStatic,
+    deriveLocationEpoch,
+    deriveLocation,
+} from './utils/system'
+
+export {
+    deriveStratum,
+    deriveResourceStats,
+    deriveLocationSize,
+    getEligibleResources,
+    getResourceWeight,
+    getLocationCandidates,
+    getDepthThreshold,
+    getResourceTier,
+    depthScaleFactor,
+    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} 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 {projectEntity, projectEntityAt, createProjectedEntity} from './scheduling/projection'
+export type {Projectable, ProjectedEntity} from './scheduling/projection'
+
+export * from './types/capabilities'
+export * from './types/entity'
+export * from './capabilities'
+
+export {
+    categoryColors,
+    tierColors,
+    categoryIcons,
+    componentIcon,
+    moduleIcon,
+    itemIcons,
+} 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 {
+    components,
+    entityRecipes,
+    moduleRecipes,
+    getComponentById,
+    getEntityRecipe,
+    getEntityRecipeByItemId,
+    getModuleRecipe,
+    getModuleRecipeByItemId,
+    getAllCraftableItems,
+    getComponentsForCategory,
+    getComponentsForStat,
+    ITEM_HULL_PLATES,
+    ITEM_CARGO_LINING,
+    ITEM_CONTAINER_T1_PACKED,
+    ITEM_THRUSTER_CORE,
+    ITEM_POWER_CELL,
+    ITEM_ENGINE_T1,
+    ITEM_GENERATOR_T1,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_WAREHOUSE_T1_PACKED,
+    ITEM_DRILL_SHAFT,
+    ITEM_EXTRACTION_PROBE,
+    ITEM_CARGO_ARM,
+    ITEM_TOOL_BIT,
+    ITEM_REACTION_CHAMBER,
+    ITEM_EXTRACTOR_T1,
+    ITEM_LOADER_T1,
+    ITEM_MANUFACTURING_T1,
+    ITEM_STORAGE_T1,
+    ITEM_HULL_PLATES_T2,
+    ITEM_CARGO_LINING_T2,
+    ITEM_CONTAINER_T2_PACKED,
+    ITEM_FOCUSING_ARRAY,
+} from './data/recipes'
+export type {
+    ComponentDefinition,
+    ComponentStat,
+    RecipeInput,
+    EntityRecipe,
+    ModuleRecipe,
+    ModuleSlot,
+    CraftableItem,
+} from './data/recipes'
+
+export {
+    encodeStats,
+    decodeStat,
+    decodeStats,
+    decodeCraftedItemStats,
+    blendStacks,
+    computeComponentStats,
+    blendComponentStacks,
+    computeEntityStats,
+    blendCargoStacks,
+    blendCrossGroup,
+    categoryItemMass,
+    computeInputMass,
+} from './derivation/crafting'
+export type {StackInput, CategoryStacks} from './derivation/crafting'
+
+export {computeContainerCapabilities, computeContainerT2Capabilities} from './entities/container'
+
+export {
+    computeShipHullCapabilities,
+    computeEngineCapabilities,
+    computeGeneratorCapabilities,
+    computeExtractorCapabilities,
+    computeHaulerCapabilities,
+    computeLoaderCapabilities,
+    computeManufacturingCapabilities,
+    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 * 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,
+    computeExtractorRate,
+    computeExtractorDrain,
+    computeExtractorDepth,
+    computeExtractorDrill,
+    computeLoaderMass,
+    computeLoaderThrust,
+    computeCrafterSpeed,
+    computeCrafterDrain,
+} from './nft/description'
+
+export {getEntitySlotLayout} from './data/recipes'
+export {
+    ITEM_TYPE_RESOURCE,
+    ITEM_TYPE_COMPONENT,
+    ITEM_TYPE_MODULE,
+    ITEM_TYPE_ENTITY,
+    itemTypeCode,
+} from './data/tiers'

package/src/managers/actions.ts

@@ -0,0 +1,197 @@
+import {Action, Int64, Name, NameType, UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import {CoordinatesType, EntityType, 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): Action {
+        return this.server.action('resolve', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+        })
+    }
+
+    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(shipId: UInt64Type): Action {
+        return this.server.action('recharge', {
+            entity_type: EntityType.SHIP,
+            id: UInt64.from(shipId),
+        })
+    }
+
+    transfer(
+        sourceType: EntityTypeName,
+        sourceId: UInt64Type,
+        destType: EntityTypeName,
+        destId: UInt64Type,
+        goodId: 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(goodId),
+            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),
+        })
+    }
+
+    extract(shipId: UInt64Type): Action {
+        return this.server.action('extract', {
+            ship_id: UInt64.from(shipId),
+        })
+    }
+
+    warp(shipId: UInt64Type, destination: CoordinatesType): Action {
+        const x = Int64.from(destination.x)
+        const y = Int64.from(destination.y)
+
+        return this.server.action('warp', {
+            entity_type: EntityType.SHIP,
+            id: UInt64.from(shipId),
+            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,
+        seed: bigint,
+        entityName: string
+    ): Action {
+        return this.server.action('deploy', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            packed_item_id: UInt16.from(packedItemId),
+            seed: UInt64.from(seed),
+            entity_name: entityName,
+        })
+    }
+
+    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),
+        })
+    }
+
+    joinGame(account: NameType, companyName: string): Action[] {
+        return [this.foundCompany(account, companyName), this.join(account)]
+    }
+}

package/src/managers/base.ts

@@ -0,0 +1,25 @@
+import {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,95 @@
+import {APIClient} from '@wharfkit/antelope'
+import {Contract} from '@wharfkit/contract'
+import {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'
+
+export class GameContext {
+    private _entities?: EntitiesManager
+    private _players?: PlayersManager
+    private _locations?: LocationsManager
+    private _epochs?: EpochsManager
+    private _actions?: ActionsManager
+
+    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
+    }
+
+    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
+    }
+}