@shipload/sdk 2.0.0-rc1 → 2.0.0-rc3

package/src/entities/warehouse.ts

@@ -1,166 +1,65 @@
-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}
     capacity: number
     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
-    }
-
-    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
+        return schedule.isUnloading(this, now)
     }
 
-    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))
+        return this.inv.totalMass
     }
 
     get cargoValue(): UInt64 {
-        return this.inventory.reduce((sum, c) => sum.adding(c.totalCost), UInt64.from(0))
+        return this.inv.totalValue
     }
 
     get maxCapacity(): UInt64 {
@@ -168,38 +67,23 @@ 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
-    }
-
-    getCargoForGood(goodId: UInt64Type): EntityInventory | undefined {
-        return this.inventory.find((c) => c.good_id.equals(goodId))
+    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined {
+        return this.inv.forItem(goodId)
     }
 
     get orbitalAltitude(): number {
-        return this.location.z?.toNumber() || 0
+        return this.coordinates.z?.toNumber() || 0
     }
 }

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 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'
@@ -31,13 +42,49 @@ export {
     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,
+    isExtractableLocation,
+    deriveLocationStatic,
+    deriveLocationEpoch,
+    deriveLocation,
+} from './utils/system'
+
+export {
+    deriveStratum,
+    deriveResourceStats,
+    deriveLocationSize,
+    getEligibleResources,
+    getResourceWeight,
+    getLocationCandidates,
+    getDepthThreshold,
+    getResourceRarity,
+    depthScaleFactor,
+    DEPTH_THRESHOLD_COMMON,
+    DEPTH_THRESHOLD_UNCOMMON,
+    DEPTH_THRESHOLD_RARE,
+    DEPTH_THRESHOLD_EPIC,
+    DEPTH_THRESHOLD_LEGENDARY,
+    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 {hash, hash512} from './utils/hash'
 
@@ -52,7 +99,7 @@ export type {
     CollectAnalysisCallbacks,
     BetterSaleLocation,
     RepositionLocation,
-    DiscountedGoodInfo,
+    DiscountedItemInfo,
     PotentialDeal,
     CargoSaleItem,
 } from './trading/collect'
@@ -91,12 +138,16 @@ export {
     estimateTravelTime,
     estimateDealTravelTime,
     hasEnergyForDistance,
+    getFlightOrigin,
+    getDestinationLocation,
+    getPositionAt,
 } from './travel/travel'
 export type {
     LoadTimeBreakdown,
     EstimatedTravelTime,
     EstimateTravelTimeOptions,
     TransferEntity,
+    HasScheduleAndLocation,
 } from './travel/travel'
 
 export {
@@ -105,7 +156,7 @@ export {
     calculateTradeProfit,
     calculateProfitPerMass,
     calculateProfitPerSecond,
-    findBestGoodToTrade,
+    findBestItemToTrade,
     calculateBreakEvenPrice,
     isProfitable,
     calculateROI,
@@ -114,9 +165,16 @@ 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'

package/src/managers/actions.ts

@@ -5,15 +5,14 @@ import {CoordinatesType, EntityType, EntityTypeName} from '../types'
 import {ServerContract} from '../contracts'
 
 interface SellableCargo {
-    good_id: {toNumber(): number} | number
+    item_id: {toNumber(): number} | number
     quantity: {toNumber(): number} | number
     hasCargo: boolean
 }
 
-export type CargoItemInput = {
-    goodId: UInt64Type
-    quantity: UInt64Type
-    unitCost?: UInt64Type
+export type EntityRefInput = {
+    entityType: EntityTypeName
+    entityId: UInt64Type
 }
 
 export class ActionsManager extends BaseManager {
@@ -30,6 +29,24 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    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,
@@ -61,37 +78,44 @@ export class ActionsManager extends BaseManager {
         sourceId: UInt64Type,
         destType: EntityTypeName,
         destId: UInt64Type,
-        cargo: CargoItemInput[]
+        goodId: UInt64Type,
+        quantity: UInt64Type
     ): Action {
-        const cargoItems = cargo.map((c) =>
-            ServerContract.Types.cargo_item.from({
-                good_id: UInt16.from(c.goodId),
-                quantity: UInt32.from(c.quantity),
-                unit_cost: UInt64.from(c.unitCost || 0),
-            })
-        )
         return this.server.action('transfer', {
             source_type: sourceType,
             source_id: UInt64.from(sourceId),
             dest_type: destType,
             dest_id: UInt64.from(destId),
-            cargo: cargoItems,
+            item_id: UInt16.from(goodId),
+            quantity: UInt32.from(quantity),
         })
     }
 
-    buyGoods(shipId: UInt64Type, goodId: UInt64Type, quantity: UInt64Type): Action {
-        return this.server.action('buygoods', {
-            ship_id: UInt64.from(shipId),
-            good_id: UInt64.from(goodId),
-            quantity: UInt64.from(quantity),
+    buyItems(
+        entityId: UInt64Type,
+        goodId: UInt64Type,
+        quantity: UInt64Type,
+        entityType: EntityTypeName = EntityType.SHIP
+    ): Action {
+        return this.server.action('buyitems', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            item_id: UInt16.from(goodId),
+            quantity: UInt32.from(quantity),
         })
     }
 
-    sellGoods(shipId: UInt64Type, goodId: UInt64Type, quantity: UInt64Type): Action {
-        return this.server.action('sellgoods', {
-            ship_id: UInt64.from(shipId),
-            good_id: UInt64.from(goodId),
-            quantity: UInt64.from(quantity),
+    sellItems(
+        entityId: UInt64Type,
+        goodId: UInt64Type,
+        quantity: UInt64Type,
+        entityType: EntityTypeName = EntityType.SHIP
+    ): Action {
+        return this.server.action('sellitems', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            item_id: UInt16.from(goodId),
+            quantity: UInt32.from(quantity),
         })
     }
 
@@ -110,6 +134,14 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    buyContainer(account: NameType, shipId: UInt64Type, name: string): Action {
+        return this.server.action('buycontainer', {
+            account: Name.from(account),
+            ship_id: UInt64.from(shipId),
+            name,
+        })
+    }
+
     takeLoan(account: NameType, amount: UInt64Type): Action {
         return this.server.action('takeloan', {
             account: Name.from(account),
@@ -137,6 +169,24 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    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,
+        })
+    }
+
     joinGame(account: NameType, companyName: string): Action[] {
         return [this.foundCompany(account, companyName), this.join(account)]
     }
@@ -157,12 +207,6 @@ export class ActionsManager extends BaseManager {
 
         return shipCargo
             .filter((c) => c.hasCargo)
-            .map((c) =>
-                this.server.action('sellgoods', {
-                    ship_id: shipId,
-                    good_id: c.good_id,
-                    quantity: c.quantity,
-                })
-            )
+            .map((c) => this.sellItems(shipId, c.item_id, c.quantity, EntityType.SHIP))
     }
 }

package/src/managers/entities.ts

@@ -2,12 +2,13 @@ import {Name, NameType, UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {Ship} from '../entities/ship'
 import {Warehouse} from '../entities/warehouse'
+import {Container} from '../entities/container'
 import {ServerContract} from '../contracts'
 
-export type EntityType = 'ship' | 'warehouse'
+export type EntityType = 'ship' | 'warehouse' | 'container' | 'location'
 
 export class EntitiesManager extends BaseManager {
-    async getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse> {
+    async getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse | Container> {
         const result = await this.server.readonly('getentity', {
             entity_type: Name.from(type),
             entity_id: id,
@@ -19,7 +20,7 @@ export class EntitiesManager extends BaseManager {
     async getEntities(
         owner: NameType | ServerContract.Types.player_row,
         type?: EntityType
-    ): Promise<(Ship | Warehouse)[]> {
+    ): Promise<(Ship | Warehouse | Container)[]> {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getentities', {
             owner: ownerName,
@@ -49,6 +50,10 @@ export class EntitiesManager extends BaseManager {
         return (await this.getEntity('warehouse', id)) as Warehouse
     }
 
+    async getContainer(id: UInt64Type): Promise<Container> {
+        return (await this.getEntity('container', id)) as Container
+    }
+
     async getShips(owner: NameType | ServerContract.Types.player_row): Promise<Ship[]> {
         return (await this.getEntities(owner, 'ship')) as Ship[]
     }
@@ -57,6 +62,10 @@ export class EntitiesManager extends BaseManager {
         return (await this.getEntities(owner, 'warehouse')) as Warehouse[]
     }
 
+    async getContainers(owner: NameType | ServerContract.Types.player_row): Promise<Container[]> {
+        return (await this.getEntities(owner, 'container')) as Container[]
+    }
+
     async getShipSummaries(
         owner: NameType | ServerContract.Types.player_row
     ): Promise<ServerContract.Types.entity_summary[]> {
@@ -69,11 +78,19 @@ export class EntitiesManager extends BaseManager {
         return this.getSummaries(owner, 'warehouse')
     }
 
-    private wrapEntity(entity: ServerContract.Types.entity_info): Ship | Warehouse {
+    async getContainerSummaries(
+        owner: NameType | ServerContract.Types.player_row
+    ): Promise<ServerContract.Types.entity_summary[]> {
+        return this.getSummaries(owner, 'container')
+    }
+
+    private wrapEntity(entity: ServerContract.Types.entity_info): Ship | Warehouse | Container {
         if (entity.type.equals('ship')) {
             return new Ship(entity)
-        } else {
+        } else if (entity.type.equals('warehouse')) {
             return new Warehouse(entity)
+        } else {
+            return new Container(entity)
         }
     }