@shipload/sdk 2.0.0-rc2 → 2.0.0-rc21

package/src/types.ts

@@ -1,68 +1,33 @@
-import {
-    Int64Type,
-    Name,
-    Struct,
-    UInt16,
-    UInt16Type,
-    UInt32,
-    UInt32Type,
-    UInt64,
-} from '@wharfkit/antelope'
+import {Int64Type, Name, UInt16, UInt16Type, UInt32, UInt32Type, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from './contracts'
 
 export const PRECISION = 10000
+export const CRAFT_ENERGY_DIVISOR = 150000
 
-// 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
-    hullmass: UInt32
-    energy: UInt16
-    engines: ServerContract.Types.movement_stats
-    generator: ServerContract.Types.energy_stats
-    loaders: ServerContract.Types.loader_stats
-    capacity: UInt32
+    hullmass?: UInt32
+    energy?: UInt16
+    engines?: ServerContract.Types.movement_stats
+    generator?: ServerContract.Types.energy_stats
+    loaders?: ServerContract.Types.loader_stats
+    hauler?: ServerContract.Types.hauler_stats
+    capacity?: UInt32
 }
 
 export interface CargoMassInfo {
-    good_id: UInt16Type
+    item_id: UInt16Type
     quantity: UInt32Type
 }
 
@@ -72,7 +37,12 @@ export enum TaskType {
     RECHARGE = 2,
     LOAD = 3,
     UNLOAD = 4,
-    EXTRACT = 5,
+    GATHER = 5,
+    WARP = 6,
+    CRAFT = 7,
+    DEPLOY = 8,
+    WRAP = 9,
+    UNWRAP = 10,
 }
 
 export enum LocationType {
@@ -83,9 +53,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 = {
@@ -131,28 +101,58 @@ export interface Distance {
     distance: UInt16
 }
 
-@Struct.type('good')
-export class Good extends Struct {
-    @Struct.field(UInt16)
-    id!: UInt16
-    @Struct.field('string')
-    name!: string
-    @Struct.field('string')
-    description!: string
-    @Struct.field(UInt32)
-    base_price!: UInt32
-    @Struct.field(UInt32)
-    mass!: UInt32
+export type ItemType = 'resource' | 'component' | 'module' | 'entity'
+export type ResourceCategory = 'ore' | 'crystal' | 'gas' | 'regolith' | 'biomass'
+export type ResourceTier = 't1' | 't2' | 't3' | 't4' | 't5'
+export type ModuleType =
+    | 'any'
+    | 'engine'
+    | 'generator'
+    | 'gatherer'
+    | 'loader'
+    | 'warp'
+    | 'crafter'
+    | 'launcher'
+    | 'storage'
+    | 'hauler'
+
+export const TIER_ADJECTIVES: Record<number, string> = {
+    1: 'Crude',
+    2: 'Dense',
+    3: 'Pure',
+    4: 'Prime',
+    5: 'Pristine',
+    6: 'Radiant',
+    7: 'Exotic',
+    8: 'Mythic',
+    9: 'Cosmic',
+    10: 'Ascendant',
+}
+
+export const CATEGORY_LABELS: Record<ResourceCategory, string> = {
+    ore: 'Ore',
+    crystal: 'Crystal',
+    gas: 'Gas',
+    regolith: 'Regolith',
+    biomass: 'Biomass',
+}
+
+export function tierNumber(tier: string): number {
+    return Number(String(tier).replace(/^t/i, ''))
+}
+
+export interface Item {
+    id: number
+    name: string
+    description: string
+    color: string
+    mass: number
+    type: ItemType
+    tier: number
+    category?: ResourceCategory
+    moduleType?: ModuleType
 }
 
-@Struct.type('GoodPrice')
-export class GoodPrice extends Struct {
-    @Struct.field(UInt16)
-    id!: UInt16
-    @Struct.field(Good)
-    good!: Good
-    @Struct.field(UInt32)
-    price!: UInt32
-    @Struct.field(UInt16)
-    supply!: UInt16
+export function formatTier(tier: number): string {
+    return 'T' + tier
 }

package/src/utils/system.ts

@@ -1,8 +1,11 @@
-import {Checksum256, Checksum256Type, UInt8} from '@wharfkit/antelope'
+import {Checksum256, Checksum256Type, Checksum512, UInt8} from '@wharfkit/antelope'
 import {hash512} from './hash'
-import {Coordinates, CoordinatesType, LocationType, PRECISION} from '../types'
+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'
 
 const LOCATION_EXISTS_THRESHOLD = 0x10
 const LOCATION_ACTIVE_THRESHOLD = 0x80
@@ -27,27 +30,72 @@ export function getLocationType(
     return LocationType.NEBULA
 }
 
-export function isExtractableLocation(locationType: LocationType): boolean {
-    return locationType === LocationType.ASTEROID || locationType === LocationType.NEBULA
+export function isGatherableLocation(locationType: LocationType): boolean {
+    return locationType !== LocationType.EMPTY
 }
 
-export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string {
-    const seed = Checksum256.from(gameSeed)
-    if (!hasSystem(seed, location)) {
-        throw new Error("System doesn't exist at location")
+export function getLocationTypeName(type: LocationType): string {
+    switch (type) {
+        case LocationType.EMPTY:
+            return 'Empty'
+        case LocationType.PLANET:
+            return 'Planet'
+        case LocationType.ASTEROID:
+            return 'Asteroid'
+        case LocationType.NEBULA:
+            return 'Nebula'
     }
-    const seedStr = `${location.x}${location.y}systemName`
-    const hashResult = hash512(seed, seedStr)
-    const syllableCount = 1 + (hashResult.array[0] % 3)
+}
+
+function uint16(hash: Checksum512, offset: number): number {
+    return (hash.array[offset] << 8) | hash.array[offset + 1]
+}
+
+function generatePlanetName(hashResult: Checksum512): string {
+    const syllableCount = 2 + (hashResult.array[0] % 2)
     const name: string[] = []
     for (let i = 0; i < syllableCount; i++) {
-        const index = hashResult.array[i] % syllables.length
+        const index = uint16(hashResult, 1 + i * 2) % syllables.length
         const syllable = syllables[index]
         name.push(i > 0 ? syllable.toLowerCase() : syllable)
     }
     return name.join('')
 }
 
+function generateAsteroidName(hashResult: Checksum512): string {
+    const A = 65
+    const letter1 = String.fromCharCode(A + (hashResult.array[0] % 26))
+    const letter2 = String.fromCharCode(A + (hashResult.array[1] % 26))
+    const num = (uint16(hashResult, 2) % 9000) + 1000
+    return `${letter1}${letter2}-${num}`
+}
+
+function generateNebulaName(hashResult: Checksum512): string {
+    const adjIdx = uint16(hashResult, 0) % nebulaAdjectives.length
+    const nounIdx = uint16(hashResult, 2) % nebulaNouns.length
+    return `${nebulaAdjectives[adjIdx]} ${nebulaNouns[nounIdx]}`
+}
+
+export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string {
+    const seed = Checksum256.from(gameSeed)
+    const locationType = getLocationType(seed, location)
+    if (locationType === LocationType.EMPTY) {
+        throw new Error("System doesn't exist at location")
+    }
+    const seedStr = `${location.x}-${location.y}-${locationType}-name`
+    const hashResult = hash512(seed, seedStr)
+    switch (locationType) {
+        case LocationType.PLANET:
+            return generatePlanetName(hashResult)
+        case LocationType.ASTEROID:
+            return generateAsteroidName(hashResult)
+        case LocationType.NEBULA:
+            return generateNebulaName(hashResult)
+        default:
+            return generatePlanetName(hashResult)
+    }
+}
+
 export function hasSystem(gameSeed: Checksum256Type, coordinates: CoordinatesType): boolean {
     return getLocationType(gameSeed, coordinates) !== LocationType.EMPTY
 }
@@ -81,7 +129,9 @@ export function deriveLocationStatic(
         loc.type = UInt8.from(LocationType.NEBULA)
     }
 
-    loc.subtype = UInt8.from(hashResult.array[2])
+    loc.subtype = UInt8.from(
+        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])
 
@@ -109,47 +159,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),
     })
 }
-
-export function deriveLocationMixture(
-    location: ServerContract.Types.location_derived,
-    epochSeed: Checksum256Type
-): ServerContract.Types.mixture_info {
-    const locationType = location.static_props.type.toNumber()
-
-    if (locationType === LocationType.NEBULA) {
-        return ServerContract.Types.mixture_info.from({
-            components: [{good_id: 1, purity: PRECISION}],
-        })
-    }
-
-    if (locationType === LocationType.ASTEROID) {
-        const seed = Checksum256.from(epochSeed)
-        const coords = location.static_props.coords
-        const str = `mixture-${coords.x}-${coords.y}`
-        const hashResult = hash512(seed, str)
-
-        const ironPrimary = location.static_props.subtype.toNumber() % 2 === 0
-        const purityRange = 0.3
-        const purityRoll = hashResult.array[0] / 255
-        const primaryPurity = 0.5 + purityRoll * purityRange
-
-        const primaryId = ironPrimary ? 26 : 29
-        const secondaryId = ironPrimary ? 29 : 26
-        const primaryAmt = Math.floor(primaryPurity * PRECISION)
-        const secondaryAmt = PRECISION - primaryAmt
-
-        return ServerContract.Types.mixture_info.from({
-            components: [
-                {good_id: primaryId, purity: primaryAmt},
-                {good_id: secondaryId, purity: secondaryAmt},
-            ],
-        })
-    }
-
-    return ServerContract.Types.mixture_info.from({components: []})
-}

package/src/capabilities/extraction.ts

@@ -1,37 +0,0 @@
-import {UInt16, UInt32} from '@wharfkit/antelope'
-import {ServerContract} from '../contracts'
-import {PRECISION} from '../types'
-
-function calc_load_time_internal(
-    loaders: ServerContract.Types.loader_stats,
-    shipZ: number,
-    cargoMass: number
-): number {
-    if (cargoMass === 0 || loaders.quantity.toNumber() === 0 || loaders.thrust.toNumber() === 0) {
-        return 0
-    }
-
-    const totalMass = cargoMass + loaders.mass.toNumber()
-    const acceleration = (loaders.thrust.toNumber() / totalMass) * PRECISION
-    const flightTime = Math.floor(2 * Math.sqrt(shipZ / acceleration))
-    return Math.floor(flightTime / loaders.quantity.toNumber())
-}
-
-export function calc_extraction_duration(
-    extractor: ServerContract.Types.extractor_stats,
-    loaders: ServerContract.Types.loader_stats,
-    shipZ: number,
-    batchMass: number
-): UInt32 {
-    const extractionTime = Math.floor(batchMass / extractor.rate.toNumber())
-    const loadingTime = calc_load_time_internal(loaders, shipZ, batchMass)
-    return UInt32.from(Math.max(extractionTime, loadingTime))
-}
-
-export function calc_extraction_energy(
-    extractor: ServerContract.Types.extractor_stats,
-    duration: number
-): UInt16 {
-    const energy = Math.floor((duration * extractor.drain.toNumber()) / PRECISION)
-    return UInt16.from(energy)
-}

package/src/data/goods.json

@@ -1,23 +0,0 @@
-[
-    {
-        "id": 1,
-        "name": "Hydrogen",
-        "description": "A lightweight fuel source essential for interstellar travel.",
-        "base_price": 50,
-        "mass": 15000
-    },
-    {
-        "id": 26,
-        "name": "Iron",
-        "description": "A versatile metal used in construction and manufacturing.",
-        "base_price": 125,
-        "mass": 40000
-    },
-    {
-        "id": 29,
-        "name": "Copper",
-        "description": "A conductive metal vital for electronics and wiring.",
-        "base_price": 200,
-        "mass": 60000
-    }
-]

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, GoodPrice} 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 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<GoodPrice[]> => {
-            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 GoodPrice.from({
-                        id: price.id,
-                        good: price.good,
-                        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/goods.ts

@@ -1,31 +0,0 @@
-import {UInt16, UInt16Type, UInt32} from '@wharfkit/antelope'
-import {Good} from '../types'
-import goodsData from '../data/goods.json'
-
-const goods = goodsData as Array<{
-    id: number
-    name: string
-    description: string
-    base_price: number
-    mass: number
-}>
-
-export const goodIds = goods.map((g) => g.id)
-
-export function getGood(goodId: UInt16Type): Good {
-    const good = goods.find((g) => UInt16.from(goodId).equals(g.id))
-    if (!good) {
-        throw new Error('Good does not exist')
-    }
-    return Good.from({
-        id: UInt16.from(good.id),
-        name: good.name,
-        description: good.description,
-        base_price: UInt32.from(good.base_price),
-        mass: UInt32.from(good.mass),
-    })
-}
-
-export function getGoods(): Good[] {
-    return goods.map((g) => getGood(g.id))
-}