@shipload/sdk 0.7.1 → 2.0.0-rc1

package/src/entities/warehouse.ts

@@ -0,0 +1,205 @@
+import {Name, NameType, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {Coordinates, CoordinatesType, TaskType} from '../types'
+import {Location} from './location'
+import {getGood} from '../market/goods'
+import * as schedule from '../scheduling/schedule'
+import {Scheduleable} from '../scheduling/schedule'
+import {EntityInventory} from './entity-inventory'
+
+export interface WarehouseStateInput {
+    id: UInt64Type
+    owner: NameType
+    name: string
+    location: 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[]
+
+    get name(): string {
+        return this.entity_name
+    }
+
+    get inventory(): EntityInventory[] {
+        if (!this._inventory) {
+            this._inventory = this.cargo.map((item) => new EntityInventory(item))
+        }
+        return this._inventory
+    }
+
+    get hasSchedule(): boolean {
+        return schedule.hasSchedule(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
+    }
+
+    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
+    }
+
+    get currentLocation(): Coordinates {
+        return this.location
+    }
+
+    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))
+    }
+
+    get maxCapacity(): UInt64 {
+        return UInt64.from(this.capacity)
+    }
+
+    get availableCapacity(): UInt64 {
+        if (this.totalCargoMass.gte(this.maxCapacity)) {
+            return UInt64.from(0)
+        }
+        return this.maxCapacity.subtracting(this.totalCargoMass)
+    }
+
+    hasSpace(goodMass: UInt64, quantity: number): boolean {
+        const additionalMass = goodMass.multiplying(quantity)
+        const newTotal = this.totalCargoMass.adding(additionalMass)
+        return newTotal.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))
+    }
+
+    get orbitalAltitude(): number {
+        return this.location.z?.toNumber() || 0
+    }
+}

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,122 @@
 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 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 {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 {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 {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,
+} from './travel/travel'
+export type {
+    LoadTimeBreakdown,
+    EstimatedTravelTime,
+    EstimateTravelTimeOptions,
+    TransferEntity,
+} 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 * 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'

package/src/managers/actions.ts

@@ -0,0 +1,168 @@
+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 CargoItemInput = {
+    goodId: UInt64Type
+    quantity: UInt64Type
+    unitCost?: 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,
+        })
+    }
+
+    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,
+        cargo: CargoItemInput[]
+    ): 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,
+        })
+    }
+
+    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),
+        })
+    }
+
+    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),
+        })
+    }
+
+    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,
+        })
+    }
+
+    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),
+        })
+    }
+
+    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.server.action('sellgoods', {
+                    ship_id: shipId,
+                    good_id: c.good_id,
+                    quantity: c.quantity,
+                })
+            )
+    }
+}

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
+    }
+}