@shipload/sdk 2.0.0-rc5 → 2.0.0-rc7

package/src/derivation/stats.ts

@@ -9,33 +9,109 @@ export interface StatDefinition {
 }
 
 const METAL_STATS: StatDefinition[] = [
-    {key: 'strength', label: 'Strength', abbreviation: 'STR', purpose: 'Raw structural/mechanical force'},
-    {key: 'tolerance', label: 'Tolerance', abbreviation: 'TOL', purpose: 'Ability to withstand heat, pressure, and stress extremes'},
-    {key: 'density', label: 'Density', abbreviation: 'DEN', purpose: 'Mass per unit', inverted: true},
+    {
+        key: 'strength',
+        label: 'Strength',
+        abbreviation: 'STR',
+        purpose: 'Raw structural/mechanical force',
+    },
+    {
+        key: 'tolerance',
+        label: 'Tolerance',
+        abbreviation: 'TOL',
+        purpose: 'Ability to withstand heat, pressure, and stress extremes',
+    },
+    {
+        key: 'density',
+        label: 'Density',
+        abbreviation: 'DEN',
+        purpose: 'Mass per unit',
+        inverted: true,
+    },
 ]
 
 const PRECIOUS_STATS: StatDefinition[] = [
-    {key: 'conductivity', label: 'Conductivity', abbreviation: 'CON', purpose: 'Efficiency of energy/signal transfer'},
-    {key: 'ductility', label: 'Ductility', abbreviation: 'DUC', purpose: 'Ability to be worked into fine, precise shapes'},
-    {key: 'reflectivity', label: 'Reflectivity', abbreviation: 'REF', purpose: 'Surface quality for heat management and precision optics'},
+    {
+        key: 'conductivity',
+        label: 'Conductivity',
+        abbreviation: 'CON',
+        purpose: 'Efficiency of energy/signal transfer',
+    },
+    {
+        key: 'ductility',
+        label: 'Ductility',
+        abbreviation: 'DUC',
+        purpose: 'Ability to be worked into fine, precise shapes',
+    },
+    {
+        key: 'reflectivity',
+        label: 'Reflectivity',
+        abbreviation: 'REF',
+        purpose: 'Surface quality for heat management and precision optics',
+    },
 ]
 
 const GAS_STATS: StatDefinition[] = [
-    {key: 'volatility', label: 'Volatility', abbreviation: 'VOL', purpose: 'Energy release potential for propulsion and force'},
-    {key: 'reactivity', label: 'Reactivity', abbreviation: 'REA', purpose: 'Chemical interaction speed for processing and penetration'},
-    {key: 'thermal', label: 'Thermal', abbreviation: 'THM', purpose: 'Heat capacity for thermal management'},
+    {
+        key: 'volatility',
+        label: 'Volatility',
+        abbreviation: 'VOL',
+        purpose: 'Energy release potential for propulsion and force',
+    },
+    {
+        key: 'reactivity',
+        label: 'Reactivity',
+        abbreviation: 'REA',
+        purpose: 'Chemical interaction speed for processing and penetration',
+    },
+    {
+        key: 'thermal',
+        label: 'Thermal',
+        abbreviation: 'THM',
+        purpose: 'Heat capacity for thermal management',
+    },
 ]
 
 const MINERAL_STATS: StatDefinition[] = [
-    {key: 'resonance', label: 'Resonance', abbreviation: 'RES', purpose: 'Energy field interaction — storage, focusing, projection'},
-    {key: 'hardness', label: 'Hardness', abbreviation: 'HRD', purpose: 'Resistance to wear — cutting surfaces, penetration'},
-    {key: 'clarity', label: 'Clarity', abbreviation: 'CLR', purpose: 'Crystalline perfection — precision optics'},
+    {
+        key: 'resonance',
+        label: 'Resonance',
+        abbreviation: 'RES',
+        purpose: 'Energy field interaction — storage, focusing, projection',
+    },
+    {
+        key: 'hardness',
+        label: 'Hardness',
+        abbreviation: 'HRD',
+        purpose: 'Resistance to wear — cutting surfaces, penetration',
+    },
+    {
+        key: 'clarity',
+        label: 'Clarity',
+        abbreviation: 'CLR',
+        purpose: 'Crystalline perfection — precision optics',
+    },
 ]
 
 const ORGANIC_STATS: StatDefinition[] = [
-    {key: 'plasticity', label: 'Plasticity', abbreviation: 'PLA', purpose: 'Ease of reshaping — speeds processing'},
-    {key: 'insulation', label: 'Insulation', abbreviation: 'INS', purpose: 'Energy containment — reduces energy loss'},
-    {key: 'purity', label: 'Purity', abbreviation: 'PUR', purpose: 'Biological cleanliness — better composites and lubricants'},
+    {
+        key: 'plasticity',
+        label: 'Plasticity',
+        abbreviation: 'PLA',
+        purpose: 'Ease of reshaping — speeds processing',
+    },
+    {
+        key: 'insulation',
+        label: 'Insulation',
+        abbreviation: 'INS',
+        purpose: 'Energy containment — reduces energy loss',
+    },
+    {
+        key: 'purity',
+        label: 'Purity',
+        abbreviation: 'PUR',
+        purpose: 'Biological cleanliness — better composites and lubricants',
+    },
 ]
 
 const STAT_MAP: Record<ResourceCategory, StatDefinition[]> = {

package/src/derivation/stratum.ts

@@ -85,7 +85,7 @@ export function deriveStratum(
 
     let depthBonus = 0
     if (stratum > 1) {
-        depthBonus = 50 * Math.log(stratum) / Math.log(65535)
+        depthBonus = (50 * Math.log(stratum)) / Math.log(65535)
     }
     const richness = Math.min(Math.floor(baseRichness + depthBonus), 1000)
 
@@ -95,7 +95,7 @@ export function deriveStratum(
 export function deriveResourceStats(seed: bigint): ResourceStats {
     const seedBytes = new Uint8Array(8)
     for (let i = 7; i >= 0; i--) {
-        seedBytes[i] = Number(seed & 0xFFn)
+        seedBytes[i] = Number(seed & 0xffn)
         seed >>= 8n
     }
     const hashResult = Checksum256.hash(Bytes.from(seedBytes))

package/src/entities/cargo-utils.ts

@@ -12,12 +12,6 @@ export function totalCargoMass(cargo: EntityInventory[]): UInt64 {
     }, UInt64.from(0))
 }
 
-export function cargoValue(cargo: EntityInventory[]): UInt64 {
-    return cargo.reduce((sum, c) => {
-        return sum.adding(c.totalCost)
-    }, UInt64.from(0))
-}
-
 export function getCargoForItem(
     cargo: EntityInventory[],
     goodId: UInt64Type
@@ -47,84 +41,33 @@ export function isFull(currentMass: UInt64, maxCapacity: UInt64): boolean {
     return currentMass.gte(maxCapacity)
 }
 
-export interface SaleValue {
-    revenue: UInt64
-    profit: UInt64
-    cost: UInt64
-}
-
-export function calculateSaleValue(
-    cargo: ServerContract.Types.cargo_item[],
-    prices: Map<number, UInt64>
-): SaleValue {
-    if (cargo.length === 0) {
-        return {revenue: UInt64.from(0), profit: UInt64.from(0), cost: UInt64.from(0)}
-    }
-
-    let revenue = UInt64.from(0)
-    let cost = UInt64.from(0)
-
-    for (const item of cargo) {
-        if (UInt32.from(item.quantity).equals(UInt32.from(0))) continue
-
-        const goodId = Number(item.item_id)
-        const salePrice = prices.get(goodId)
-
-        if (salePrice) {
-            revenue = revenue.adding(salePrice.multiplying(item.quantity))
-        }
-
-        cost = cost.adding(item.unit_cost.multiplying(item.quantity))
-    }
-
-    const profit = revenue.gte(cost) ? revenue.subtracting(cost) : UInt64.from(0)
-
-    return {
-        revenue,
-        profit,
-        cost,
-    }
-}
-
-export function calculateSaleValueFromArray(
-    cargo: ServerContract.Types.cargo_item[],
-    prices: UInt64[]
-): SaleValue {
-    const priceMap = new Map<number, UInt64>()
-    prices.forEach((price, index) => {
-        priceMap.set(index, price)
-    })
-    return calculateSaleValue(cargo, priceMap)
-}
-
-export function afterSellItems(
+export function afterRemoveItems(
     cargo: ServerContract.Types.cargo_item[],
-    goodsToSell: Array<{goodId: number; quantity: number}>
+    goodsToRemove: Array<{goodId: number; quantity: number}>
 ): EntityInventory[] {
     if (cargo.length === 0) {
         return []
     }
 
     return cargo.map((item) => {
-        const saleItem = goodsToSell.find((s) => Number(item.item_id) === s.goodId)
-        if (!saleItem) {
+        const removeItem = goodsToRemove.find((s) => Number(item.item_id) === s.goodId)
+        if (!removeItem) {
             return new EntityInventory(item)
         }
 
         const currentQty = Number(item.quantity)
-        const newQty = Math.max(0, currentQty - saleItem.quantity)
+        const newQty = Math.max(0, currentQty - removeItem.quantity)
 
         return new EntityInventory(
             ServerContract.Types.cargo_item.from({
                 item_id: item.item_id,
                 quantity: UInt32.from(newQty),
-                unit_cost: item.unit_cost,
             })
         )
     })
 }
 
-export function afterSellAllItems(cargo: ServerContract.Types.cargo_item[]): EntityInventory[] {
+export function afterRemoveAllItems(cargo: ServerContract.Types.cargo_item[]): EntityInventory[] {
     if (cargo.length === 0) {
         return []
     }
@@ -135,7 +78,6 @@ export function afterSellAllItems(cargo: ServerContract.Types.cargo_item[]): Ent
                 ServerContract.Types.cargo_item.from({
                     item_id: item.item_id,
                     quantity: UInt32.from(0),
-                    unit_cost: item.unit_cost,
                 })
             )
     )

package/src/entities/container.ts

@@ -68,3 +68,21 @@ export class Container extends ServerContract.Types.entity_info {
         return this.coordinates.z?.toNumber() || 0
     }
 }
+
+export function computeContainerCapabilities(stats: Record<string, number>): {
+	hullmass: number
+	capacity: number
+} {
+	const density = stats['density'] ?? 500
+	const strength = stats['strength'] ?? 500
+	const ductility = stats['ductility'] ?? 500
+	const purity = stats['purity'] ?? 500
+
+	const hullmass = 25000 + 75 * density
+
+	const statSum = strength + ductility + purity
+	const exponent = statSum / 2997
+	const capacity = Math.floor(1000000 * Math.pow(10, exponent))
+
+	return {hullmass, capacity}
+}

package/src/entities/entity-inventory.ts

@@ -29,10 +29,6 @@ export class EntityInventory extends ServerContract.Types.cargo_item {
         return UInt64.from(this.unitMass).multiplying(this.quantity)
     }
 
-    get totalCost(): UInt64 {
-        return this.unit_cost.multiplying(this.quantity)
-    }
-
     get hasCargo(): boolean {
         return UInt32.from(this.quantity).gt(UInt32.from(0))
     }

package/src/entities/inventory-accessor.ts

@@ -20,10 +20,6 @@ export class InventoryAccessor {
         return this.items.reduce((sum, c) => sum.adding(c.totalMass), UInt64.from(0))
     }
 
-    get totalValue(): UInt64 {
-        return this.items.reduce((sum, c) => sum.adding(c.totalCost), UInt64.from(0))
-    }
-
     forItem(goodId: UInt64Type): EntityInventory | undefined {
         return this.items.find((c) => c.item_id.equals(goodId))
     }

package/src/entities/location.ts

@@ -1,35 +1,22 @@
-import {Checksum256, Checksum256Type, UInt16, UInt16Type, UInt64} from '@wharfkit/antelope'
-import {ServerContract} from '../contracts'
-import {Coordinates, CoordinatesType, Distance, ItemPrice, LocationType} from '../types'
+import {Checksum256, Checksum256Type, UInt16Type, UInt64} from '@wharfkit/antelope'
+import {Coordinates, CoordinatesType, Distance, LocationType} from '../types'
 import {getLocationType, hasSystem, isExtractableLocation} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 
-/**
- * Location helper class for working with game coordinates.
- * Provides system detection, market price caching, nearby planet finding, and supply tracking.
- */
 export class Location {
     readonly coordinates: Coordinates
-    private _marketPrices?: ItemPrice[]
     private _gameSeed?: Checksum256
     private _hasSystem?: boolean
-    private _locationRows?: ServerContract.Types.supply_row[]
     private _epoch?: UInt64
 
     constructor(coordinates: CoordinatesType) {
         this.coordinates = Coordinates.from(coordinates)
     }
 
-    /**
-     * Create a Location from coordinates
-     */
     static from(coordinates: CoordinatesType): Location {
         return new Location(Coordinates.from(coordinates))
     }
 
-    /**
-     * Check if this location has a system (planet, asteroid, or nebula)
-     */
     hasSystemAt(gameSeed: Checksum256Type): boolean {
         const seed = Checksum256.from(gameSeed)
         if (this._hasSystem === undefined || !this._gameSeed?.equals(seed)) {
@@ -39,214 +26,32 @@ export class Location {
         return this._hasSystem
     }
 
-    /**
-     * Get the location type (EMPTY, PLANET, ASTEROID, or NEBULA)
-     */
     getLocationTypeAt(gameSeed: Checksum256Type): LocationType {
         return getLocationType(gameSeed, this.coordinates)
     }
 
-    /**
-     * Check if this location is extractable (asteroid or nebula)
-     */
     isExtractableAt(gameSeed: Checksum256Type): boolean {
         return isExtractableLocation(this.getLocationTypeAt(gameSeed))
     }
 
-    /**
-     * Set cached market prices for this location
-     */
-    setMarketPrices(prices: ItemPrice[]): void {
-        this._marketPrices = prices
-    }
-
-    /**
-     * Get cached market prices (returns undefined if not cached)
-     */
-    get marketPrices(): ItemPrice[] | undefined {
-        return this._marketPrices
-    }
-
-    /**
-     * Get price for a specific good (from cache)
-     */
-    getPrice(goodId: UInt16Type): ItemPrice | undefined {
-        if (!this._marketPrices) return undefined
-        return this._marketPrices.find((p) => p.id.equals(goodId))
-    }
-
-    /**
-     * Find nearby planets from this location
-     */
     findNearby(gameSeed: Checksum256Type, maxDistance: UInt16Type = 20): Distance[] {
         return findNearbyPlanets(Checksum256.from(gameSeed), this.coordinates, maxDistance)
     }
 
-    /**
-     * Check if this location equals another location
-     */
     equals(other: CoordinatesType | Location): boolean {
         const otherCoords = other instanceof Location ? other.coordinates : Coordinates.from(other)
         return this.coordinates.equals(otherCoords)
     }
 
-    /**
-     * Set location rows (supply data) for this location
-     */
-    setLocationRows(rows: ServerContract.Types.supply_row[], epoch: UInt64): void {
-        this._locationRows = rows
-        this._epoch = epoch
-    }
-
-    /**
-     * Get cached location rows (supply data)
-     */
-    get locationRows(): ServerContract.Types.supply_row[] | undefined {
-        return this._locationRows
-    }
-
-    /**
-     * Get supply for a specific good at this location
-     * Returns undefined if location rows not cached or good not found
-     */
-    getSupply(goodId: UInt16Type): UInt16 | undefined {
-        if (!this._locationRows) return undefined
-        const row = this._locationRows.find(
-            (r) => r.item_id.equals(goodId) && this._epoch && r.epoch.equals(this._epoch)
-        )
-        return row ? row.supply : undefined
-    }
-
-    /**
-     * Get all available goods at this location (goods with supply > 0)
-     * Returns undefined if location rows not cached
-     */
-    get availableGoods(): ServerContract.Types.supply_row[] | undefined {
-        if (!this._locationRows) return undefined
-        return this._locationRows.filter(
-            (r) => this._epoch && r.epoch.equals(this._epoch) && r.supply.gt(UInt16.from(0))
-        )
-    }
-
-    /**
-     * Check if a specific good is available (has supply)
-     * Returns false if location rows not cached
-     */
-    hasGood(goodId: UInt16Type): boolean {
-        const supply = this.getSupply(goodId)
-        return supply !== undefined && supply.gt(UInt16.from(0))
-    }
-
-    /**
-     * Get the epoch for cached location data
-     */
     get epoch(): UInt64 | undefined {
         return this._epoch
     }
 
-    /**
-     * Check if cached data exists
-     */
-    get hasCachedData(): boolean {
-        return this._marketPrices !== undefined || this._locationRows !== undefined
-    }
-
-    /**
-     * Check if supply data is cached
-     */
-    get hasSupplyData(): boolean {
-        return this._locationRows !== undefined
-    }
-
-    /**
-     * Clear all cached data
-     */
     clearCache(): void {
-        this._marketPrices = undefined
-        this._locationRows = undefined
         this._epoch = undefined
     }
-
-    /**
-     * Create optimistic Location with updated supply after purchase/sale.
-     * Matches contract: update_location_supply (delta can be positive or negative)
-     * Contract reference: market.cpp:53, 123-151
-     *
-     * @param goodId - Good ID to update supply for
-     * @param quantityDelta - Change in supply (negative for purchase, positive for sale)
-     * @returns New Location with updated supply in cached data
-     *
-     * @example
-     * // After buying 10 units (supply decreases)
-     * const newLocation = location.withUpdatedSupply(1, -10)
-     *
-     * // After selling 5 units (supply increases)
-     * const newLocation = location.withUpdatedSupply(1, 5)
-     */
-    withUpdatedSupply(goodId: UInt16Type, quantityDelta: number): Location {
-        const newLocation = Location.from(this.coordinates)
-
-        // Copy market prices if cached
-        if (this._marketPrices) {
-            newLocation._marketPrices = this._marketPrices.map((price) => {
-                if (price.id.equals(goodId)) {
-                    const currentSupply = UInt16.from(price.supply)
-                    const delta = UInt16.from(Math.abs(quantityDelta))
-                    const newSupply =
-                        quantityDelta < 0
-                            ? currentSupply.gte(delta)
-                                ? currentSupply.subtracting(delta)
-                                : UInt16.from(0)
-                            : currentSupply.adding(quantityDelta)
-
-                    return ItemPrice.from({
-                        id: price.id,
-                        item: price.item,
-                        price: price.price,
-                        supply: newSupply,
-                    })
-                }
-                return price
-            })
-        }
-
-        // Copy location rows if cached
-        if (this._locationRows && this._epoch) {
-            newLocation._locationRows = this._locationRows.map((row) => {
-                if (row.item_id.equals(goodId) && row.epoch.equals(this._epoch!)) {
-                    const currentSupply = UInt16.from(row.supply)
-                    const delta = UInt16.from(Math.abs(quantityDelta))
-                    const newSupply =
-                        quantityDelta < 0
-                            ? currentSupply.gte(delta)
-                                ? currentSupply.subtracting(delta)
-                                : UInt16.from(0)
-                            : currentSupply.adding(quantityDelta)
-
-                    return ServerContract.Types.supply_row.from({
-                        id: row.id,
-                        coordinates: row.coordinates,
-                        epoch: row.epoch,
-                        item_id: row.item_id,
-                        supply: newSupply,
-                    })
-                }
-                return row
-            })
-            newLocation._epoch = this._epoch
-        }
-
-        // Copy other cached data
-        newLocation._gameSeed = this._gameSeed
-        newLocation._hasSystem = this._hasSystem
-
-        return newLocation
-    }
 }
 
-/**
- * Helper function to convert various coordinate types to Location
- */
 export function toLocation(coords: CoordinatesType | Location): Location {
     if (coords instanceof Location) {
         return coords

package/src/entities/makers.ts

@@ -5,26 +5,27 @@ import {Warehouse, WarehouseStateInput} from './warehouse'
 import {Container, ContainerStateInput} from './container'
 
 export function makeShip(state: ShipStateInput): Ship {
-    const entityInfo = ServerContract.Types.entity_info.from({
+    const info: Record<string, unknown> = {
         type: Name.from('ship'),
         id: UInt64.from(state.id),
         owner: Name.from(state.owner),
         entity_name: state.name,
         coordinates: ServerContract.Types.coordinates.from(state.coordinates),
-        hullmass: UInt32.from(state.hullmass),
-        capacity: UInt32.from(state.capacity),
-        energy: UInt16.from(state.energy),
         cargomass: UInt32.from(0),
         cargo: state.cargo || [],
         is_idle: !state.schedule,
         current_task_elapsed: UInt32.from(0),
         current_task_remaining: UInt32.from(0),
         pending_tasks: [],
-        engines: state.engines,
-        generator: state.generator,
-        loaders: state.loaders,
-        schedule: state.schedule,
-    })
+    }
+    if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
+    if (state.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
+    if (state.energy !== undefined) info.energy = UInt16.from(state.energy)
+    if (state.engines) info.engines = state.engines
+    if (state.generator) info.generator = state.generator
+    if (state.loaders) info.loaders = state.loaders
+    if (state.schedule) info.schedule = state.schedule
+    const entityInfo = ServerContract.Types.entity_info.from(info)
     return new Ship(entityInfo)
 }