@shipload/sdk 0.7.1 → 2.0.0-rc10

package/src/entities/cargo-utils.ts

@@ -0,0 +1,84 @@
+import {UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {EntityInventory} from './entity-inventory'
+import {ServerContract} from '../contracts'
+
+export interface CargoData {
+    cargo: EntityInventory[]
+}
+
+export function totalCargoMass(cargo: EntityInventory[]): UInt64 {
+    return cargo.reduce((sum, c) => {
+        return sum.adding(c.totalMass)
+    }, UInt64.from(0))
+}
+
+export function getCargoForItem(
+    cargo: EntityInventory[],
+    goodId: UInt64Type
+): EntityInventory | undefined {
+    return cargo.find((c) => c.item_id.equals(goodId))
+}
+
+export function hasSpace(
+    currentMass: UInt64,
+    maxCapacity: UInt64,
+    goodMass: UInt64,
+    quantity: number
+): boolean {
+    const additionalMass = goodMass.multiplying(quantity)
+    const totalMass = currentMass.adding(additionalMass)
+    return totalMass.lte(maxCapacity)
+}
+
+export function availableCapacity(currentMass: UInt64, maxCapacity: UInt64): UInt64 {
+    if (currentMass.gte(maxCapacity)) {
+        return UInt64.from(0)
+    }
+    return maxCapacity.subtracting(currentMass)
+}
+
+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

@@ -0,0 +1,39 @@
+import {UInt32, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {getItem} from '../market/items'
+import {Item} from '../types'
+
+export class EntityInventory extends ServerContract.Types.cargo_item {
+    private _item?: Item
+
+    get item(): Item {
+        if (!this._item) {
+            this._item = getItem(this.item_id)
+        }
+        return this._item
+    }
+
+    get good(): Item {
+        return this.item
+    }
+
+    get name(): string {
+        return this.item.name
+    }
+
+    get unitMass(): UInt32 {
+        return this.item.mass
+    }
+
+    get totalMass(): UInt64 {
+        return UInt64.from(this.unitMass).multiplying(this.quantity)
+    }
+
+    get hasCargo(): boolean {
+        return UInt32.from(this.quantity).gt(UInt32.from(0))
+    }
+
+    get isEmpty(): boolean {
+        return UInt32.from(this.quantity).equals(UInt32.from(0))
+    }
+}

package/src/entities/gamestate.ts

@@ -0,0 +1,152 @@
+import {Checksum256, Int64, UInt64} from '@wharfkit/antelope'
+import {PlatformContract, ServerContract} from '../contracts'
+import {EpochInfo, getCurrentEpoch, getEpochInfo} from '../scheduling/epoch'
+import {hasSystem} from '../utils/system'
+
+/**
+ * GameState class extends the state_row from the server contract
+ * with helper methods for epoch management and system generation
+ */
+export class GameState extends ServerContract.Types.state_row {
+    private _game?: PlatformContract.Types.game_row
+
+    /**
+     * Create a GameState instance from a state_row
+     */
+    static from(
+        state: ServerContract.Types.state_row,
+        game?: PlatformContract.Types.game_row
+    ): GameState {
+        const gameState = Object.create(GameState.prototype) as GameState
+        Object.assign(gameState, state)
+        gameState._game = game
+        return gameState
+    }
+
+    /**
+     * Set the game configuration (needed for epoch calculations)
+     */
+    setGame(game: PlatformContract.Types.game_row): void {
+        this._game = game
+    }
+
+    /**
+     * Get the current epoch number from the state
+     */
+    get currentEpoch(): UInt64 {
+        return this.epoch
+    }
+
+    /**
+     * Get the epoch seed (used for market pricing and system generation)
+     */
+    get epochSeed(): Checksum256 {
+        return this.seed
+    }
+
+    /**
+     * Get the game seed (from game config, if available)
+     */
+    get gameSeed(): Checksum256 | undefined {
+        return this._game?.config.seed
+    }
+
+    /**
+     * Check if the game is currently enabled
+     */
+    get isEnabled(): boolean {
+        return this.enabled
+    }
+
+    /**
+     * Get the total number of ships in the game
+     */
+    get shipCount(): number {
+        return Number(this.ships)
+    }
+
+    /**
+     * Get the current salt value (used for random number generation)
+     */
+    get currentSalt(): UInt64 {
+        return this.salt
+    }
+
+    /**
+     * Get the commit hash for the next epoch
+     */
+    get nextEpochCommit(): Checksum256 {
+        return this.commit
+    }
+
+    /**
+     * Calculate the current epoch from game config (if game is set)
+     * This might differ from state.epoch if the blockchain hasn't advanced yet
+     */
+    get calculatedCurrentEpoch(): UInt64 | undefined {
+        if (!this._game) {
+            return undefined
+        }
+        return getCurrentEpoch(this._game)
+    }
+
+    /**
+     * Get epoch info (start/end times) for the current epoch
+     */
+    get currentEpochInfo(): EpochInfo | undefined {
+        if (!this._game) {
+            return undefined
+        }
+        return getEpochInfo(this._game, this.epoch)
+    }
+
+    /**
+     * Get epoch info for a specific epoch number
+     */
+    getEpochInfo(epoch: UInt64): EpochInfo | undefined {
+        if (!this._game) {
+            return undefined
+        }
+        return getEpochInfo(this._game, epoch)
+    }
+
+    /**
+     * Check if a system exists at given coordinates
+     * Requires game seed from game config
+     */
+    hasSystemAt(x: number, y: number): boolean {
+        if (!this._game) {
+            return false
+        }
+        return hasSystem(this._game.config.seed, {x: Int64.from(x), y: Int64.from(y)})
+    }
+
+    /**
+     * Check if a system exists at coordinates object
+     */
+    hasSystemAtCoords(coords: ServerContract.Types.coordinates): boolean {
+        if (!this._game) {
+            return false
+        }
+        return hasSystem(this._game.config.seed, coords)
+    }
+
+    /**
+     * Get a summary of the game state
+     */
+    get summary(): {
+        enabled: boolean
+        epoch: string
+        ships: number
+        hasSeed: boolean
+        hasCommit: boolean
+    } {
+        return {
+            enabled: this.enabled,
+            epoch: this.epoch.toString(),
+            ships: this.shipCount,
+            hasSeed: !this.seed.equals(Checksum256.from('0'.repeat(64))),
+            hasCommit: !this.commit.equals(Checksum256.from('0'.repeat(64))),
+        }
+    }
+}

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

@@ -0,0 +1,60 @@
+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'
+
+export class Location {
+    readonly coordinates: Coordinates
+    private _gameSeed?: Checksum256
+    private _hasSystem?: boolean
+    private _epoch?: UInt64
+
+    constructor(coordinates: CoordinatesType) {
+        this.coordinates = Coordinates.from(coordinates)
+    }
+
+    static from(coordinates: CoordinatesType): Location {
+        return new Location(Coordinates.from(coordinates))
+    }
+
+    hasSystemAt(gameSeed: Checksum256Type): boolean {
+        const seed = Checksum256.from(gameSeed)
+        if (this._hasSystem === undefined || !this._gameSeed?.equals(seed)) {
+            this._gameSeed = seed
+            this._hasSystem = hasSystem(seed, this.coordinates)
+        }
+        return this._hasSystem
+    }
+
+    getLocationTypeAt(gameSeed: Checksum256Type): LocationType {
+        return getLocationType(gameSeed, this.coordinates)
+    }
+
+    isExtractableAt(gameSeed: Checksum256Type): boolean {
+        return isExtractableLocation(this.getLocationTypeAt(gameSeed))
+    }
+
+    findNearby(gameSeed: Checksum256Type, maxDistance: UInt16Type = 20): Distance[] {
+        return findNearbyPlanets(Checksum256.from(gameSeed), this.coordinates, maxDistance)
+    }
+
+    equals(other: CoordinatesType | Location): boolean {
+        const otherCoords = other instanceof Location ? other.coordinates : Coordinates.from(other)
+        return this.coordinates.equals(otherCoords)
+    }
+
+    get epoch(): UInt64 | undefined {
+        return this._epoch
+    }
+
+    clearCache(): void {
+        this._epoch = undefined
+    }
+}
+
+export function toLocation(coords: CoordinatesType | Location): Location {
+    if (coords instanceof Location) {
+        return coords
+    }
+    return Location.from(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)
+}

package/src/entities/player.ts

@@ -0,0 +1,15 @@
+import {Name, NameType} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+
+export interface PlayerStateInput {
+    owner: NameType
+}
+
+export class Player extends ServerContract.Types.player_row {
+    static fromState(state: PlayerStateInput): Player {
+        const playerRow = ServerContract.Types.player_row.from({
+            owner: Name.from(state.owner),
+        })
+        return new Player(playerRow)
+    }
+}