@shipload/sdk 0.7.1 → 2.0.0-rc2

package/src/errors.ts

@@ -1,9 +1,46 @@
-export const ERROR_SYSTEM_NOT_INITIALIZED = 'System not initialized'
-export const GOOD_DOES_NOT_EXIST = 'Good does not exist'
-export const GOOD_NOT_AVAILABLE_AT_LOCATION = 'Good not available at location'
-export const PLAYER_NOT_FOUND = 'Player not found'
-export const SHIP_NOT_FOUND = 'Ship not found'
-export const SHIP_CANNOT_BUY_TRAVELING = 'Ship cannot buy while traveling'
-export const INSUFFICIENT_BALANCE = 'Insufficient balance'
-export const INSUFFICIENT_GOOD_QUANTITY = 'Insufficient good quantity'
-export const REQUIRES_MORE_THAN_ONE = 'Requires more than one'
+export const COMPANY_NOT_FOUND = 'Cannot find company for given account.'
+export const COMMIT_ALREADY_SET = 'Commit has already been set.'
+export const COMMIT_CANNOT_MATCH = 'Next commit cannot match current commit.'
+export const COMMIT_NOT_SET = 'Commit has not been set.'
+export const EPOCH_NON_ZERO = 'Epoch must be greater than zero.'
+export const EPOCH_NOT_READY = 'Current epoch is not ready to advance'
+export const ERROR_SYSTEM_ALREADY_INITIALIZED = 'This game has already been initialized.'
+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 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 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.'
+export const PLAYER_ALREADY_JOINED = 'Player has already joined the game.'
+export const PLAYER_NOT_FOUND = 'Cannot find player for given account name.'
+export const SHIP_ALREADY_THERE = 'Ship cannot travel to the location its already at.'
+export const SHIP_ALREADY_TRAVELING = 'Ship is already traveling.'
+export const SHIP_CANNOT_BUY_TRAVELING = 'Ship cannot buy goods while traveling.'
+export const SHIP_CANNOT_UPDATE_TRAVELING = 'Ship cannot be updated while traveling.'
+export const SHIP_INVALID_DESTINATION = 'Ship cannot travel, no system at specified destination.'
+export const SHIP_INVALID_TRAVEL_DURATION =
+    'This trip cannot be made as it would exceed the maximum travel duration.'
+export const SHIP_NOT_ARRIVED = 'Ship has not yet arrived at its destination.'
+export const SHIP_NOT_ENOUGH_ENERGY =
+    'Ship does not have enough energy to travel to the destination.'
+export const SHIP_NOT_ENOUGH_ENERGY_CAPACITY =
+    'Ship does not have enough energy capacity to travel.'
+export const SHIP_NOT_FOUND = 'Cannot find ship for given account.'
+export const SHIP_NOT_OWNED = 'Ship is not owned by this account.'
+export const NO_SCHEDULE = 'No scheduled tasks.'
+export const SHIP_NOT_IDLE = 'Ship must be idle (no active schedule) for this action.'
+export const SHIP_NO_COMPLETED_TASKS = 'No completed tasks to resolve.'
+export const SHIP_CANNOT_CANCEL_TASK = 'Cannot cancel task that is immutable or in progress.'
+export const SHIP_NO_TASKS_TO_CANCEL = 'No tasks to cancel.'
+export const SHIP_INVALID_CARGO = 'Invalid cargo specified for load/unload.'
+export const SHIP_CARGO_NOT_OWNED = 'Cannot load cargo that is not owned.'
+export const SHIP_CARGO_NOT_LOADED = 'Cannot unload cargo that is not loaded.'
+export const WAREHOUSE_NOT_FOUND = 'Cannot find warehouse for given id.'
+export const WAREHOUSE_ALREADY_AT_LOCATION = 'Warehouse already exists at this location.'
+export const WAREHOUSE_CAPACITY_EXCEEDED = 'Warehouse capacity would be exceeded.'

package/src/index-module.ts

@@ -1,10 +1,155 @@
 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 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'
+export {Location, toLocation} from './entities/location'
+export {GameState} from './entities/gamestate'
+
+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 {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,
+    deriveLocationStatic,
+    deriveLocationEpoch,
+    deriveLocation,
+    deriveLocationMixture,
+} from './utils/system'
+
+export {hash, hash512} from './utils/hash'
+
+export type {Deal, FindDealsOptions} from './trading/deal'
+export {findDealsForShip, findBestDeal} from './trading/deal'
+
+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 {
+    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 {
+    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'

package/src/managers/actions.ts

@@ -0,0 +1,200 @@
+import {Action, Int64, Name, NameType, UInt16, UInt32, 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
+}
+
+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),
+            good_id: UInt16.from(goodId),
+            quantity: UInt32.from(quantity),
+        })
+    }
+
+    buyGoods(
+        entityId: UInt64Type,
+        goodId: UInt64Type,
+        quantity: UInt64Type,
+        entityType: EntityTypeName = EntityType.SHIP
+    ): Action {
+        return this.server.action('buygoods', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            good_id: UInt16.from(goodId),
+            quantity: UInt32.from(quantity),
+        })
+    }
+
+    sellGoods(
+        entityId: UInt64Type,
+        goodId: UInt64Type,
+        quantity: UInt64Type,
+        entityType: EntityTypeName = EntityType.SHIP
+    ): Action {
+        return this.server.action('sellgoods', {
+            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,
+        })
+    }
+
+    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),
+            amount: UInt64.from(amount),
+        })
+    }
+
+    payLoan(account: NameType, amount: UInt64Type): Action {
+        return this.server.action('payloan', {
+            account: Name.from(account),
+            amount: UInt64.from(amount),
+        })
+    }
+
+    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),
+        })
+    }
+
+    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/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,104 @@
+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 {TradesManager} from './trades'
+import {EpochsManager} from './epochs'
+import {ActionsManager} from './actions'
+
+export class GameContext {
+    private _entities?: EntitiesManager
+    private _players?: PlayersManager
+    private _locations?: LocationsManager
+    private _trades?: TradesManager
+    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 trades(): TradesManager {
+        if (!this._trades) {
+            this._trades = new TradesManager(this)
+        }
+        return this._trades
+    }
+
+    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
+    }
+}

package/src/managers/entities.ts

@@ -0,0 +1,103 @@
+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' | 'container' | 'location'
+
+export class EntitiesManager extends BaseManager {
+    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,
+        })
+        const entityInfo = result as ServerContract.Types.entity_info
+        return this.wrapEntity(entityInfo)
+    }
+
+    async getEntities(
+        owner: NameType | ServerContract.Types.player_row,
+        type?: EntityType
+    ): Promise<(Ship | Warehouse | Container)[]> {
+        const ownerName = this.resolveOwner(owner)
+        const result = await this.server.readonly('getentities', {
+            owner: ownerName,
+            entity_type: type ? Name.from(type) : null,
+        })
+        const entities = result as ServerContract.Types.entity_info[]
+        return entities.map((entity) => this.wrapEntity(entity))
+    }
+
+    async getSummaries(
+        owner: NameType | ServerContract.Types.player_row,
+        type?: EntityType
+    ): Promise<ServerContract.Types.entity_summary[]> {
+        const ownerName = this.resolveOwner(owner)
+        const result = await this.server.readonly('getsummaries', {
+            owner: ownerName,
+            entity_type: type ? Name.from(type) : null,
+        })
+        return result as ServerContract.Types.entity_summary[]
+    }
+
+    async getShip(id: UInt64Type): Promise<Ship> {
+        return (await this.getEntity('ship', id)) as Ship
+    }
+
+    async getWarehouse(id: UInt64Type): Promise<Warehouse> {
+        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[]
+    }
+
+    async getWarehouses(owner: NameType | ServerContract.Types.player_row): Promise<Warehouse[]> {
+        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[]> {
+        return this.getSummaries(owner, 'ship')
+    }
+
+    async getWarehouseSummaries(
+        owner: NameType | ServerContract.Types.player_row
+    ): Promise<ServerContract.Types.entity_summary[]> {
+        return this.getSummaries(owner, '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 if (entity.type.equals('warehouse')) {
+            return new Warehouse(entity)
+        } else {
+            return new Container(entity)
+        }
+    }
+
+    private resolveOwner(owner: NameType | ServerContract.Types.player_row): Name {
+        if (typeof owner === 'object' && owner !== null && 'owner' in owner) {
+            return owner.owner
+        }
+        return Name.from(owner)
+    }
+}