@shipload/sdk 2.0.0-rc1 → 2.0.0-rc11

package/src/entities/warehouse.ts

@@ -1,166 +1,62 @@
-import {Name, NameType, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {UInt64, UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {Coordinates, CoordinatesType, TaskType} from '../types'
+import {CoordinatesType} from '../types'
 import {Location} from './location'
-import {getGood} from '../market/goods'
-import * as schedule from '../scheduling/schedule'
-import {Scheduleable} from '../scheduling/schedule'
+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: NameType
+    owner: string
     name: string
-    location: CoordinatesType | {x: number; y: number; z?: number}
+    coordinates: CoordinatesType | {x: number; y: number; z?: number}
+    hullmass?: number
     capacity: number
-    loaders: ServerContract.Types.loader_stats
+    loaders?: ServerContract.Types.loader_stats
     schedule?: ServerContract.Types.schedule
     cargo?: ServerContract.Types.cargo_item[]
 }
 
-export class Warehouse extends ServerContract.Types.entity_info implements Scheduleable {
-    static fromState(state: WarehouseStateInput): Warehouse {
-        const entityInfo = ServerContract.Types.entity_info.from({
-            type: Name.from('warehouse'),
-            id: UInt64.from(state.id),
-            owner: Name.from(state.owner),
-            entity_name: state.name,
-            location: ServerContract.Types.coordinates.from(state.location),
-            capacity: UInt32.from(state.capacity),
-            cargomass: UInt32.from(0),
-            cargo: state.cargo || [],
-            loaders: state.loaders,
-            is_idle: !state.schedule,
-            current_task_elapsed: UInt32.from(0),
-            current_task_remaining: UInt32.from(0),
-            pending_tasks: [],
-            schedule: state.schedule,
-            mass: UInt32.from(0),
-            energy: 0,
-            engines: ServerContract.Types.movement_stats.from({
-                thrust: 0,
-                drain: 0,
-                maxmass: 0,
-            }),
-            generator: ServerContract.Types.energy_stats.from({
-                capacity: 0,
-                recharge: 0,
-            }),
-        })
-        return new Warehouse(entityInfo)
-    }
-
-    private _location?: Location
-    private _inventory?: EntityInventory[]
+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[] {
-        if (!this._inventory) {
-            this._inventory = this.cargo.map((item) => new EntityInventory(item))
-        }
-        return this._inventory
+        return this.inv.items
     }
 
-    get hasSchedule(): boolean {
-        return schedule.hasSchedule(this)
+    get sched(): ScheduleAccessor {
+        return (this._sched ??= new ScheduleAccessor(this))
     }
 
     get isIdle(): boolean {
         return this.is_idle
     }
 
-    get tasks(): ServerContract.Types.task[] {
-        return schedule.getTasks(this)
-    }
-
-    scheduleDuration(): number {
-        return schedule.scheduleDuration(this)
-    }
-
-    scheduleElapsed(now: Date): number {
-        return schedule.scheduleElapsed(this, now)
-    }
-
-    scheduleRemaining(now: Date): number {
-        return schedule.scheduleRemaining(this, now)
-    }
-
-    scheduleComplete(now: Date): boolean {
-        return schedule.scheduleComplete(this, now)
-    }
-
-    currentTaskIndex(now: Date): number {
-        return schedule.currentTaskIndex(this, now)
-    }
-
-    currentTask(now: Date): ServerContract.Types.task | undefined {
-        return schedule.currentTask(this, now)
-    }
-
-    currentTaskType(now: Date): TaskType | undefined {
-        return schedule.currentTaskType(this, now)
-    }
-
-    getTaskStartTime(index: number): number {
-        return schedule.getTaskStartTime(this, index)
-    }
-
-    getTaskElapsed(index: number, now: Date): number {
-        return schedule.getTaskElapsed(this, index, now)
-    }
-
-    getTaskRemaining(index: number, now: Date): number {
-        return schedule.getTaskRemaining(this, index, now)
-    }
-
-    isTaskComplete(index: number, now: Date): boolean {
-        return schedule.isTaskComplete(this, index, now)
-    }
-
-    isTaskInProgress(index: number, now: Date): boolean {
-        return schedule.isTaskInProgress(this, index, now)
-    }
-
-    currentTaskProgress(now: Date): number {
-        return schedule.currentTaskProgress(this, now)
-    }
-
-    scheduleProgress(now: Date): number {
-        return schedule.scheduleProgress(this, now)
-    }
-
     isLoading(now: Date): boolean {
-        const taskType = this.currentTaskType(now)
-        return taskType === TaskType.LOAD
+        return schedule.isLoading(this, now)
     }
 
     isUnloading(now: Date): boolean {
-        const taskType = this.currentTaskType(now)
-        return taskType === TaskType.UNLOAD
+        return schedule.isUnloading(this, now)
     }
 
-    calcCargoMass(): UInt64 {
-        let mass = UInt64.from(0)
-        for (const item of this.cargo) {
-            const good = getGood(item.good_id)
-            mass = mass.adding(good.mass.multiplying(item.quantity))
-        }
-        return mass
-    }
-
-    get currentLocation(): Coordinates {
-        return this.location
+    get location(): Location {
+        return Location.from(this.coordinates)
     }
 
     get totalCargoMass(): UInt64 {
-        return this.inventory.reduce((sum, c) => sum.adding(c.totalMass), UInt64.from(0))
-    }
-
-    get cargoValue(): UInt64 {
-        return this.inventory.reduce((sum, c) => sum.adding(c.totalCost), UInt64.from(0))
+        return this.inv.totalMass
     }
 
     get maxCapacity(): UInt64 {
@@ -168,38 +64,28 @@ export class Warehouse extends ServerContract.Types.entity_info implements Sched
     }
 
     get availableCapacity(): UInt64 {
-        if (this.totalCargoMass.gte(this.maxCapacity)) {
-            return UInt64.from(0)
-        }
-        return this.maxCapacity.subtracting(this.totalCargoMass)
+        const cargo = this.totalCargoMass
+        return cargo.gte(this.maxCapacity) ? UInt64.from(0) : this.maxCapacity.subtracting(cargo)
     }
 
     hasSpace(goodMass: UInt64, quantity: number): boolean {
-        const additionalMass = goodMass.multiplying(quantity)
-        const newTotal = this.totalCargoMass.adding(additionalMass)
-        return newTotal.lte(this.maxCapacity)
+        return this.totalCargoMass.adding(goodMass.multiplying(quantity)).lte(this.maxCapacity)
     }
 
     get isFull(): boolean {
         return this.totalCargoMass.gte(this.maxCapacity)
     }
 
-    get locationObject(): Location {
-        if (!this._location) {
-            this._location = Location.from(this.location)
-        }
-        return this._location
-    }
-
-    setLocation(location: Location): void {
-        this._location = location
+    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined {
+        return this.inv.forItem(goodId)
     }
 
-    getCargoForGood(goodId: UInt64Type): EntityInventory | undefined {
-        return this.inventory.find((c) => c.good_id.equals(goodId))
+    get orbitalAltitude(): number {
+        return this.coordinates.z?.toNumber() || 0
     }
 
-    get orbitalAltitude(): number {
-        return this.location.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

@@ -9,11 +9,11 @@ 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 GOOD_DOES_NOT_EXIST = 'Good does not exist.'
-export const GOOD_NOT_AVAILABLE_AT_LOCATION = 'Good is not tradeable at ship location.'
+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_GOOD_QUANTITY = 'Insufficient quantity in cargo.'
-export const INSUFFICIENT_GOOD_SUPPLY = 'Insufficient supply of good at location.'
+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.'

package/src/index-module.ts

@@ -8,6 +8,10 @@ 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
@@ -16,6 +20,13 @@ 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'
@@ -26,45 +37,57 @@ 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} from './utils/system'
+export {
+    getSystemName,
+    hasSystem,
+    getLocationType,
+    getLocationTypeName,
+    isGatherableLocation,
+    deriveLocationStatic,
+    deriveLocationEpoch,
+    deriveLocation,
+} from './utils/system'
 
-export {hash, hash512} from './utils/hash'
+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 {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 {getStatDefinitions, getStatName, resolveStats} from './derivation'
+export type {StatDefinition, NamedStats} from './derivation'
+
+export {hash, hash512} from './utils/hash'
 
 export {
     distanceBetweenCoordinates,
@@ -91,32 +114,193 @@ export {
     estimateTravelTime,
     estimateDealTravelTime,
     hasEnergyForDistance,
+    getFlightOrigin,
+    getDestinationLocation,
+    getPositionAt,
 } from './travel/travel'
 export type {
     LoadTimeBreakdown,
     EstimatedTravelTime,
     EstimateTravelTimeOptions,
     TransferEntity,
+    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'
+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_MATTER_CONDUIT,
+    ITEM_SURVEY_PROBE,
+    ITEM_CARGO_ARM,
+    ITEM_TOOL_BIT,
+    ITEM_REACTION_CHAMBER,
+    ITEM_GATHERER_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,
+    computeGathererCapabilities,
+    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,
+    computeGathererYield,
+    computeGathererDrain,
+    computeGathererDepth,
+    computeGathererSpeed,
+    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'