@shipload/sdk 2.0.0-rc1 → 2.0.0-rc11

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[]
@@ -11,17 +12,11 @@ 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 getCargoForGood(
+export function getCargoForItem(
     cargo: EntityInventory[],
     goodId: UInt64Type
 ): EntityInventory | undefined {
-    return cargo.find((c) => c.good_id.equals(goodId))
+    return cargo.find((c) => c.item_id.equals(goodId))
 }
 
 export function hasSpace(
@@ -45,3 +40,45 @@ export function availableCapacity(currentMass: UInt64, maxCapacity: UInt64): UIn
 export function isFull(currentMass: UInt64, maxCapacity: UInt64): boolean {
     return currentMass.gte(maxCapacity)
 }
+
+export function afterRemoveItems(
+    cargo: ServerContract.Types.cargo_item[],
+    goodsToRemove: Array<{goodId: number; quantity: number}>
+): EntityInventory[] {
+    if (cargo.length === 0) {
+        return []
+    }
+
+    return cargo.map((item) => {
+        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 - removeItem.quantity)
+
+        return new EntityInventory(
+            ServerContract.Types.cargo_item.from({
+                item_id: item.item_id,
+                quantity: UInt32.from(newQty),
+            })
+        )
+    })
+}
+
+export function afterRemoveAllItems(cargo: ServerContract.Types.cargo_item[]): EntityInventory[] {
+    if (cargo.length === 0) {
+        return []
+    }
+
+    return cargo.map(
+        (item) =>
+            new EntityInventory(
+                ServerContract.Types.cargo_item.from({
+                    item_id: item.item_id,
+                    quantity: UInt32.from(0),
+                })
+            )
+    )
+}

package/src/entities/container.ts

@@ -0,0 +1,106 @@
+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
+    }
+}
+
+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}
+}
+
+export function computeContainerT2Capabilities(stats: Record<string, number>): {
+    hullmass: number
+    capacity: number
+} {
+    const strength = stats['strength'] ?? 0
+    const density = stats['density'] ?? 0
+    const ductility = stats['ductility'] ?? 0
+    const purity = stats['purity'] ?? 0
+
+    const hullmass = 20000 + 50 * density
+
+    const statSum = strength + ductility + purity
+    const exponent = statSum / 2500
+    const capacity = Math.floor(1500000 * Math.pow(10, exponent))
+
+    return {hullmass, capacity}
+}

package/src/entities/entity-inventory.ts

@@ -1,34 +1,34 @@
 import {UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {getGood} from '../market/goods'
-import {Good} from '../types'
+import {getItem} from '../market/items'
+import {Item} from '../types'
 
 export class EntityInventory extends ServerContract.Types.cargo_item {
-    private _good?: Good
+    private _item?: Item
 
-    get good(): Good {
-        if (!this._good) {
-            this._good = getGood(this.good_id)
+    get item(): Item {
+        if (!this._item) {
+            this._item = getItem(this.item_id)
         }
-        return this._good
+        return this._item
+    }
+
+    get good(): Item {
+        return this.item
     }
 
     get name(): string {
-        return this.good.name
+        return this.item.name
     }
 
     get unitMass(): UInt32 {
-        return this.good.mass
+        return this.item.mass
     }
 
     get totalMass(): UInt64 {
         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

@@ -0,0 +1,42 @@
+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))
+    }
+
+    forItem(goodId: UInt64Type): EntityInventory | undefined {
+        return this.items.find((c) => c.item_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,35 +1,22 @@
-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 {Checksum256, Checksum256Type, UInt16Type, UInt64} from '@wharfkit/antelope'
+import {Coordinates, CoordinatesType, Distance, LocationType} from '../types'
+import {getLocationType, hasSystem, isGatherableLocation} 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?: GoodPrice[]
     private _gameSeed?: Checksum256
     private _hasSystem?: boolean
-    private _locationRows?: ServerContract.Types.location_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)
-     */
     hasSystemAt(gameSeed: Checksum256Type): boolean {
         const seed = Checksum256.from(gameSeed)
         if (this._hasSystem === undefined || !this._gameSeed?.equals(seed)) {
@@ -39,200 +26,32 @@ export class Location {
         return this._hasSystem
     }
 
-    /**
-     * Set cached market prices for this location
-     */
-    setMarketPrices(prices: GoodPrice[]): void {
-        this._marketPrices = prices
+    getLocationTypeAt(gameSeed: Checksum256Type): LocationType {
+        return getLocationType(gameSeed, this.coordinates)
     }
 
-    /**
-     * Get cached market prices (returns undefined if not cached)
-     */
-    get marketPrices(): GoodPrice[] | undefined {
-        return this._marketPrices
+    isGatherableAt(gameSeed: Checksum256Type): boolean {
+        return isGatherableLocation(this.getLocationTypeAt(gameSeed))
     }
 
-    /**
-     * Get price for a specific good (from cache)
-     */
-    getPrice(goodId: UInt16Type): GoodPrice | 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.location_row[], epoch: UInt64): void {
-        this._locationRows = rows
-        this._epoch = epoch
-    }
-
-    /**
-     * Get cached location rows (supply data)
-     */
-    get locationRows(): ServerContract.Types.location_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.good_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.location_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 GoodPrice.from({
-                        id: price.id,
-                        good: price.good,
-                        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.good_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.location_row.from({
-                        id: row.id,
-                        coordinates: row.coordinates,
-                        epoch: row.epoch,
-                        good_id: row.good_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

@@ -0,0 +1,72 @@
+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 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),
+        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: [],
+    }
+    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)
+}
+
+export function makeWarehouse(state: WarehouseStateInput): Warehouse {
+    const info: Record<string, unknown> = {
+        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 || [],
+        is_idle: !state.schedule,
+        current_task_elapsed: UInt32.from(0),
+        current_task_remaining: UInt32.from(0),
+        pending_tasks: [],
+    }
+    if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
+    if (state.loaders) info.loaders = state.loaders
+    if (state.schedule) info.schedule = state.schedule
+    const entityInfo = ServerContract.Types.entity_info.from(info)
+    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)
+}