@shipload/sdk 2.0.0-rc5 → 2.0.0-rc7

package/src/entities/player.ts

@@ -1,288 +1,15 @@
-import {
-    Int64,
-    Int64Type,
-    Name,
-    NameType,
-    UInt32,
-    UInt32Type,
-    UInt64,
-    UInt64Type,
-} from '@wharfkit/antelope'
+import {Name, NameType} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 
 export interface PlayerStateInput {
     owner: NameType
-    balance: UInt64Type
-    debt: UInt32Type
-    networth: Int64Type
 }
 
-/**
- * Player helper class extending player_row with computed financial properties.
- * Provides easy access to balance, debt, networth, and loan calculations.
- */
 export class Player extends ServerContract.Types.player_row {
-    /**
-     * Construct a Player instance from individual state pieces.
-     * Used by UI's ReactivePlayer to reconstruct Player from reactive state.
-     */
     static fromState(state: PlayerStateInput): Player {
         const playerRow = ServerContract.Types.player_row.from({
             owner: Name.from(state.owner),
-            balance: UInt64.from(state.balance),
-            debt: UInt32.from(state.debt),
-            networth: Int64.from(state.networth),
         })
         return new Player(playerRow)
     }
-    // Constants for game rules (match smart contract)
-    private static readonly MAX_LOAN = 1000000
-    // Contract formula: 2500 * pow(5, sequence - 1) = 500 * pow(5, sequence)
-    private static readonly BASE_SHIP_COST = 500
-    private static readonly SHIP_COST_MULTIPLIER = 5
-
-    // Optional ship count for nextShipCost calculation
-    private _shipCount?: number
-
-    /**
-     * Set the current ship count (needed for nextShipCost calculation)
-     */
-    setShipCount(count: number): void {
-        this._shipCount = count
-    }
-
-    /**
-     * Get the current ship count (if set)
-     */
-    get shipCount(): number | undefined {
-        return this._shipCount
-    }
-
-    /**
-     * Calculate the cost of the next ship based on current ship count
-     * Matches contract: pow(5, sequence) * 100
-     * @param shipCount - Optional ship count (uses cached value if not provided)
-     */
-    getNextShipCost(shipCount?: number): UInt64 {
-        const count = shipCount ?? this._shipCount ?? 0
-        const cost = Math.pow(Player.SHIP_COST_MULTIPLIER, count) * Player.BASE_SHIP_COST
-        return UInt64.from(Math.floor(cost))
-    }
-
-    /**
-     * Get the cost of the next ship based on cached ship count
-     */
-    get nextShipCost(): UInt64 {
-        return this.getNextShipCost()
-    }
-
-    /**
-     * Check if player can afford to buy a ship
-     * @param shipCount - Optional ship count (uses cached value if not provided)
-     */
-    canBuyShip(shipCount?: number): boolean {
-        return UInt64.from(this.balance).gte(this.getNextShipCost(shipCount))
-    }
-
-    /**
-     * Calculate available loan amount (max loan - current debt)
-     */
-    get availableLoan(): UInt64 {
-        const maxLoan = UInt64.from(Player.MAX_LOAN)
-        if (UInt64.from(this.debt).gte(maxLoan)) {
-            return UInt64.from(0)
-        }
-        return maxLoan.subtracting(this.debt)
-    }
-
-    /**
-     * Check if player can take out a loan
-     */
-    get canTakeLoan(): boolean {
-        return this.availableLoan.gt(UInt64.zero)
-    }
-
-    /**
-     * Check if player can pay back loan
-     */
-    get canPayLoan(): boolean {
-        return UInt64.from(this.debt).gt(UInt64.zero) && UInt64.from(this.balance).gt(UInt64.zero)
-    }
-
-    /**
-     * Calculate maximum payback amount (min of debt and balance)
-     */
-    get maxPayback(): UInt64 {
-        return UInt64.from(this.debt).lt(this.balance) ? this.debt : this.balance
-    }
-
-    /**
-     * Get the maximum loan amount (constant)
-     */
-    static get MAX_LOAN_LIMIT(): number {
-        return Player.MAX_LOAN
-    }
-
-    /**
-     * Check if player is in debt
-     */
-    get hasDebt(): boolean {
-        return UInt64.from(this.debt).gt(UInt64.zero)
-    }
-
-    /**
-     * Check if player is solvent (positive networth)
-     */
-    get isSolvent(): boolean {
-        return this.networth.gte(Int64.zero)
-    }
-
-    /**
-     * Create an optimistic update for balance changes
-     * Uses integer math to match contract
-     * @param delta - Amount to change (can be negative)
-     */
-    withBalanceChange(delta: UInt64 | number): Player {
-        const newPlayer = Player.from(this)
-        const amount = typeof delta === 'number' ? UInt64.from(Math.abs(delta)) : delta
-
-        if (typeof delta === 'number' && delta < 0) {
-            // Subtract, ensuring we don't go below 0
-            newPlayer.balance = UInt64.from(this.balance).gte(amount)
-                ? this.balance.subtracting(amount)
-                : UInt64.from(0)
-        } else {
-            // Add
-            newPlayer.balance = this.balance.adding(amount)
-        }
-
-        // Calculate networth as Int64 (can be negative)
-        const balanceInt = Int64.from(newPlayer.balance)
-        const debtInt = Int64.from(newPlayer.debt)
-        newPlayer.networth = balanceInt.subtracting(debtInt)
-        return newPlayer
-    }
-
-    /**
-     * Create an optimistic update for debt changes
-     * Uses integer math to match contract
-     * @param delta - Amount to change (can be negative)
-     */
-    withDebtChange(delta: UInt64 | number): Player {
-        const newPlayer = Player.from(this)
-        const amount = typeof delta === 'number' ? UInt64.from(Math.abs(delta)) : delta
-
-        if (typeof delta === 'number' && delta < 0) {
-            // Subtract, ensuring we don't go below 0
-            newPlayer.debt = UInt64.from(this.debt).gte(amount)
-                ? this.debt.subtracting(amount)
-                : UInt64.from(0)
-        } else {
-            // Add
-            newPlayer.debt = this.debt.adding(amount)
-        }
-
-        // Calculate networth as Int64 (can be negative)
-        const balanceInt = Int64.from(newPlayer.balance)
-        const debtInt = Int64.from(newPlayer.debt)
-        newPlayer.networth = balanceInt.subtracting(debtInt)
-        return newPlayer
-    }
-
-    /**
-     * Create an optimistic update for taking a loan
-     */
-    withLoan(amount: UInt64): Player {
-        const newPlayer = Player.from(this)
-        newPlayer.balance = this.balance.adding(amount)
-        newPlayer.debt = this.debt.adding(amount)
-        // Calculate networth as Int64 (can be negative)
-        const balanceInt = Int64.from(newPlayer.balance)
-        const debtInt = Int64.from(newPlayer.debt)
-        newPlayer.networth = balanceInt.subtracting(debtInt)
-        return newPlayer
-    }
-
-    /**
-     * Create an optimistic update for paying back a loan
-     */
-    withLoanPayment(amount: UInt64): Player {
-        const actualPayment = this.maxPayback.lt(amount) ? this.maxPayback : amount
-        const newPlayer = Player.from(this)
-        newPlayer.balance = this.balance.subtracting(actualPayment)
-        newPlayer.debt = this.debt.subtracting(actualPayment)
-        // Calculate networth as Int64 (can be negative)
-        const balanceInt = Int64.from(newPlayer.balance)
-        const debtInt = Int64.from(newPlayer.debt)
-        newPlayer.networth = balanceInt.subtracting(debtInt)
-        return newPlayer
-    }
-
-    /**
-     * Simulate networth update from selling goods.
-     * Matches contract: networth += (sellPrice - paid * quantity)
-     * Contract reference: market.cpp:75
-     *
-     * @param sellPrice - Total revenue from sale (price * quantity)
-     * @param paidPerUnit - Average cost per unit paid (from cargo.paid)
-     * @param quantity - Quantity being sold
-     * @returns New player with updated networth
-     *
-     * @example
-     * // Sold 10 units at 150 each (revenue=1500), paid 100 per unit
-     * const newPlayer = player.withSaleNetworth(
-     *     UInt64.from(1500),
-     *     UInt64.from(100),
-     *     UInt32.from(10)
-     * )
-     * // Networth increases by: 1500 - (100*10) = 500
-     */
-    withSaleNetworth(sellPrice: UInt64, paidPerUnit: UInt64, quantity: UInt64): Player {
-        // Match contract: price - paid * quantity
-        const cost = paidPerUnit.multiplying(quantity)
-        const profit = sellPrice.gte(cost) ? sellPrice.subtracting(cost) : Int64.from(0)
-
-        const newPlayer = Player.from(this)
-        newPlayer.networth = Int64.from(this.networth).adding(profit)
-        return newPlayer
-    }
-
-    /**
-     * Simulate complete sell goods transaction.
-     * Updates both balance (adds revenue) and networth (adds profit).
-     * Matches contract actions: update_balance + update_networth
-     *
-     * @param sellPrice - Total revenue from sale (price * quantity)
-     * @param paidPerUnit - Average cost per unit paid (from cargo.paid)
-     * @param quantity - Quantity being sold
-     * @returns New player with updated balance and networth
-     */
-    withSellGoods(sellPrice: UInt64, paidPerUnit: UInt64, quantity: UInt64): Player {
-        const cost = paidPerUnit.multiplying(quantity)
-        const profit = sellPrice.gte(cost) ? sellPrice.subtracting(cost) : Int64.from(0)
-
-        const newPlayer = Player.from(this)
-        newPlayer.balance = this.balance.adding(sellPrice)
-        newPlayer.networth = Int64.from(this.networth).adding(profit)
-        return newPlayer
-    }
-
-    /**
-     * Simulate complete buy goods transaction.
-     * Updates balance (subtracts cost).
-     *
-     * @param purchaseCost - Total cost of purchase (price * quantity)
-     * @returns New player with updated balance
-     */
-    withBuyGoods(purchaseCost: UInt64): Player {
-        const newPlayer = Player.from(this)
-        newPlayer.balance = UInt64.from(this.balance).gte(purchaseCost)
-            ? this.balance.subtracting(purchaseCost)
-            : UInt64.from(0)
-        // Calculate networth as Int64 (can be negative)
-        const balanceInt = Int64.from(newPlayer.balance)
-        const debtInt = Int64.from(newPlayer.debt)
-        newPlayer.networth = balanceInt.subtracting(debtInt)
-        return newPlayer
-    }
 }

package/src/entities/ship-deploy.ts

@@ -0,0 +1,89 @@
+export function computeShipHullCapabilities(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.0
+    const capacity = Math.floor(1000000 * Math.pow(10, exponent))
+
+    return {hullmass, capacity}
+}
+
+export function computeEngineCapabilities(stats: Record<string, number>): {
+    thrust: number
+    drain: number
+} {
+    const vol = stats.volatility ?? 500
+    const thm = stats.thermal ?? 500
+
+    return {
+        thrust: 400 + Math.floor(vol * 3 / 4),
+        drain: Math.max(16, 30 - Math.floor(thm / 70)),
+    }
+}
+
+export function computeGeneratorCapabilities(stats: Record<string, number>): {
+    capacity: number
+    recharge: number
+} {
+    const res = stats.resonance ?? 500
+    const clr = stats.clarity ?? 500
+
+    return {
+        capacity: 300 + Math.floor(res / 6),
+        recharge: 5 + Math.floor(clr * 15 / 1000),
+    }
+}
+
+export function computeExtractorCapabilities(stats: Record<string, number>): {
+    rate: number
+    drain: number
+    depth: number
+    drill: number
+} {
+    const str = stats.strength ?? 500
+    const con = stats.conductivity ?? 500
+    const ref = stats.reflectivity ?? 500
+    const tol = stats.tolerance ?? 500
+
+    return {
+        rate: 200 + str,
+        drain: Math.max(10, 50 - Math.floor(con / 20)),
+        depth: 200 + Math.floor(tol * 3 / 2),
+        drill: 100 + Math.floor(ref * 4 / 5),
+    }
+}
+
+export function computeLoaderCapabilities(stats: Record<string, number>): {
+    mass: number
+    thrust: number
+    quantity: number
+} {
+    const duc = stats.ductility ?? 500
+    const pla = stats.plasticity ?? 500
+
+    return {
+        mass: Math.max(200, 2000 - Math.floor(duc * 2)),
+        thrust: 1 + Math.floor(pla / 500),
+        quantity: 1,
+    }
+}
+
+export function computeManufacturingCapabilities(stats: Record<string, number>): {
+    speed: number
+    drain: number
+} {
+    const rea = stats.reactivity ?? 500
+    const clr = stats.clarity ?? 500
+
+    return {
+        speed: 100 + Math.floor(rea * 4 / 5),
+        drain: Math.max(5, 30 - Math.floor(clr / 33)),
+    }
+}

package/src/entities/ship.ts

@@ -21,7 +21,6 @@ import {
     hasEnergyForDistance,
     maxTravelDistance,
 } from '../capabilities/movement'
-import * as cargoUtils from './cargo-utils'
 import * as schedule from '../scheduling/schedule'
 
 export interface ShipStateInput {
@@ -29,12 +28,12 @@ export interface ShipStateInput {
     owner: string
     name: string
     coordinates: CoordinatesType | {x: number; y: number; z?: number}
-    hullmass: number
-    capacity: number
-    energy: number
-    engines: ServerContract.Types.movement_stats
-    generator: ServerContract.Types.energy_stats
-    loaders: ServerContract.Types.loader_stats
+    hullmass?: number
+    capacity?: number
+    energy?: number
+    engines?: ServerContract.Types.movement_stats
+    generator?: ServerContract.Types.energy_stats
+    loaders?: ServerContract.Types.loader_stats
     schedule?: ServerContract.Types.schedule
     cargo?: ServerContract.Types.cargo_item[]
 }
@@ -109,6 +108,14 @@ export class Ship extends ServerContract.Types.entity_info {
         return schedule.isExtracting(this, now)
     }
 
+    get hasEngines(): boolean {
+        return this.engines !== undefined
+    }
+
+    get hasGenerator(): boolean {
+        return this.generator !== undefined
+    }
+
     get hasExtractor(): boolean {
         return this.extractor !== undefined
     }
@@ -133,10 +140,6 @@ export class Ship extends ServerContract.Types.entity_info {
         return this.inv.totalMass
     }
 
-    get cargoValue(): UInt64 {
-        return this.inv.totalValue
-    }
-
     get totalMass(): UInt64 {
         let mass = UInt64.from(this.hullmass ?? 0).adding(this.totalCargoMass)
         if (this.loaders) {
@@ -193,20 +196,4 @@ export class Ship extends ServerContract.Types.entity_info {
         if (!this.engines || !this.generator || this.energy === undefined) return false
         return hasEnergyForDistance(this as MovementEntity, distance)
     }
-
-    calculateSaleValue(prices: Map<number, UInt64>): cargoUtils.SaleValue {
-        return cargoUtils.calculateSaleValue(this.cargo, prices)
-    }
-
-    calculateSaleValueFromArray(prices: UInt64[]): cargoUtils.SaleValue {
-        return cargoUtils.calculateSaleValueFromArray(this.cargo, prices)
-    }
-
-    afterSellItems(goodsToSell: Array<{goodId: number; quantity: number}>): EntityInventory[] {
-        return cargoUtils.afterSellItems(this.cargo, goodsToSell)
-    }
-
-    afterSellAllItems(): EntityInventory[] {
-        return cargoUtils.afterSellAllItems(this.cargo)
-    }
 }

package/src/entities/warehouse.ts

@@ -58,10 +58,6 @@ export class Warehouse extends ServerContract.Types.entity_info {
         return this.inv.totalMass
     }
 
-    get cargoValue(): UInt64 {
-        return this.inv.totalValue
-    }
-
     get maxCapacity(): UInt64 {
         return UInt64.from(this.capacity)
     }

package/src/index-module.ts

@@ -37,7 +37,6 @@ export {
     EntitiesManager,
     PlayersManager,
     LocationsManager,
-    TradesManager,
     EpochsManager,
     ActionsManager,
 } from './managers'
@@ -47,8 +46,6 @@ export type {EntityRefInput} from './managers/actions'
 export {getItem, getItems, itemIds} from './market/items'
 export {getCurrentEpoch, getEpochInfo} from './scheduling/epoch'
 export type {EpochInfo} from './scheduling/epoch'
-export {marketPrice, marketPrices, getRarity, getRarityMultiplier, Rarities} from './market/market'
-export type {Rarity} from './market/market'
 export {
     getSystemName,
     hasSystem,
@@ -91,31 +88,6 @@ export type {StatDefinition, NamedStats} from './derivation'
 
 export {hash, hash512} from './utils/hash'
 
-export type {Deal, FindDealsOptions} from './trading/deal'
-export {findDealsForShip, findBestDeal} from './trading/deal'
-
-export type {
-    CollectActionType,
-    CollectOption,
-    CollectAnalysis,
-    CollectAnalysisOptions,
-    CollectAnalysisCallbacks,
-    BetterSaleLocation,
-    RepositionLocation,
-    DiscountedItemInfo,
-    PotentialDeal,
-    CargoSaleItem,
-} from './trading/collect'
-export {
-    analyzeCollectOptions,
-    analyzeCargoSale,
-    createSellAndTradeOption,
-    createTravelToSellOption,
-    createSellAndRepositionOption,
-    createSellAndStayOption,
-    createExploreOption,
-} from './trading/collect'
-
 export {
     distanceBetweenCoordinates,
     distanceBetweenPoints,
@@ -153,19 +125,6 @@ export type {
     HasScheduleAndLocation,
 } from './travel/travel'
 
-export {
-    calculateUpdatedCargoCost,
-    calculateMaxTradeQuantity,
-    calculateTradeProfit,
-    calculateProfitPerMass,
-    calculateProfitPerSecond,
-    findBestItemToTrade,
-    calculateBreakEvenPrice,
-    isProfitable,
-    calculateROI,
-} from './trading/trade'
-export type {TradeCalculation, TradeProfitResult} from './trading/trade'
-
 export * as schedule from './scheduling/schedule'
 export type {Scheduleable, ScheduleData} from './scheduling/schedule'
 export {ScheduleAccessor, createScheduleAccessor} from './scheduling/accessor'
@@ -181,3 +140,69 @@ export type {Projectable, ProjectedEntity} from './scheduling/projection'
 export * from './types/capabilities'
 export * from './types/entity'
 export * from './capabilities'
+
+export {categoryColors, tierColors, categoryIcons, componentIcon, moduleIcon} from './data/colors'
+
+export {
+   components,
+   entityRecipes,
+   moduleRecipes,
+   getComponentById,
+   getEntityRecipe,
+   getEntityRecipeByItemId,
+   getModuleRecipe,
+   getModuleRecipeByItemId,
+   getAllCraftableItems,
+   getComponentsForCategory,
+   getComponentsForStat,
+   ITEM_HULL_PLATES,
+   ITEM_CARGO_LINING,
+   ITEM_CONTAINER_PACKED,
+   ITEM_THRUSTER_CORE,
+   ITEM_POWER_CELL,
+   ITEM_ENGINE_T1,
+   ITEM_GENERATOR_T1,
+   ITEM_SHIP_T1_PACKED,
+   ITEM_DRILL_SHAFT,
+   ITEM_EXTRACTION_PROBE,
+   ITEM_CARGO_ARM,
+   ITEM_TOOL_BIT,
+   ITEM_REACTION_CHAMBER,
+   ITEM_EXTRACTOR_T1,
+   ITEM_LOADER_T1,
+   ITEM_MANUFACTURING_T1,
+} from './data/recipes'
+export type {
+   ComponentDefinition,
+   ComponentStat,
+   RecipeInput,
+   EntityRecipe,
+   ModuleRecipe,
+   CraftableItem,
+} from './data/recipes'
+
+export {
+   encodeStats,
+   decodeStats,
+   decodeCraftedItemStats,
+   blendStacks,
+   computeComponentStats,
+   blendComponentStacks,
+   computeEntityStats,
+   blendCargoStacks,
+} from './derivation/crafting'
+export type {StackInput, CategoryStacks} from './derivation/crafting'
+
+export {computeContainerCapabilities} from './entities/container'
+
+export {
+    computeShipHullCapabilities,
+    computeEngineCapabilities,
+    computeGeneratorCapabilities,
+    computeExtractorCapabilities,
+    computeLoaderCapabilities,
+    computeManufacturingCapabilities,
+} from './entities/ship-deploy'
+
+export {resolveItem} from './resolution/resolve-item'
+export type {ResolvedItem, ResolvedItemStat, ResolvedAttributeGroup, ResolvedItemType} from './resolution/resolve-item'