@shipload/sdk 2.0.0-rc4 → 2.0.0-rc6

package/src/derivation/stratum.ts

@@ -16,10 +16,9 @@ export interface StratumInfo {
 }
 
 export interface ResourceStats {
-    purity: number
-    density: number
-    reactivity: number
-    resonance: number
+    stat1: number
+    stat2: number
+    stat3: number
 }
 
 export function deriveStratum(
@@ -86,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)
 
@@ -94,15 +93,17 @@ export function deriveStratum(
 }
 
 export function deriveResourceStats(seed: bigint): ResourceStats {
-    const seedStr = seed.toString()
-    const encoder = new TextEncoder()
-    const data = encoder.encode(seedStr)
-    const hashResult = Checksum256.hash(Bytes.from(data))
+    const seedBytes = new Uint8Array(8)
+    for (let i = 7; i >= 0; i--) {
+        seedBytes[i] = Number(seed & 0xffn)
+        seed >>= 8n
+    }
+    const hashResult = Checksum256.hash(Bytes.from(seedBytes))
     const hashBytes = hashResult.array
 
     const extractU16 = (offset: number): number => (hashBytes[offset] << 8) | hashBytes[offset + 1]
 
-    const weibullStat = (raw: number): number => {
+    const weibull = (raw: number): number => {
         const u = raw / 65536
         let x = 0.27 * Math.sqrt(-Math.log(1 - u))
         if (x > 1) x = 1
@@ -110,9 +111,8 @@ export function deriveResourceStats(seed: bigint): ResourceStats {
     }
 
     return {
-        purity: weibullStat(extractU16(0)),
-        density: weibullStat(extractU16(2)),
-        reactivity: weibullStat(extractU16(4)),
-        resonance: weibullStat(extractU16(6)),
+        stat1: weibull(extractU16(0)),
+        stat2: weibull(extractU16(2)),
+        stat3: weibull(extractU16(4)),
     }
 }

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