@shipload/sdk 2.0.0-rc1 → 2.0.0-rc11

package/src/entities/player.ts

@@ -1,287 +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
-    private static readonly BASE_SHIP_COST = 100 // pow(5, sequence) * 100
-    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,263 @@
+import {decodeCraftedItemStats} from '../derivation/crafting'
+import {
+    getModuleCapabilityType,
+    MODULE_CRAFTER,
+    MODULE_ENGINE,
+    MODULE_GATHERER,
+    MODULE_GENERATOR,
+    MODULE_HAULER,
+    MODULE_LOADER,
+} from '../capabilities/modules'
+
+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(30, 50 - 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 computeGathererCapabilities(stats: Record<string, number>): {
+    yield: number
+    drain: number
+    depth: number
+    speed: number
+} {
+    const str = stats.strength ?? 500
+    const con = stats.conductivity ?? 500
+    const ref = stats.reflectivity ?? 500
+    const tol = stats.tolerance ?? 500
+
+    return {
+        yield: 200 + str,
+        drain: Math.max(10, 50 - Math.floor(con / 20)),
+        depth: 200 + Math.floor((tol * 3) / 2),
+        speed: 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)),
+    }
+}
+
+export function computeHaulerCapabilities(stats: Record<string, number>): {
+    capacity: number
+    efficiency: number
+    drain: number
+} {
+    const res = stats.resonance ?? 500
+    const con = stats.conductivity ?? 500
+    const clr = stats.clarity ?? 500
+
+    return {
+        capacity: Math.max(1, 1 + Math.floor(res / 400)),
+        efficiency: 2000 + con * 6,
+        drain: Math.max(3, 15 - Math.floor(clr / 80)),
+    }
+}
+
+export function computeStorageCapabilities(
+    stats: Record<string, number>,
+    baseCapacity: number
+): {
+    capacityBonus: number
+} {
+    const strength = stats.strength ?? 500
+    const ductility = stats.ductility ?? 500
+    const purity = stats.purity ?? 500
+
+    const statSum = strength + ductility + purity
+    const capacityBonus = Math.floor(
+        (baseCapacity * (10 + Math.floor((statSum * 10) / 2997))) / 100
+    )
+
+    return {capacityBonus}
+}
+
+export function computeWarehouseHullCapabilities(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(20000000 * Math.pow(10, exponent))
+
+    return {hullmass, capacity}
+}
+
+export interface ShipCapabilities {
+    engines?: {thrust: number; drain: number}
+    generator?: {capacity: number; recharge: number}
+    gatherer?: {yield: number; drain: number; depth: number; speed: number}
+    hauler?: {capacity: number; efficiency: number; drain: number}
+    loaders?: {mass: number; thrust: number; quantity: number}
+    crafter?: {speed: number; drain: number}
+}
+
+export function computeShipCapabilities(
+    modules: {itemId: number; seed: bigint}[]
+): ShipCapabilities {
+    const ship: ShipCapabilities = {}
+
+    const engineModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_ENGINE)
+    if (engineModules.length > 0) {
+        let totalThrust = 0
+        let totalDrain = 0
+        for (const m of engineModules) {
+            const caps = computeEngineCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            totalThrust += caps.thrust
+            totalDrain += caps.drain
+        }
+        ship.engines = {thrust: totalThrust, drain: totalDrain}
+    }
+
+    const generatorModules = modules.filter(
+        (m) => getModuleCapabilityType(m.itemId) === MODULE_GENERATOR
+    )
+    if (generatorModules.length > 0) {
+        let totalCapacity = 0
+        let totalRecharge = 0
+        for (const m of generatorModules) {
+            const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            totalCapacity += caps.capacity
+            totalRecharge += caps.recharge
+        }
+        ship.generator = {capacity: totalCapacity, recharge: totalRecharge}
+    }
+
+    const gathererModules = modules.filter(
+        (m) => getModuleCapabilityType(m.itemId) === MODULE_GATHERER
+    )
+    if (gathererModules.length > 0) {
+        let totalYield = 0
+        let totalDrain = 0
+        let totalDepth = 0
+        let totalSpeed = 0
+        for (const m of gathererModules) {
+            const caps = computeGathererCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            totalYield += caps.yield
+            totalDrain += caps.drain
+            totalDepth += caps.depth
+            totalSpeed += caps.speed
+        }
+        ship.gatherer = {yield: totalYield, drain: totalDrain, depth: totalDepth, speed: totalSpeed}
+    }
+
+    const haulerModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_HAULER)
+    if (haulerModules.length > 0) {
+        let totalCapacity = 0
+        let weightedEffNum = 0
+        let totalDrain = 0
+        for (const m of haulerModules) {
+            const decoded = decodeCraftedItemStats(m.itemId, m.seed)
+            const caps = computeHaulerCapabilities({
+                resonance: decoded.capacity,
+                conductivity: decoded.efficiency,
+                clarity: decoded.drain,
+            })
+            totalCapacity += caps.capacity
+            weightedEffNum += caps.efficiency * caps.capacity
+            totalDrain += caps.drain
+        }
+        ship.hauler = {
+            capacity: totalCapacity,
+            efficiency: totalCapacity > 0 ? Math.floor(weightedEffNum / totalCapacity) : 0,
+            drain: totalDrain,
+        }
+    }
+
+    const loaderModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_LOADER)
+    if (loaderModules.length > 0) {
+        let totalMass = 0
+        let totalThrust = 0
+        let totalQuantity = 0
+        for (const m of loaderModules) {
+            const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            totalMass += caps.mass
+            totalThrust += caps.thrust
+            totalQuantity += caps.quantity
+        }
+        ship.loaders = {mass: totalMass, thrust: totalThrust, quantity: totalQuantity}
+    }
+
+    const crafterModules = modules.filter(
+        (m) => getModuleCapabilityType(m.itemId) === MODULE_CRAFTER
+    )
+    if (crafterModules.length > 0) {
+        let totalSpeed = 0
+        let totalDrain = 0
+        for (const m of crafterModules) {
+            const caps = computeManufacturingCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            totalSpeed += caps.speed
+            totalDrain += caps.drain
+        }
+        ship.crafter = {speed: totalSpeed, drain: totalDrain}
+    }
+
+    return ship
+}