@shipload/sdk 2.0.0-rc5 → 2.0.0-rc6

package/src/managers/actions.ts

@@ -1,15 +1,8 @@
 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 {
-    item_id: {toNumber(): number} | number
-    quantity: {toNumber(): number} | number
-    hasCargo: boolean
-}
-
 export type EntityRefInput = {
     entityType: EntityTypeName
     entityId: UInt64Type
@@ -91,71 +84,6 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    buyItems(
-        entityId: UInt64Type,
-        goodId: UInt64Type,
-        quantity: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP
-    ): Action {
-        return this.server.action('buyitems', {
-            entity_type: entityType,
-            id: UInt64.from(entityId),
-            item_id: UInt16.from(goodId),
-            quantity: UInt32.from(quantity),
-        })
-    }
-
-    sellItems(
-        entityId: UInt64Type,
-        goodId: UInt64Type,
-        quantity: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP
-    ): Action {
-        return this.server.action('sellitems', {
-            entity_type: entityType,
-            id: UInt64.from(entityId),
-            item_id: UInt16.from(goodId),
-            quantity: UInt32.from(quantity),
-        })
-    }
-
-    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),
@@ -187,26 +115,46 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    joinGame(account: NameType, companyName: string): Action[] {
-        return [this.foundCompany(account, companyName), this.join(account)]
+    craft(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        recipeId: number,
+        quantity: number,
+        inputs: {itemId: number; quantity: number; seed?: bigint}[]
+    ): Action {
+        const cargoInputs = inputs.map((i) =>
+            ServerContract.Types.cargo_item.from({
+                item_id: UInt16.from(i.itemId),
+                quantity: UInt32.from(i.quantity),
+                seed: i.seed !== undefined ? UInt64.from(i.seed) : null,
+            })
+        )
+        return this.server.action('craft', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            recipe_id: UInt16.from(recipeId),
+            quantity: UInt32.from(quantity),
+            inputs: cargoInputs,
+        })
     }
 
-    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)
+    deploy(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        packedItemId: number,
+        seed: bigint,
+        entityName: string
+    ): Action {
+        return this.server.action('deploy', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            packed_item_id: UInt16.from(packedItemId),
+            seed: UInt64.from(seed),
+            entity_name: entityName,
+        })
+    }
 
-        return shipCargo
-            .filter((c) => c.hasCargo)
-            .map((c) => this.sellItems(shipId, c.item_id, c.quantity, EntityType.SHIP))
+    joinGame(account: NameType, companyName: string): Action[] {
+        return [this.foundCompany(account, companyName), this.join(account)]
     }
 }

package/src/managers/context.ts

@@ -6,7 +6,6 @@ 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'
 
@@ -14,7 +13,6 @@ export class GameContext {
     private _entities?: EntitiesManager
     private _players?: PlayersManager
     private _locations?: LocationsManager
-    private _trades?: TradesManager
     private _epochs?: EpochsManager
     private _actions?: ActionsManager
 
@@ -48,13 +46,6 @@ export class GameContext {
         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)

package/src/managers/index.ts

@@ -4,6 +4,5 @@ export {EntitiesManager} from './entities'
 export type {EntityType} from './entities'
 export {PlayersManager} from './players'
 export {LocationsManager} from './locations'
-export {TradesManager} from './trades'
 export {EpochsManager} from './epochs'
 export {ActionsManager} from './actions'

package/src/managers/locations.ts

@@ -1,55 +1,11 @@
-import {Bytes, Checksum256, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {CoordinatesType, coordsToLocationId, Distance, ItemPrice} from '../types'
-import {marketPrice, marketPrices} from '../market/market'
+import {CoordinatesType, coordsToLocationId, Distance} from '../types'
 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<ItemPrice> {
-        const game = await this.getGame()
-        const state = await this.getState()
-        return marketPrice(location, goodId, game.config.seed, state)
-    }
-
-    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<ItemPrice[]> {
-        const [game, state, supplyRows] = await Promise.all([
-            this.getGame(),
-            this.getState(),
-            this.getSupplyRows(location),
-        ])
-
-        const prices = marketPrices(location, game.config.seed, state)
-
-        const supplyMap = new Map<number, number>()
-        for (const row of supplyRows) {
-            if (UInt64.from(row.epoch).equals(state.epoch)) {
-                supplyMap.set(Number(row.item_id), Number(row.supply))
-            }
-        }
-
-        return prices.map((price) => {
-            const actualSupply = supplyMap.get(Number(price.id))
-            if (actualSupply !== undefined) {
-                return ItemPrice.from({
-                    id: price.id,
-                    item: price.item,
-                    price: price.price,
-                    supply: UInt64.from(actualSupply),
-                })
-            }
-            return price
-        })
-    }
-
     async hasSystem(location: CoordinatesType): Promise<boolean> {
         const game = await this.getGame()
         return hasSystem(game.config.seed, location)
@@ -63,45 +19,6 @@ export class LocationsManager extends BaseManager {
         return findNearbyPlanets(game.config.seed, origin, maxDistance)
     }
 
-    async getSupplyRows(location: CoordinatesType) {
-        const hash = Checksum256.hash(Bytes.from(`${location.x}-${location.y}`, 'utf8'))
-        return this.server.table('supply').all({
-            index_position: 'secondary',
-            from: hash,
-            to: hash,
-        })
-    }
-
-    async getLocationWithPrices(coords: CoordinatesType): Promise<Location> {
-        const location = toLocation(coords)
-        const prices = await this.getMarketPrices(location.coordinates)
-        location.setMarketPrices(prices)
-        return location
-    }
-
-    async getLocationWithSupply(coords: CoordinatesType): Promise<Location> {
-        const location = toLocation(coords)
-        const [rows, state] = await Promise.all([
-            this.getSupplyRows(location.coordinates),
-            this.getState(),
-        ])
-        location.setLocationRows(rows, state.epoch)
-        return location
-    }
-
-    async getLocationComplete(coords: CoordinatesType): Promise<Location> {
-        const location = toLocation(coords)
-        const [prices, rows, state] = await Promise.all([
-            this.getMarketPrices(location.coordinates),
-            this.getSupplyRows(location.coordinates),
-            this.getState(),
-        ])
-
-        location.setMarketPrices(prices)
-        location.setLocationRows(rows, state.epoch)
-        return location
-    }
-
     async getLocationEntity(
         id: UInt64Type
     ): Promise<ServerContract.Types.location_row | undefined> {

package/src/market/items.ts

@@ -7,7 +7,6 @@ const items: Item[] = itemsData.map((g) =>
         id: g.id,
         name: g.name,
         description: g.description,
-        base_price: g.base_price,
         mass: g.mass,
         category: g.category,
         tier: g.tier,

package/src/scheduling/projection.ts

@@ -23,13 +23,11 @@ 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
@@ -42,7 +40,6 @@ export interface Projectable extends ScheduleData {
     generator?: ServerContract.Types.energy_stats
     engines?: ServerContract.Types.movement_stats
     loaders?: ServerContract.Types.loader_stats
-    trade?: ServerContract.Types.trade_stats
     capacity?: UInt32
     cargo: ServerContract.Types.cargo_item[]
     cargomass: UInt32
@@ -59,7 +56,6 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
     const loaders = entity.loaders
     const engines = entity.engines
     const generator = entity.generator
-    const trade = entity.trade
     const capacity = entity.capacity
 
     const projected: ProjectedEntity = {
@@ -71,7 +67,6 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         engines,
         generator,
         loaders,
-        trade,
 
         get totalMass() {
             let mass = UInt64.from(this.shipMass).adding(this.cargoMass)
@@ -93,10 +88,6 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
             return capsHasLoaders(this.capabilities())
         },
 
-        hasTrade() {
-            return this.trade !== undefined
-        },
-
         capabilities(): EntityCapabilities {
             return {
                 hullmass: this.shipMass,
@@ -104,7 +95,6 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
                 engines: this.engines,
                 generator: this.generator,
                 loaders: this.loaders,
-                trade: this.trade,
             }
         },
 

package/src/shipload.ts

@@ -7,7 +7,6 @@ import {GameContext} from './managers/context'
 import {EntitiesManager} from './managers/entities'
 import {PlayersManager} from './managers/players'
 import {LocationsManager} from './managers/locations'
-import {TradesManager} from './managers/trades'
 import {EpochsManager} from './managers/epochs'
 import {ActionsManager} from './managers/actions'
 import {GameState} from './entities/gamestate'
@@ -94,10 +93,6 @@ export class Shipload {
         return this._context.locations
     }
 
-    get trades(): TradesManager {
-        return this._context.trades
-    }
-
     get epochs(): EpochsManager {
         return this._context.epochs
     }

package/src/types/capabilities.ts

@@ -20,10 +20,6 @@ export interface LoaderCapability {
     loaders: ServerContract.Types.loader_stats
 }
 
-export interface TradeCapability {
-    trade: ServerContract.Types.trade_stats
-}
-
 export interface ExtractorCapability {
     extractor: ServerContract.Types.extractor_stats
 }
@@ -42,8 +38,8 @@ export interface EntityCapabilities {
     engines?: ServerContract.Types.movement_stats
     generator?: ServerContract.Types.energy_stats
     loaders?: ServerContract.Types.loader_stats
-    trade?: ServerContract.Types.trade_stats
     extractor?: ServerContract.Types.extractor_stats
+    crafter?: ServerContract.Types.crafter_stats
 }
 
 export interface EntityState {
@@ -66,10 +62,6 @@ export function capsHasLoaders(caps: EntityCapabilities): boolean {
     return caps.loaders !== undefined
 }
 
-export function capsHasTrade(caps: EntityCapabilities): boolean {
-    return caps.trade !== undefined
-}
-
 export function capsHasExtractor(caps: EntityCapabilities): boolean {
     return caps.extractor !== undefined
 }

package/src/types/entity-traits.ts

@@ -11,7 +11,6 @@ export interface EntityTraits {
     isMovable: boolean
     hasEnergy: boolean
     hasLoaders: boolean
-    hasTrade: boolean
     notFoundError: string
 }
 
@@ -20,7 +19,7 @@ export const shipTraits: EntityTraits = {
     isMovable: true,
     hasEnergy: true,
     hasLoaders: true,
-    hasTrade: true,
+
     notFoundError: 'ship not found',
 }
 
@@ -29,7 +28,7 @@ export const warehouseTraits: EntityTraits = {
     isMovable: false,
     hasEnergy: false,
     hasLoaders: true,
-    hasTrade: false,
+
     notFoundError: 'warehouse not found',
 }
 
@@ -38,7 +37,7 @@ export const containerTraits: EntityTraits = {
     isMovable: true,
     hasEnergy: false,
     hasLoaders: false,
-    hasTrade: false,
+
     notFoundError: 'container not found',
 }
 

package/src/types/entity.ts

@@ -25,7 +25,6 @@ export type ShipEntity = Entity &
     LoaderCapability &
     MassCapability &
     ScheduleCapability & {
-        trade?: ServerContract.Types.trade_stats
         extractor?: ServerContract.Types.extractor_stats
     }
 

package/src/types.ts

@@ -12,7 +12,6 @@ import {ServerContract} from './contracts'
 
 export const PRECISION = 10000
 
-// Ship constants
 export const INITIAL_SHIP_GENERATOR_CAPACITY = 350
 export const INITIAL_SHIP_DRAIN = 25
 export const INITIAL_SHIP_ENERGY = 350
@@ -22,31 +21,24 @@ export const INITIAL_SHIP_Z = 800
 export const INITIAL_SHIP_RECHARGE = 10
 export const INITIAL_SHIP_THRUST = 250
 
-// Loader constants
 export const INITIAL_LOADER_MASS = 1000
 export const INITIAL_LOADER_QUANTITY = 1
 export const INITIAL_LOADER_THRUST = 1
 
-// Warehouse constants
 export const WAREHOUSE_Z = 500
 export const INITIAL_WAREHOUSE_CAPACITY = 10000000
 
-// Container constants
 export const CONTAINER_Z = 300
 export const INITIAL_CONTAINER_HULLMASS = 50000
 export const INITIAL_CONTAINER_CAPACITY = 2000000
 
-// Mechanics
 export const TRAVEL_MAX_DURATION = 86400
 
-// Altitude limits (for UI/calculations)
 export const MIN_ORBITAL_ALTITUDE = 800
 export const MAX_ORBITAL_ALTITUDE = 3000
 
-// Legacy alias (deprecated, use INITIAL_SHIP_CAPACITY)
 export const INITIAL_SHIP_MASS = 500000
 
-// Extractor constants
 export const INITIAL_EXTRACTOR_RATE = 700
 export const INITIAL_EXTRACTOR_DRAIN = 2500
 export const INITIAL_EXTRACTOR_EFFICIENCY = 5000
@@ -74,6 +66,8 @@ export enum TaskType {
     UNLOAD = 4,
     EXTRACT = 5,
     WARP = 6,
+    CRAFT = 7,
+    DEPLOY = 8,
 }
 
 export enum LocationType {
@@ -84,9 +78,9 @@ export enum LocationType {
 }
 
 export enum TaskCancelable {
-    NEVER = 0, // Task cannot be cancelled
-    BEFORE_START = 1, // Task can only be cancelled before it starts
-    ALWAYS = 2, // Task can always be cancelled
+    NEVER = 0,
+    BEFORE_START = 1,
+    ALWAYS = 2,
 }
 
 export const EntityType = {
@@ -144,8 +138,6 @@ export class Item extends Struct {
     @Struct.field('string')
     description!: string
     @Struct.field(UInt32)
-    base_price!: UInt32
-    @Struct.field(UInt32)
     mass!: UInt32
     @Struct.field('string')
     category!: ResourceCategory
@@ -154,15 +146,3 @@ export class Item extends Struct {
     @Struct.field('string')
     color!: string
 }
-
-@Struct.type('ItemPrice')
-export class ItemPrice extends Struct {
-    @Struct.field(UInt16)
-    id!: UInt16
-    @Struct.field(Item)
-    item!: Item
-    @Struct.field(UInt32)
-    price!: UInt32
-    @Struct.field(UInt16)
-    supply!: UInt16
-}

package/src/utils/system.ts

@@ -2,6 +2,7 @@ import {Checksum256, Checksum256Type, Checksum512, UInt8} from '@wharfkit/antelo
 import {hash512} from './hash'
 import {Coordinates, CoordinatesType, LocationType} from '../types'
 import {ServerContract} from '../contracts'
+import {deriveLocationSize} from '../derivation/location-size'
 import syllables from '../data/syllables.json'
 import nebulaAdjectives from '../data/nebula-adjectives.json'
 import nebulaNouns from '../data/nebula-nouns.json'
@@ -116,9 +117,7 @@ export function deriveLocationStatic(
     }
 
     loc.subtype = UInt8.from(
-        Number(loc.type) === LocationType.PLANET
-            ? hashResult.array[2] % 6
-            : hashResult.array[2]
+        Number(loc.type) === LocationType.PLANET ? hashResult.array[2] % 6 : hashResult.array[2]
     )
     loc.seed0 = UInt8.from(hashResult.array[3])
     loc.seed1 = UInt8.from(hashResult.array[4])
@@ -147,8 +146,10 @@ export function deriveLocation(
     epochSeed: Checksum256Type,
     coordinates: CoordinatesType
 ): ServerContract.Types.location_derived {
+    const staticProps = deriveLocationStatic(gameSeed, coordinates)
     return ServerContract.Types.location_derived.from({
-        static_props: deriveLocationStatic(gameSeed, coordinates),
+        static_props: staticProps,
         epoch_props: deriveLocationEpoch(epochSeed, coordinates),
+        size: deriveLocationSize(staticProps),
     })
 }

package/src/managers/trades.ts

@@ -1,119 +0,0 @@
-import {UInt64} from '@wharfkit/antelope'
-import {BaseManager} from './base'
-import {Ship} from '../entities/ship'
-import {Deal, findDealsForShip, FindDealsOptions} from '../trading/deal'
-import {
-    analyzeCollectOptions,
-    CollectAnalysis,
-    CollectAnalysisCallbacks,
-    CollectAnalysisOptions,
-} from '../trading/collect'
-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, ItemPrice[]>()
-    private priceCacheEpoch: UInt64 | undefined
-
-    private makePriceCacheKey(location: Coordinates): string {
-        return `${location.x},${location.y}`
-    }
-
-    private async createCallbacks(): Promise<CollectAnalysisCallbacks> {
-        const game = await this.getGame()
-        const serverState = await this.getState()
-        const currentEpoch = getCurrentEpoch(game)
-
-        if (!this.priceCacheEpoch || !this.priceCacheEpoch.equals(currentEpoch)) {
-            this.priceCache.clear()
-            this.priceCacheEpoch = currentEpoch
-        }
-
-        const getNearbyLocations = async (
-            origin: Coordinates,
-            maxDistance: number
-        ): Promise<Location[]> => {
-            const nearby = findNearbyPlanets(game.config.seed, origin, maxDistance)
-            return nearby.map((d) => toLocation(d.destination))
-        }
-
-        const getMarketPrices = async (location: Coordinates): Promise<ItemPrice[]> => {
-            const cacheKey = this.makePriceCacheKey(location)
-            const cached = this.priceCache.get(cacheKey)
-            if (cached) {
-                return cached
-            }
-
-            const locationWithSupply = await this.context.locations.getLocationComplete(location)
-            const prices = locationWithSupply.marketPrices || []
-
-            const result = prices.map((price) => {
-                const actualSupply = locationWithSupply.getSupply(price.id)
-
-                if (actualSupply !== undefined) {
-                    return ItemPrice.from({
-                        id: price.id,
-                        item: price.item,
-                        price: price.price,
-                        supply: actualSupply,
-                    })
-                }
-                return price
-            })
-
-            this.priceCache.set(cacheKey, result)
-            return result
-        }
-
-        const getGameSeed = () => game.config.seed
-        const getState = () => serverState
-
-        return {getNearbyLocations, getMarketPrices, getGameSeed, getState}
-    }
-
-    clearPriceCache(): void {
-        this.priceCache.clear()
-        this.priceCacheEpoch = undefined
-    }
-
-    async findDeals(
-        ship: Ship,
-        originLocation?: Coordinates,
-        options: FindDealsOptions = {}
-    ): Promise<Deal[]> {
-        const origin = originLocation || Coordinates.from(ship.coordinates)
-        const callbacks = await this.createCallbacks()
-
-        const deals = await findDealsForShip(
-            ship,
-            origin,
-            callbacks.getNearbyLocations,
-            callbacks.getMarketPrices,
-            options
-        )
-
-        return deals
-    }
-
-    async findBestDeal(
-        ship: Ship,
-        originLocation?: Coordinates,
-        options: FindDealsOptions = {}
-    ): Promise<Deal | undefined> {
-        const deals = await this.findDeals(ship, originLocation, {...options, maxDeals: 1})
-        return deals[0]
-    }
-
-    async getCollectOptions(
-        ship: Ship,
-        arrivedAt?: Coordinates,
-        options: CollectAnalysisOptions = {}
-    ): Promise<CollectAnalysis> {
-        const location = arrivedAt || Coordinates.from(ship.coordinates)
-        const callbacks = await this.createCallbacks()
-
-        return analyzeCollectOptions(ship, location, callbacks, options)
-    }
-}