@shipload/sdk 2.0.0-rc1 → 2.0.0-rc2

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))
+        return this.inv.forGood(goodId)
     }
 
     get orbitalAltitude(): number {
-        return this.location.z?.toNumber() || 0
+        return this.coordinates.z?.toNumber() || 0
     }
 }

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,14 @@ 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 mixture_info = ServerContract.Types.mixture_info
+export type mixture_component = ServerContract.Types.mixture_component
+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 +43,23 @@ export {
     ActionsManager,
 } from './managers'
 export type {EntityType} from './managers'
+export type {EntityRefInput} from './managers/actions'
 
 export {getGood, getGoods, goodIds} from './market/goods'
 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,
+    deriveLocationMixture,
+} from './utils/system'
 
 export {hash, hash512} from './utils/hash'
 
@@ -91,12 +113,16 @@ export {
     estimateTravelTime,
     estimateDealTravelTime,
     hasEnergyForDistance,
+    getFlightOrigin,
+    getDestinationLocation,
+    getPositionAt,
 } from './travel/travel'
 export type {
     LoadTimeBreakdown,
     EstimatedTravelTime,
     EstimateTravelTimeOptions,
     TransferEntity,
+    HasScheduleAndLocation,
 } from './travel/travel'
 
 export {
@@ -114,9 +140,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

@@ -10,10 +10,9 @@ interface SellableCargo {
     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,
+            good_id: UInt16.from(goodId),
+            quantity: UInt32.from(quantity),
         })
     }
 
-    buyGoods(shipId: UInt64Type, goodId: UInt64Type, quantity: UInt64Type): Action {
+    buyGoods(
+        entityId: UInt64Type,
+        goodId: UInt64Type,
+        quantity: UInt64Type,
+        entityType: EntityTypeName = EntityType.SHIP
+    ): Action {
         return this.server.action('buygoods', {
-            ship_id: UInt64.from(shipId),
-            good_id: UInt64.from(goodId),
-            quantity: UInt64.from(quantity),
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            good_id: UInt16.from(goodId),
+            quantity: UInt32.from(quantity),
         })
     }
 
-    sellGoods(shipId: UInt64Type, goodId: UInt64Type, quantity: UInt64Type): Action {
+    sellGoods(
+        entityId: UInt64Type,
+        goodId: UInt64Type,
+        quantity: UInt64Type,
+        entityType: EntityTypeName = EntityType.SHIP
+    ): Action {
         return this.server.action('sellgoods', {
-            ship_id: UInt64.from(shipId),
-            good_id: UInt64.from(goodId),
-            quantity: UInt64.from(quantity),
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            good_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,12 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    extract(shipId: UInt64Type): Action {
+        return this.server.action('extract', {
+            ship_id: UInt64.from(shipId),
+        })
+    }
+
     joinGame(account: NameType, companyName: string): Action[] {
         return [this.foundCompany(account, companyName), this.join(account)]
     }
@@ -157,12 +195,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.sellGoods(shipId, c.good_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)
         }
     }
 

package/src/managers/locations.ts

@@ -1,10 +1,11 @@
-import {Bytes, Checksum256, UInt16Type, UInt64} from '@wharfkit/antelope'
+import {Bytes, Checksum256, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {CoordinatesType, Distance, GoodPrice} from '../types'
+import {CoordinatesType, coordsToLocationId, Distance, GoodPrice} from '../types'
 import {marketPrice, marketPrices} from '../market/market'
 import {hasSystem} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 import {Location, toLocation} from '../entities/location'
+import {ServerContract} from '../contracts'
 
 export class LocationsManager extends BaseManager {
     async getMarketPrice(location: CoordinatesType, goodId: number): Promise<GoodPrice> {
@@ -20,16 +21,16 @@ export class LocationsManager extends BaseManager {
     }
 
     async getMarketPricesWithSupply(location: CoordinatesType): Promise<GoodPrice[]> {
-        const [game, state, locationRows] = await Promise.all([
+        const [game, state, supplyRows] = await Promise.all([
             this.getGame(),
             this.getState(),
-            this.getLocation(location),
+            this.getSupplyRows(location),
         ])
 
         const prices = marketPrices(location, game.config.seed, state)
 
         const supplyMap = new Map<number, number>()
-        for (const row of locationRows) {
+        for (const row of supplyRows) {
             if (UInt64.from(row.epoch).equals(state.epoch)) {
                 supplyMap.set(Number(row.good_id), Number(row.supply))
             }
@@ -62,9 +63,9 @@ export class LocationsManager extends BaseManager {
         return findNearbyPlanets(game.config.seed, origin, maxDistance)
     }
 
-    async getLocation(location: CoordinatesType) {
+    async getSupplyRows(location: CoordinatesType) {
         const hash = Checksum256.hash(Bytes.from(`${location.x}-${location.y}`, 'utf8'))
-        return this.server.table('location').all({
+        return this.server.table('supply').all({
             index_position: 'secondary',
             from: hash,
             to: hash,
@@ -81,7 +82,7 @@ export class LocationsManager extends BaseManager {
     async getLocationWithSupply(coords: CoordinatesType): Promise<Location> {
         const location = toLocation(coords)
         const [rows, state] = await Promise.all([
-            this.getLocation(location.coordinates),
+            this.getSupplyRows(location.coordinates),
             this.getState(),
         ])
         location.setLocationRows(rows, state.epoch)
@@ -92,7 +93,7 @@ export class LocationsManager extends BaseManager {
         const location = toLocation(coords)
         const [prices, rows, state] = await Promise.all([
             this.getMarketPrices(location.coordinates),
-            this.getLocation(location.coordinates),
+            this.getSupplyRows(location.coordinates),
             this.getState(),
         ])
 
@@ -100,4 +101,22 @@ export class LocationsManager extends BaseManager {
         location.setLocationRows(rows, state.epoch)
         return location
     }
+
+    async getLocationEntity(
+        id: UInt64Type
+    ): Promise<ServerContract.Types.location_row | undefined> {
+        const row = await this.server.table('location').get(UInt64.from(id))
+        return row ?? undefined
+    }
+
+    async getLocationEntityAt(
+        coords: CoordinatesType
+    ): Promise<ServerContract.Types.location_row | undefined> {
+        const id = coordsToLocationId(coords)
+        return this.getLocationEntity(id)
+    }
+
+    async getAllLocationEntities(): Promise<ServerContract.Types.location_row[]> {
+        return this.server.table('location').all()
+    }
 }

package/src/managers/trades.ts

@@ -83,7 +83,7 @@ export class TradesManager extends BaseManager {
         originLocation?: Coordinates,
         options: FindDealsOptions = {}
     ): Promise<Deal[]> {
-        const origin = originLocation || ship.currentLocation
+        const origin = originLocation || Coordinates.from(ship.coordinates)
         const callbacks = await this.createCallbacks()
 
         const deals = await findDealsForShip(
@@ -111,7 +111,7 @@ export class TradesManager extends BaseManager {
         arrivedAt?: Coordinates,
         options: CollectAnalysisOptions = {}
     ): Promise<CollectAnalysis> {
-        const location = arrivedAt || ship.currentLocation
+        const location = arrivedAt || Coordinates.from(ship.coordinates)
         const callbacks = await this.createCallbacks()
 
         return analyzeCollectOptions(ship, location, callbacks, options)

package/src/market/market.ts

@@ -163,11 +163,10 @@ export function getSupply(
     const r = roll(gameSeed, seed)
     const percent = r / 65535
     const epoch = 1 + Number(state.epoch) / 90
-    // NOTE: Contract has bug where 1/3 is integer division = 0, so pow(ships, 0) = 1
-    // TODO: Update this when contract is fixed to use (double)1/(double)3
-    const ship = Math.pow(Number(state.ships), 0)
+    const ship = 1
     const goodIdNum = Number(goodId)
-    return Math.floor((128 / goodIdNum) * percent * ship * epoch)
+    const base = Math.floor(128 / goodIdNum)
+    return Math.floor(base * percent * ship * epoch)
 }
 
 export function marketPrice(