@shipload/sdk 2.0.0-rc4 → 2.0.0-rc6

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,10 +7,9 @@ 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,
-        rarity: g.rarity,
+        tier: g.tier,
         color: g.color,
     })
 )

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 = {
@@ -132,8 +126,8 @@ export interface Distance {
     distance: UInt16
 }
 
-export type ResourceCategory = 'metal' | 'gas' | 'mineral' | 'organic'
-export type ResourceRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary'
+export type ResourceCategory = 'metal' | 'precious' | 'gas' | 'mineral' | 'organic'
+export type ResourceTier = 't1' | 't2' | 't3' | 't4' | 't5'
 
 @Struct.type('item')
 export class Item extends Struct {
@@ -144,25 +138,11 @@ 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
     @Struct.field('string')
-    rarity!: ResourceRarity
+    tier!: ResourceTier
     @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)
-    }
-}