@shipload/sdk 2.0.0-rc1 → 2.0.0-rc2

package/src/data/goods.json

@@ -7,14 +7,14 @@
         "mass": 15000
     },
     {
-        "id": 2,
+        "id": 26,
         "name": "Iron",
         "description": "A versatile metal used in construction and manufacturing.",
         "base_price": 125,
         "mass": 40000
     },
     {
-        "id": 3,
+        "id": 29,
         "name": "Copper",
         "description": "A conductive metal vital for electronics and wiring.",
         "base_price": 200,

package/src/entities/cargo-utils.ts

@@ -1,5 +1,6 @@
-import {UInt64, UInt64Type} from '@wharfkit/antelope'
+import {UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {EntityInventory} from './entity-inventory'
+import {ServerContract} from '../contracts'
 
 export interface CargoData {
     cargo: EntityInventory[]
@@ -45,3 +46,97 @@ export function availableCapacity(currentMass: UInt64, maxCapacity: UInt64): UIn
 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.good_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 afterSellGoods(
+    cargo: ServerContract.Types.cargo_item[],
+    goodsToSell: Array<{goodId: number; quantity: number}>
+): EntityInventory[] {
+    if (cargo.length === 0) {
+        return []
+    }
+
+    return cargo.map((item) => {
+        const saleItem = goodsToSell.find((s) => Number(item.good_id) === s.goodId)
+        if (!saleItem) {
+            return new EntityInventory(item)
+        }
+
+        const currentQty = Number(item.quantity)
+        const newQty = Math.max(0, currentQty - saleItem.quantity)
+
+        return new EntityInventory(
+            ServerContract.Types.cargo_item.from({
+                good_id: item.good_id,
+                quantity: UInt32.from(newQty),
+                unit_cost: item.unit_cost,
+            })
+        )
+    })
+}
+
+export function afterSellAllGoods(cargo: ServerContract.Types.cargo_item[]): EntityInventory[] {
+    if (cargo.length === 0) {
+        return []
+    }
+
+    return cargo.map(
+        (item) =>
+            new EntityInventory(
+                ServerContract.Types.cargo_item.from({
+                    good_id: item.good_id,
+                    quantity: UInt32.from(0),
+                    unit_cost: item.unit_cost,
+                })
+            )
+    )
+}

package/src/entities/container.ts

@@ -0,0 +1,70 @@
+import {UInt64, UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {CoordinatesType} from '../types'
+import {Location} from './location'
+import {ScheduleAccessor} from '../scheduling/accessor'
+import * as schedule from '../scheduling/schedule'
+
+export interface ContainerStateInput {
+    id: UInt64Type
+    owner: string
+    name: string
+    coordinates: CoordinatesType | {x: number; y: number; z?: number}
+    hullmass: number
+    capacity: number
+    cargomass?: number
+    schedule?: ServerContract.Types.schedule
+}
+
+export class Container extends ServerContract.Types.entity_info {
+    private _sched?: ScheduleAccessor
+
+    get name(): string {
+        return this.entity_name
+    }
+
+    get sched(): ScheduleAccessor {
+        return (this._sched ??= new ScheduleAccessor(this))
+    }
+
+    get isIdle(): boolean {
+        return this.is_idle
+    }
+
+    isLoading(now: Date): boolean {
+        return schedule.isLoading(this, now)
+    }
+
+    isUnloading(now: Date): boolean {
+        return schedule.isUnloading(this, now)
+    }
+
+    get location(): Location {
+        return Location.from(this.coordinates)
+    }
+
+    get totalMass(): UInt64 {
+        return UInt64.from(this.hullmass ?? 0).adding(this.cargomass)
+    }
+
+    get maxCapacity(): UInt64 {
+        return UInt64.from(this.capacity)
+    }
+
+    get availableCapacity(): UInt64 {
+        const cargo = UInt64.from(this.cargomass)
+        return cargo.gte(this.maxCapacity) ? UInt64.from(0) : this.maxCapacity.subtracting(cargo)
+    }
+
+    hasSpace(additionalMass: UInt64): boolean {
+        return UInt64.from(this.cargomass).adding(additionalMass).lte(this.maxCapacity)
+    }
+
+    get isFull(): boolean {
+        return UInt64.from(this.cargomass).gte(this.maxCapacity)
+    }
+
+    get orbitalAltitude(): number {
+        return this.coordinates.z?.toNumber() || 0
+    }
+}

package/src/entities/inventory-accessor.ts

@@ -0,0 +1,46 @@
+import {UInt64, UInt64Type} from '@wharfkit/antelope'
+import {EntityInventory} from './entity-inventory'
+import {HasCargo} from '../capabilities/storage'
+
+export type {HasCargo}
+
+export class InventoryAccessor {
+    private _items?: EntityInventory[]
+
+    constructor(private readonly entity: HasCargo) {}
+
+    get items(): EntityInventory[] {
+        if (!this._items) {
+            this._items = this.entity.cargo.map((item) => new EntityInventory(item))
+        }
+        return this._items
+    }
+
+    get totalMass(): UInt64 {
+        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))
+    }
+
+    forGood(goodId: UInt64Type): EntityInventory | undefined {
+        return this.items.find((c) => c.good_id.equals(goodId))
+    }
+
+    get sellable(): EntityInventory[] {
+        return this.items.filter((c) => c.hasCargo)
+    }
+
+    get hasSellable(): boolean {
+        return this.items.some((c) => c.hasCargo)
+    }
+
+    get sellableCount(): number {
+        return this.items.filter((c) => c.hasCargo).length
+    }
+}
+
+export function createInventoryAccessor(entity: HasCargo): InventoryAccessor {
+    return new InventoryAccessor(entity)
+}

package/src/entities/location.ts

@@ -1,7 +1,7 @@
 import {Checksum256, Checksum256Type, UInt16, UInt16Type, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {Coordinates, CoordinatesType, Distance, GoodPrice} from '../types'
-import {hasSystem} from '../utils/system'
+import {Coordinates, CoordinatesType, Distance, GoodPrice, LocationType} from '../types'
+import {getLocationType, hasSystem, isExtractableLocation} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 
 /**
@@ -13,7 +13,7 @@ export class Location {
     private _marketPrices?: GoodPrice[]
     private _gameSeed?: Checksum256
     private _hasSystem?: boolean
-    private _locationRows?: ServerContract.Types.location_row[]
+    private _locationRows?: ServerContract.Types.supply_row[]
     private _epoch?: UInt64
 
     constructor(coordinates: CoordinatesType) {
@@ -28,7 +28,7 @@ export class Location {
     }
 
     /**
-     * Check if this location has a system (planet)
+     * Check if this location has a system (planet, asteroid, or nebula)
      */
     hasSystemAt(gameSeed: Checksum256Type): boolean {
         const seed = Checksum256.from(gameSeed)
@@ -39,6 +39,20 @@ 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
      */
@@ -79,7 +93,7 @@ export class Location {
     /**
      * Set location rows (supply data) for this location
      */
-    setLocationRows(rows: ServerContract.Types.location_row[], epoch: UInt64): void {
+    setLocationRows(rows: ServerContract.Types.supply_row[], epoch: UInt64): void {
         this._locationRows = rows
         this._epoch = epoch
     }
@@ -87,7 +101,7 @@ export class Location {
     /**
      * Get cached location rows (supply data)
      */
-    get locationRows(): ServerContract.Types.location_row[] | undefined {
+    get locationRows(): ServerContract.Types.supply_row[] | undefined {
         return this._locationRows
     }
 
@@ -107,7 +121,7 @@ export class Location {
      * Get all available goods at this location (goods with supply > 0)
      * Returns undefined if location rows not cached
      */
-    get availableGoods(): ServerContract.Types.location_row[] | undefined {
+    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))
@@ -209,7 +223,7 @@ export class Location {
                                 : UInt16.from(0)
                             : currentSupply.adding(quantityDelta)
 
-                    return ServerContract.Types.location_row.from({
+                    return ServerContract.Types.supply_row.from({
                         id: row.id,
                         coordinates: row.coordinates,
                         epoch: row.epoch,

package/src/entities/makers.ts

@@ -0,0 +1,69 @@
+import {Name, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {Ship, ShipStateInput} from './ship'
+import {Warehouse, WarehouseStateInput} from './warehouse'
+import {Container, ContainerStateInput} from './container'
+
+export function makeShip(state: ShipStateInput): Ship {
+    const entityInfo = ServerContract.Types.entity_info.from({
+        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,
+    })
+    return new Ship(entityInfo)
+}
+
+export function makeWarehouse(state: WarehouseStateInput): Warehouse {
+    const entityInfo = ServerContract.Types.entity_info.from({
+        type: Name.from('warehouse'),
+        id: UInt64.from(state.id),
+        owner: Name.from(state.owner),
+        entity_name: state.name,
+        coordinates: ServerContract.Types.coordinates.from(state.coordinates),
+        capacity: UInt32.from(state.capacity),
+        cargomass: UInt32.from(0),
+        cargo: state.cargo || [],
+        loaders: state.loaders,
+        is_idle: !state.schedule,
+        current_task_elapsed: UInt32.from(0),
+        current_task_remaining: UInt32.from(0),
+        pending_tasks: [],
+        schedule: state.schedule,
+    })
+    return new Warehouse(entityInfo)
+}
+
+export function makeContainer(state: ContainerStateInput): Container {
+    const entityInfo = ServerContract.Types.entity_info.from({
+        type: Name.from('container'),
+        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),
+        cargomass: UInt32.from(state.cargomass || 0),
+        cargo: [],
+        is_idle: !state.schedule,
+        current_task_elapsed: UInt32.from(0),
+        current_task_remaining: UInt32.from(0),
+        pending_tasks: [],
+        schedule: state.schedule,
+    })
+    return new Container(entityInfo)
+}

package/src/entities/player.ts

@@ -37,7 +37,8 @@ export class Player extends ServerContract.Types.player_row {
     }
     // Constants for game rules (match smart contract)
     private static readonly MAX_LOAN = 1000000
-    private static readonly BASE_SHIP_COST = 100 // pow(5, sequence) * 100
+    // 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