@shipload/sdk 2.0.0-rc5 → 2.0.0-rc7

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

@@ -19,13 +19,12 @@ export interface Entity {
 }
 
 export type ShipEntity = Entity &
-    MovementCapability &
-    EnergyCapability &
+    Partial<MovementCapability> &
+    Partial<EnergyCapability> &
     StorageCapability &
-    LoaderCapability &
+    Partial<LoaderCapability> &
     MassCapability &
     ScheduleCapability & {
-        trade?: ServerContract.Types.trade_stats
         extractor?: ServerContract.Types.extractor_stats
     }
 

package/src/types.ts

@@ -12,44 +12,19 @@ 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
-export const INITIAL_SHIP_HULLMASS = 100000
-export const INITIAL_SHIP_CAPACITY = 500000
-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
+export const BASE_ORBITAL_MASS = 100000
 
 export interface ShipLike {
     coordinates: ServerContract.Types.coordinates
@@ -74,6 +49,8 @@ export enum TaskType {
     UNLOAD = 4,
     EXTRACT = 5,
     WARP = 6,
+    CRAFT = 7,
+    DEPLOY = 8,
 }
 
 export enum LocationType {
@@ -84,9 +61,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 +121,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 +129,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)
-    }
-}

package/src/market/market.ts

@@ -1,195 +0,0 @@
-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'
-
-export enum Rarities {
-    legendary = 'LEGENDARY',
-    epic = 'EPIC',
-    rare = 'RARE',
-    uncommon = 'UNCOMMON',
-    common = 'COMMON',
-    trash = 'TRASH',
-}
-
-export interface Rarity {
-    rarity: Rarities
-    minMultiplier: number
-    maxMultiplier: number
-}
-
-export function getRarity(
-    gameSeed: Checksum256Type,
-    epochSeed: Checksum256Type,
-    location: CoordinatesType,
-    goodId: UInt16Type
-): Rarity {
-    const seed = `${epochSeed}${location.x}${location.y}${goodId}rarity`
-    const rarityRoll = roll(gameSeed, seed)
-
-    if (rarityRoll < 13) {
-        return {
-            rarity: Rarities.legendary,
-            minMultiplier: 2.25,
-            maxMultiplier: 3.0,
-        }
-    } else if (rarityRoll < 176) {
-        return {
-            rarity: Rarities.epic,
-            minMultiplier: 1.75,
-            maxMultiplier: 2.25,
-        }
-    } else if (rarityRoll < 996) {
-        return {
-            rarity: Rarities.rare,
-            minMultiplier: 1.4,
-            maxMultiplier: 1.75,
-        }
-    } else if (rarityRoll < 2966) {
-        return {
-            rarity: Rarities.uncommon,
-            minMultiplier: 1.225,
-            maxMultiplier: 1.4,
-        }
-    } else if (rarityRoll < 19568) {
-        return {
-            rarity: Rarities.common,
-            minMultiplier: 1.07,
-            maxMultiplier: 1.225,
-        }
-    } else if (rarityRoll < 45988) {
-        return {
-            rarity: Rarities.trash,
-            minMultiplier: 1,
-            maxMultiplier: 1.07,
-        }
-    } else if (rarityRoll < 62508) {
-        return {
-            rarity: Rarities.common,
-            minMultiplier: 0.925,
-            maxMultiplier: 1,
-        }
-    } else if (rarityRoll < 64518) {
-        return {
-            rarity: Rarities.uncommon,
-            minMultiplier: 0.77,
-            maxMultiplier: 0.925,
-        }
-    } else if (rarityRoll < 65437) {
-        return {
-            rarity: Rarities.rare,
-            minMultiplier: 0.595,
-            maxMultiplier: 0.77,
-        }
-    } else if (rarityRoll < 65523) {
-        return {
-            rarity: Rarities.epic,
-            minMultiplier: 0.41,
-            maxMultiplier: 0.595,
-        }
-    } else {
-        return {
-            rarity: Rarities.legendary,
-            minMultiplier: 0.285,
-            maxMultiplier: 0.41,
-        }
-    }
-}
-
-export function getRarityMultiplier(
-    gameSeed: Checksum256Type,
-    epochSeed: Checksum256Type,
-    location: CoordinatesType,
-    goodId: UInt16Type
-): number {
-    const rarity = getRarity(gameSeed, epochSeed, location, goodId)
-    const range = rarity.maxMultiplier - rarity.minMultiplier
-    const seed = `${epochSeed}${location.x}${location.y}${goodId}raritymultiplier`
-    const r = roll(gameSeed, seed)
-    return rarity.minMultiplier + (r / 65535) * range
-}
-
-export function getLocationMultiplier(
-    gameSeed: Checksum256Type,
-    location: CoordinatesType,
-    goodId: UInt16Type
-): number {
-    const seed = `${location.x}${location.y}${goodId}locationmultiplier`
-    const r = roll(gameSeed, seed)
-    if (r < 13) {
-        return 0.75
-    } else if (r < 176) {
-        return 0.8
-    } else if (r < 996) {
-        return 0.85
-    } else if (r < 2966) {
-        return 0.9
-    } else if (r < 19568) {
-        return 0.95
-    } else if (r < 45988) {
-        return 1
-    } else if (r < 62508) {
-        return 1.05
-    } else if (r < 64518) {
-        return 1.1
-    } else if (r < 65437) {
-        return 1.15
-    } else if (r < 65523) {
-        return 1.2
-    } else {
-        return 1.25
-    }
-}
-
-export function getSupply(
-    gameSeed: Checksum256Type,
-    state: ServerContract.Types.state_row,
-    location: CoordinatesType,
-    goodId: UInt16Type
-): number {
-    const seed = `${state.seed}${location.x}${location.y}${goodId}supply`
-    const r = roll(gameSeed, seed)
-    const percent = r / 65535
-    const epoch = 1 + Number(state.epoch) / 90
-    const ship = 1
-    const goodIdNum = Number(goodId)
-    const base = Math.floor(128 / goodIdNum)
-    return Math.floor(base * percent * ship * epoch)
-}
-
-export function marketPrice(
-    location: ServerContract.ActionParams.Type.coordinates,
-    goodId: UInt16Type,
-    gameSeed: Checksum256Type,
-    state: ServerContract.Types.state_row
-): ItemPrice {
-    const item = getItem(goodId)
-    let price = Number(item.base_price)
-
-    const rarityMultiplier = getRarityMultiplier(gameSeed, state.seed, location, goodId)
-    price *= rarityMultiplier
-
-    // Location multiplier of the deal (static, based on game seed)
-    // Small impact range on price, from 1.0x to 1.5x
-    const locationMultiplier = getLocationMultiplier(gameSeed, location, goodId)
-    price *= locationMultiplier
-
-    // Determine the current supply of the good at the location
-    const supply = getSupply(gameSeed, state, location, goodId)
-
-    return ItemPrice.from({
-        id: goodId,
-        item,
-        price: UInt32.from(price),
-        supply: UInt16.from(supply),
-    })
-}
-
-export function marketPrices(
-    location: ServerContract.ActionParams.Type.coordinates,
-    gameSeed: Checksum256Type,
-    state: ServerContract.Types.state_row
-): ItemPrice[] {
-    return getItems().map((item) => marketPrice(location, item.id, gameSeed, state))
-}

package/src/market/rolls.ts

@@ -1,8 +0,0 @@
-import {Checksum256Type} from '@wharfkit/antelope'
-import {hash512} from '../utils/hash'
-
-export function roll(gameSeed: Checksum256Type, rollSeed: string): number {
-    const hash = hash512(gameSeed, rollSeed)
-    // Combine the first two bytes to form a uint16_t value
-    return (hash.array[0] << 8) | hash.array[1]
-}