@shipload/sdk 2.0.0-rc1 → 2.0.0-rc3

package/src/managers/locations.ts

@@ -1,46 +1,47 @@
-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, ItemPrice} 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> {
+    async getMarketPrice(location: CoordinatesType, goodId: number): Promise<ItemPrice> {
         const game = await this.getGame()
         const state = await this.getState()
         return marketPrice(location, goodId, game.config.seed, state)
     }
 
-    async getMarketPrices(location: CoordinatesType): Promise<GoodPrice[]> {
+    async getMarketPrices(location: CoordinatesType): Promise<ItemPrice[]> {
         const game = await this.getGame()
         const state = await this.getState()
         return marketPrices(location, game.config.seed, state)
     }
 
-    async getMarketPricesWithSupply(location: CoordinatesType): Promise<GoodPrice[]> {
-        const [game, state, locationRows] = await Promise.all([
+    async getMarketPricesWithSupply(location: CoordinatesType): Promise<ItemPrice[]> {
+        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))
+                supplyMap.set(Number(row.item_id), Number(row.supply))
             }
         }
 
         return prices.map((price) => {
             const actualSupply = supplyMap.get(Number(price.id))
             if (actualSupply !== undefined) {
-                return GoodPrice.from({
+                return ItemPrice.from({
                     id: price.id,
-                    good: price.good,
+                    item: price.item,
                     price: price.price,
                     supply: UInt64.from(actualSupply),
                 })
@@ -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

@@ -8,13 +8,13 @@ import {
     CollectAnalysisCallbacks,
     CollectAnalysisOptions,
 } from '../trading/collect'
-import {Coordinates, GoodPrice} from '../types'
+import {Coordinates, ItemPrice} from '../types'
 import {Location, toLocation} from '../entities/location'
 import {findNearbyPlanets} from '../travel/travel'
 import {getCurrentEpoch} from '../scheduling/epoch'
 
 export class TradesManager extends BaseManager {
-    private priceCache = new Map<string, GoodPrice[]>()
+    private priceCache = new Map<string, ItemPrice[]>()
     private priceCacheEpoch: UInt64 | undefined
 
     private makePriceCacheKey(location: Coordinates): string {
@@ -39,7 +39,7 @@ export class TradesManager extends BaseManager {
             return nearby.map((d) => toLocation(d.destination))
         }
 
-        const getMarketPrices = async (location: Coordinates): Promise<GoodPrice[]> => {
+        const getMarketPrices = async (location: Coordinates): Promise<ItemPrice[]> => {
             const cacheKey = this.makePriceCacheKey(location)
             const cached = this.priceCache.get(cacheKey)
             if (cached) {
@@ -53,9 +53,9 @@ export class TradesManager extends BaseManager {
                 const actualSupply = locationWithSupply.getSupply(price.id)
 
                 if (actualSupply !== undefined) {
-                    return GoodPrice.from({
+                    return ItemPrice.from({
                         id: price.id,
-                        good: price.good,
+                        item: price.item,
                         price: price.price,
                         supply: actualSupply,
                     })
@@ -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/items.ts

@@ -0,0 +1,31 @@
+import {UInt16, UInt16Type} from '@wharfkit/antelope'
+import {Item} from '../types'
+import itemsData from '../data/items.json'
+
+const items: Item[] = itemsData.map((g) =>
+    Item.from({
+        id: g.id,
+        name: g.name,
+        description: g.description,
+        base_price: g.base_price,
+        mass: g.mass,
+        category: g.category,
+        rarity: g.rarity,
+        color: g.color,
+    })
+)
+
+export const itemIds = items.map((i) => i.id)
+
+export function getItem(itemId: UInt16Type): Item {
+    const id = UInt16.from(itemId)
+    const item = items.find((i) => i.id.equals(id))
+    if (!item) {
+        throw new Error(`Item with id ${id} not found`)
+    }
+    return item
+}
+
+export function getItems(): Item[] {
+    return items
+}

package/src/market/market.ts

@@ -1,5 +1,5 @@
-import {CoordinatesType, GoodPrice} from '../types'
-import {getGood, getGoods} from './goods'
+import {CoordinatesType, ItemPrice} from '../types'
+import {getItem, getItems} from './items'
 import {Checksum256Type, UInt16, UInt16Type, UInt32} from '@wharfkit/antelope'
 import {roll} from './rolls'
 import {ServerContract} from '../contracts'
@@ -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(
@@ -175,9 +174,9 @@ export function marketPrice(
     goodId: UInt16Type,
     gameSeed: Checksum256Type,
     state: ServerContract.Types.state_row
-): GoodPrice {
-    const good = getGood(goodId)
-    let price = Number(good.base_price)
+): ItemPrice {
+    const item = getItem(goodId)
+    let price = Number(item.base_price)
 
     // Rarity multiplier of the deal (changes with epoch)
     // Large impact range on price, from 0.285x to 3.0x
@@ -192,9 +191,9 @@ export function marketPrice(
     // Determine the current supply of the good at the location
     const supply = getSupply(gameSeed, state, location, goodId)
 
-    return GoodPrice.from({
+    return ItemPrice.from({
         id: goodId,
-        good,
+        item,
         price: UInt32.from(price),
         supply: UInt16.from(supply),
     })
@@ -204,6 +203,6 @@ export function marketPrices(
     location: ServerContract.ActionParams.Type.coordinates,
     gameSeed: Checksum256Type,
     state: ServerContract.Types.state_row
-): GoodPrice[] {
-    return getGoods().map((good) => marketPrice(location, good.id, gameSeed, state))
+): ItemPrice[] {
+    return getItems().map((item) => marketPrice(location, item.id, gameSeed, state))
 }

package/src/scheduling/accessor.ts

@@ -0,0 +1,82 @@
+import {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+import {ScheduleData} from './schedule'
+import * as schedule from './schedule'
+
+type Task = ServerContract.Types.task
+
+export class ScheduleAccessor {
+    constructor(private entity: ScheduleData) {}
+
+    get hasSchedule(): boolean {
+        return schedule.hasSchedule(this.entity)
+    }
+
+    get isIdle(): boolean {
+        return schedule.isIdle(this.entity)
+    }
+
+    get tasks(): Task[] {
+        return schedule.getTasks(this.entity)
+    }
+
+    duration(): number {
+        return schedule.scheduleDuration(this.entity)
+    }
+
+    elapsed(now: Date): number {
+        return schedule.scheduleElapsed(this.entity, now)
+    }
+
+    remaining(now: Date): number {
+        return schedule.scheduleRemaining(this.entity, now)
+    }
+
+    complete(now: Date): boolean {
+        return schedule.scheduleComplete(this.entity, now)
+    }
+
+    currentTaskIndex(now: Date): number {
+        return schedule.currentTaskIndex(this.entity, now)
+    }
+
+    currentTask(now: Date): Task | undefined {
+        return schedule.currentTask(this.entity, now)
+    }
+
+    currentTaskType(now: Date): TaskType | undefined {
+        return schedule.currentTaskType(this.entity, now)
+    }
+
+    taskStartTime(index: number): number {
+        return schedule.getTaskStartTime(this.entity, index)
+    }
+
+    taskElapsed(index: number, now: Date): number {
+        return schedule.getTaskElapsed(this.entity, index, now)
+    }
+
+    taskRemaining(index: number, now: Date): number {
+        return schedule.getTaskRemaining(this.entity, index, now)
+    }
+
+    taskComplete(index: number, now: Date): boolean {
+        return schedule.isTaskComplete(this.entity, index, now)
+    }
+
+    taskInProgress(index: number, now: Date): boolean {
+        return schedule.isTaskInProgress(this.entity, index, now)
+    }
+
+    currentTaskProgress(now: Date): number {
+        return schedule.currentTaskProgress(this.entity, now)
+    }
+
+    progress(now: Date): number {
+        return schedule.scheduleProgress(this.entity, now)
+    }
+}
+
+export function createScheduleAccessor(entity: ScheduleData): ScheduleAccessor {
+    return new ScheduleAccessor(entity)
+}

package/src/scheduling/projection.ts

@@ -1,15 +1,19 @@
-import {UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {Name, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import {Coordinates, PRECISION, TaskType} from '../types'
+import {
+    capsHasLoaders,
+    capsHasMovement,
+    capsHasStorage,
+    EntityCapabilities,
+    EntityState,
+} from '../types/capabilities'
 import {distanceBetweenCoordinates, lerp} from '../travel/travel'
-import {getGood} from '../market/goods'
+import {calcCargoMass} from '../capabilities/storage'
+import {getItem} from '../market/items'
 import * as schedule from './schedule'
 import {ScheduleData} from './schedule'
 
-/**
- * Projected state of an entity after scheduled tasks complete.
- * Mirrors contract's projected_entity struct.
- */
 export interface ProjectedEntity {
     location: Coordinates
     energy: UInt16
@@ -19,41 +23,56 @@ export interface ProjectedEntity {
     engines?: ServerContract.Types.movement_stats
     loaders?: ServerContract.Types.loader_stats
     generator?: ServerContract.Types.energy_stats
+    trade?: ServerContract.Types.trade_stats
     readonly totalMass: UInt64
+
+    hasMovement(): boolean
+    hasStorage(): boolean
+    hasLoaders(): boolean
+    hasTrade(): boolean
+
+    capabilities(): EntityCapabilities
+    state(): EntityState
 }
 
-/**
- * Interface for entities that can be projected.
- * Ships and Warehouses both implement this.
- */
 export interface Projectable extends ScheduleData {
-    location: Coordinates
-    energy: UInt16
-    mass: UInt32
+    coordinates: Coordinates | ServerContract.Types.coordinates
+    energy?: UInt16
+    hullmass?: UInt32
     generator?: ServerContract.Types.energy_stats
     engines?: ServerContract.Types.movement_stats
     loaders?: ServerContract.Types.loader_stats
-    capacity?: UInt64
-    calcCargoMass(): UInt64
+    trade?: ServerContract.Types.trade_stats
+    capacity?: UInt32
+    cargo: ServerContract.Types.cargo_item[]
+    cargomass: UInt32
+    owner?: Name
+}
+
+function getHullMass(entity: Projectable): UInt32 {
+    return UInt32.from(entity.hullmass ?? 0)
 }
 
-/**
- * Create initial projected entity state from a projectable entity.
- */
 export function createProjectedEntity(entity: Projectable): ProjectedEntity {
-    const cargoMass = entity.calcCargoMass()
-    const shipMass = UInt32.from(entity.mass)
+    const cargoMass = calcCargoMass(entity)
+    const shipMass = getHullMass(entity)
     const loaders = entity.loaders
+    const engines = entity.engines
+    const generator = entity.generator
+    const trade = entity.trade
+    const capacity = entity.capacity
 
-    return {
-        location: Coordinates.from(entity.location),
-        energy: UInt16.from(entity.energy),
+    const projected: ProjectedEntity = {
+        location: Coordinates.from(entity.coordinates),
+        energy: UInt16.from(entity.energy ?? 0),
         cargoMass,
         shipMass,
-        capacity: entity.capacity,
-        engines: entity.engines,
-        generator: entity.generator,
+        capacity: capacity ? UInt64.from(capacity) : undefined,
+        engines,
+        generator,
         loaders,
+        trade,
+
         get totalMass() {
             let mass = UInt64.from(this.shipMass).adding(this.cargoMass)
             if (this.loaders) {
@@ -61,12 +80,48 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
             }
             return mass
         },
+
+        hasMovement() {
+            return capsHasMovement(this.capabilities())
+        },
+
+        hasStorage() {
+            return capsHasStorage(this.capabilities())
+        },
+
+        hasLoaders() {
+            return capsHasLoaders(this.capabilities())
+        },
+
+        hasTrade() {
+            return this.trade !== undefined
+        },
+
+        capabilities(): EntityCapabilities {
+            return {
+                hullmass: this.shipMass,
+                capacity: this.capacity ? UInt32.from(this.capacity) : undefined,
+                engines: this.engines,
+                generator: this.generator,
+                loaders: this.loaders,
+                trade: this.trade,
+            }
+        },
+
+        state(): EntityState {
+            return {
+                owner: entity.owner ?? Name.from(''),
+                location: ServerContract.Types.coordinates.from(this.location),
+                energy: this.energy,
+                cargomass: UInt32.from(this.cargoMass),
+                cargo: entity.cargo,
+            }
+        },
     }
+
+    return projected
 }
 
-/**
- * Apply a recharge task to projected state.
- */
 function applyRechargeTask(
     projected: ProjectedEntity,
     _task: ServerContract.Types.task,
@@ -84,19 +139,16 @@ function applyRechargeTask(
     }
 }
 
-/**
- * Apply a flight task to projected state.
- */
 function applyFlightTask(
     projected: ProjectedEntity,
     task: ServerContract.Types.task,
     options: {complete: boolean; progress?: number}
 ): void {
-    if (!task.location || !projected.engines) return
+    if (!task.coordinates || !projected.engines) return
 
     const origin = projected.location
-    const destination = Coordinates.from(task.location)
-    const distance = distanceBetweenCoordinates(origin, task.location)
+    const destination = Coordinates.from(task.coordinates)
+    const distance = distanceBetweenCoordinates(origin, task.coordinates)
     const energyUsage = distance.dividing(PRECISION).multiplying(projected.engines.drain)
 
     if (options.complete) {
@@ -117,33 +169,48 @@ function applyFlightTask(
     }
 }
 
-/**
- * Apply a load task to projected state.
- */
+function getItemMass(item_id: UInt16 | number): UInt32 {
+    const item = getItem(item_id)
+    return item.mass
+}
+
 function applyLoadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     for (const item of task.cargo) {
-        const good = getGood(item.good_id)
-        projected.cargoMass = projected.cargoMass.adding(good.mass.multiplying(item.quantity))
+        const good_mass = getItemMass(item.item_id)
+        projected.cargoMass = projected.cargoMass.adding(good_mass.multiplying(item.quantity))
     }
 }
 
-/**
- * Apply an unload task to projected state.
- */
 function applyUnloadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     for (const item of task.cargo) {
-        const good = getGood(item.good_id)
-        const cargoMass = good.mass.multiplying(item.quantity)
+        const good_mass = getItemMass(item.item_id)
+        const cargoMass = good_mass.multiplying(item.quantity)
         projected.cargoMass = projected.cargoMass.gt(cargoMass)
             ? projected.cargoMass.subtracting(cargoMass)
             : UInt64.from(0)
     }
 }
 
-/**
- * Project entity state after all scheduled tasks complete.
- * Mirrors contract's project_ship/project_warehouse methods.
- */
+function applyExtractTask(
+    projected: ProjectedEntity,
+    task: ServerContract.Types.task,
+    options: {complete: boolean}
+): void {
+    if (!options.complete) return
+
+    if (task.energy_cost) {
+        const energyCost = UInt16.from(task.energy_cost)
+        projected.energy = projected.energy.gt(energyCost)
+            ? UInt16.from(projected.energy.subtracting(energyCost))
+            : UInt16.from(0)
+    }
+
+    for (const item of task.cargo) {
+        const good_mass = getItemMass(item.item_id)
+        projected.cargoMass = projected.cargoMass.adding(good_mass.multiplying(item.quantity))
+    }
+}
+
 export function projectEntity(entity: Projectable): ProjectedEntity {
     const projected = createProjectedEntity(entity)
 
@@ -156,7 +223,7 @@ export function projectEntity(entity: Projectable): ProjectedEntity {
             case TaskType.RECHARGE:
                 applyRechargeTask(projected, task, {complete: true})
                 break
-            case TaskType.FLIGHT:
+            case TaskType.TRAVEL:
                 applyFlightTask(projected, task, {complete: true})
                 break
             case TaskType.LOAD:
@@ -165,15 +232,15 @@ export function projectEntity(entity: Projectable): ProjectedEntity {
             case TaskType.UNLOAD:
                 applyUnloadTask(projected, task)
                 break
+            case TaskType.EXTRACT:
+                applyExtractTask(projected, task, {complete: true})
+                break
         }
     }
 
     return projected
 }
 
-/**
- * Project entity state at a specific time (partial task execution).
- */
 export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity {
     const projected = createProjectedEntity(entity)
 
@@ -198,7 +265,7 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
             case TaskType.RECHARGE:
                 applyRechargeTask(projected, task, {complete: taskComplete, progress})
                 break
-            case TaskType.FLIGHT:
+            case TaskType.TRAVEL:
                 applyFlightTask(projected, task, {complete: taskComplete, progress})
                 break
             case TaskType.LOAD:
@@ -211,6 +278,11 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
                     applyUnloadTask(projected, task)
                 }
                 break
+            case TaskType.EXTRACT:
+                if (taskComplete) {
+                    applyExtractTask(projected, task, {complete: true})
+                }
+                break
         }
     }
 

package/src/scheduling/schedule.ts

@@ -153,3 +153,27 @@ export function scheduleProgress(entity: ScheduleData, now: Date): number {
     const elapsed = scheduleElapsed(entity, now)
     return Math.min(1, elapsed / duration)
 }
+
+export function isTaskType(entity: ScheduleData, taskType: TaskType, now: Date): boolean {
+    return currentTaskType(entity, now) === taskType
+}
+
+export function isInFlight(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.TRAVEL, now)
+}
+
+export function isRecharging(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.RECHARGE, now)
+}
+
+export function isLoading(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.LOAD, now)
+}
+
+export function isUnloading(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.UNLOAD, now)
+}
+
+export function isExtracting(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.EXTRACT, now)
+}