@shipload/sdk 1.0.0-next.7 → 1.0.0-next.71

package/src/entities/entity.ts

@@ -0,0 +1,102 @@
+import {UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {
+    CAP_DEMOLISH,
+    CAP_MODULES,
+    CAP_UNDEPLOY,
+    CAP_WRAP,
+    type EntityClass,
+    getEntityClass,
+    kindCan,
+} from '../data/kind-registry'
+import {InventoryAccessor} from './inventory-accessor'
+import {Location} from './location'
+import {ScheduleAccessor} from '../scheduling/accessor'
+import * as schedule from '../scheduling/schedule'
+import type {EntityInventory} from './entity-inventory'
+
+export class Entity extends ServerContract.Types.entity_info {
+    private _sched?: ScheduleAccessor
+    private _inv?: InventoryAccessor
+
+    get name(): string {
+        return this.entity_name
+    }
+
+    get location(): Location {
+        return Location.from(this.coordinates)
+    }
+
+    get isIdle(): boolean {
+        return schedule.isIdle(this)
+    }
+
+    get hasPendingCapper(): boolean {
+        return schedule.hasPendingCapper(this)
+    }
+
+    get sched(): ScheduleAccessor {
+        this._sched ??= new ScheduleAccessor(this)
+        return this._sched
+    }
+
+    get inv(): InventoryAccessor {
+        this._inv ??= new InventoryAccessor(this)
+        return this._inv
+    }
+
+    get inventory(): EntityInventory[] {
+        return this.inv.items
+    }
+
+    get totalCargoMass(): UInt64 {
+        return this.inv.totalMass
+    }
+
+    get maxCapacity(): UInt64 {
+        return UInt64.from(this.capacity ?? 0)
+    }
+
+    get availableCapacity(): UInt64 {
+        const cargo = this.totalCargoMass
+        const max = this.maxCapacity
+        return cargo.gte(max) ? UInt64.from(0) : max.subtracting(cargo)
+    }
+
+    get isFull(): boolean {
+        return this.totalCargoMass.gte(this.maxCapacity)
+    }
+
+    get totalMass(): UInt64 {
+        const hull = this.hullmass ? UInt64.from(this.hullmass) : UInt64.from(0)
+        return hull.adding(this.totalCargoMass)
+    }
+
+    get entityClass(): EntityClass {
+        return getEntityClass(this.type)
+    }
+
+    get canWrap(): boolean {
+        return kindCan(this.type, CAP_WRAP)
+    }
+
+    get canUndeploy(): boolean {
+        return kindCan(this.type, CAP_UNDEPLOY)
+    }
+
+    get canDemolish(): boolean {
+        return kindCan(this.type, CAP_DEMOLISH)
+    }
+
+    get canUseModules(): boolean {
+        return kindCan(this.type, CAP_MODULES)
+    }
+
+    isLoading(now: Date): boolean {
+        return schedule.isLoading(this, now)
+    }
+
+    isUnloading(now: Date): boolean {
+        return schedule.isUnloading(this, now)
+    }
+}

package/src/entities/gamestate.ts

@@ -1,4 +1,4 @@
-import {Checksum256, Int64, type UInt64} from '@wharfkit/antelope'
+import {Checksum256, Int64, UInt64} from '@wharfkit/antelope'
 import {type PlatformContract, ServerContract} from '../contracts'
 import {type EpochInfo, getCurrentEpoch, getEpochInfo} from '../scheduling/epoch'
 import {hasSystem} from '../utils/system'
@@ -34,7 +34,7 @@ export class GameState extends ServerContract.Types.state_row {
      * Get the current epoch number from the state
      */
     get currentEpoch(): UInt64 {
-        return this.epoch
+        return UInt64.from(this.epoch.toString())
     }
 
     /**
@@ -58,27 +58,6 @@ export class GameState extends ServerContract.Types.state_row {
         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
@@ -97,7 +76,7 @@ export class GameState extends ServerContract.Types.state_row {
         if (!this._game) {
             return undefined
         }
-        return getEpochInfo(this._game, this.epoch)
+        return getEpochInfo(this._game, this.currentEpoch)
     }
 
     /**
@@ -137,16 +116,12 @@ export class GameState extends ServerContract.Types.state_row {
     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/makers.ts

@@ -1,42 +1,58 @@
-import {Name, UInt16, UInt32, UInt64, UInt8} from '@wharfkit/antelope'
+import {Name, TimePoint, UInt16, UInt32, UInt64, UInt8} from '@wharfkit/antelope'
+import type {NameType, UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {type PackedModuleInput, Ship, type ShipStateInput} from './ship'
-import {computeWarehouseCapabilities, Warehouse, type WarehouseStateInput} from './warehouse'
-import {Container, type ContainerStateInput} from './container'
-import {ITEM_SHIP_T1_PACKED, ITEM_WAREHOUSE_T1_PACKED} from '../data/item-ids'
+import {Entity} from './entity'
+import {getKindMeta, getTemplateMeta} from '../data/kind-registry'
+import type {EntityTypeName} from '../data/kind-registry'
 import {getEntityLayout} from '../data/recipes-runtime'
+import type {EntitySlot} from '../data/recipes-runtime'
 import {itemMetadata} from '../data/metadata'
 import {getItem} from '../data/catalog'
-import {
-    getModuleCapabilityType,
-    MODULE_STORAGE,
-    moduleAccepts,
-    moduleSlotTypeToCode,
-} from '../capabilities/modules'
-import {computeShipCapabilities, computeStorageCapabilities} from './ship-deploy'
-import {decodeCraftedItemStats} from '../derivation/crafting'
+import {getModuleCapabilityType, moduleAccepts, moduleSlotTypeToCode} from '../capabilities/modules'
+import {computeEntityCapabilities} from '../derivation/capabilities'
+import {packedModulesToInstalled} from './slot-multiplier'
+import {LANE_MOBILITY} from '../scheduling/schedule'
+
+export interface PackedModuleInput {
+    itemId: number
+    stats: bigint
+}
+
+export interface EntityStateInput {
+    id: UInt64Type
+    owner: NameType
+    name: string
+    coordinates: {x: number; y: number; z?: number}
+    itemId?: number
+    hullmass?: number
+    capacity?: number
+    cargomass?: number
+    energy?: number
+    modules?: PackedModuleInput[]
+    schedule?: ServerContract.Types.schedule
+    lanes?: ServerContract.Types.lane[]
+    cargo?: ServerContract.Types.cargo_item[]
+    projectedAt?: Date
+}
 
 function assignModulesToSlots(
-    packedEntityItemId: number,
+    slots: EntitySlot[],
     modules: PackedModuleInput[],
     entityLabel: string
 ): ServerContract.Types.module_entry[] {
-    const layout = getEntityLayout(packedEntityItemId)
-    const slots = layout?.slots ?? []
     const result: Array<{type: number; installed?: ServerContract.Types.packed_module}> = slots.map(
         (s) => ({type: moduleSlotTypeToCode(s.type), installed: undefined})
     )
 
     for (const mod of modules) {
-        const itemId = Number(UInt16.from(mod.itemId).value.toString())
-        const modType = getModuleCapabilityType(itemId)
+        const modType = getModuleCapabilityType(mod.itemId)
         const slotIdx = result.findIndex((r) => !r.installed && moduleAccepts(r.type, modType))
         if (slotIdx === -1) {
             let modName: string
             try {
-                modName = getItem(itemId).name
+                modName = getItem(mod.itemId).name
             } catch {
-                modName = itemMetadata[itemId]?.name ?? `item ${itemId}`
+                modName = itemMetadata[mod.itemId]?.name ?? `item ${mod.itemId}`
             }
             throw new Error(
                 `No compatible slot for module ${modName} (type ${modType}) on ${entityLabel}`
@@ -56,141 +72,133 @@ function assignModulesToSlots(
     )
 }
 
-function decodePackedInput(m: PackedModuleInput): {itemId: number; stats: bigint} {
-    return {
-        itemId: Number(UInt16.from(m.itemId).value.toString()),
-        stats: BigInt(UInt64.from(m.stats).toString()),
-    }
+const ZERO_HULL_STATS: Record<string, number> = {
+    density: 0,
+    strength: 0,
+    hardness: 0,
+    cohesion: 0,
 }
 
-function computeStorageBonus(
-    decoded: {itemId: number; stats: bigint}[],
-    baseCapacity: number
-): number {
-    let totalBonus = 0
-    for (const m of decoded) {
-        if (getModuleCapabilityType(m.itemId) !== MODULE_STORAGE) continue
-        const stats = decodeCraftedItemStats(m.itemId, m.stats)
-        const {capacityBonus} = computeStorageCapabilities(stats, baseCapacity)
-        totalBonus += capacityBonus
+export function makeEntity(packedItemId: number, state: EntityStateInput): Entity {
+    const template = getTemplateMeta(packedItemId)
+    if (!template) {
+        throw new Error(`Unknown packed entity item ID: ${packedItemId}`)
     }
-    return totalBonus
-}
 
-function deriveShipFromModules(
-    modules: PackedModuleInput[],
-    baseCapacity: number
-): {
-    capabilities: ReturnType<typeof computeShipCapabilities>
-    finalCapacity: number
-} {
-    const decoded = modules.map(decodePackedInput)
-    const capabilities = computeShipCapabilities(decoded)
-    const totalBonus = computeStorageBonus(decoded, baseCapacity)
-    return {capabilities, finalCapacity: baseCapacity + totalBonus}
-}
+    const kind = template.kind.toString() as EntityTypeName
+    const layout = getEntityLayout(packedItemId)?.slots ?? []
+    const mods = state.modules ?? []
+
+    const lanes =
+        state.lanes ??
+        (state.schedule
+            ? [
+                  ServerContract.Types.lane.from({
+                      lane_key: UInt8.from(LANE_MOBILITY),
+                      schedule: state.schedule,
+                  }),
+              ]
+            : [])
 
-export function makeShip(state: ShipStateInput): Ship {
     const info: Record<string, unknown> = {
-        type: Name.from('ship'),
+        type: template.kind,
         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),
+        item_id: UInt16.from(state.itemId ?? template.itemId),
+        cargomass: UInt32.from(state.cargomass ?? 0),
         cargo: state.cargo || [],
-        is_idle: !state.schedule,
-        current_task_elapsed: UInt32.from(0),
-        current_task_remaining: UInt32.from(0),
-        pending_tasks: [],
+        lanes,
+        holds: [],
+        projected_at: TimePoint.fromMilliseconds(state.projectedAt?.getTime() ?? 0),
     }
-    if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
-    if (state.energy !== undefined) info.energy = UInt16.from(state.energy)
-    if (state.schedule) info.schedule = state.schedule
-
-    let moduleEntries: ServerContract.Types.module_entry[] = []
-    if (state.modules && state.modules.length > 0) {
-        moduleEntries = assignModulesToSlots(ITEM_SHIP_T1_PACKED, state.modules, 'Ship T1')
-        const {capabilities, finalCapacity} = deriveShipFromModules(
-            state.modules,
-            state.capacity ?? 0
-        )
-        if (capabilities.engines) info.engines = capabilities.engines
-        if (capabilities.generator) info.generator = capabilities.generator
-        if (capabilities.gatherer) info.gatherer = capabilities.gatherer
-        if (capabilities.hauler) info.hauler = capabilities.hauler
-        if (capabilities.loaders) info.loaders = capabilities.loaders
-        if (capabilities.crafter) info.crafter = capabilities.crafter
-        if (state.capacity !== undefined) info.capacity = UInt32.from(finalCapacity)
-    } else {
-        moduleEntries = assignModulesToSlots(ITEM_SHIP_T1_PACKED, [], 'Ship T1')
+
+    if (state.energy !== undefined) info.energy = UInt32.from(state.energy)
+
+    if (kind === 'container') {
+        info.modules = []
+        if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
         if (state.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
-    }
+    } else {
+        const entityLabel = getKindMeta(template.kind)?.defaultLabel ?? kind
+        const moduleEntries = assignModulesToSlots(layout, mods, entityLabel)
+        info.modules = moduleEntries
 
-    info.modules = moduleEntries
+        const installed = packedModulesToInstalled(moduleEntries)
+        const caps = computeEntityCapabilities(ZERO_HULL_STATS, packedItemId, installed, layout)
 
-    const entityInfo = ServerContract.Types.entity_info.from(info)
-    return new Ship(entityInfo)
-}
+        if (state.hullmass !== undefined) {
+            info.hullmass = UInt32.from(state.hullmass)
+        } else if (installed.length > 0) {
+            info.hullmass = UInt32.from(caps.hullmass)
+        }
 
-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.schedule) info.schedule = state.schedule
-
-    let moduleEntries: ServerContract.Types.module_entry[] = []
-    if (state.modules && state.modules.length > 0) {
-        moduleEntries = assignModulesToSlots(
-            ITEM_WAREHOUSE_T1_PACKED,
-            state.modules,
-            'Warehouse T1'
-        )
-        const decoded = state.modules.map(decodePackedInput)
-        const capabilities = computeWarehouseCapabilities(decoded)
-        if (capabilities.loaders) info.loaders = capabilities.loaders
+        if (state.capacity !== undefined) {
+            info.capacity = UInt32.from(state.capacity)
+        } else {
+            info.capacity = UInt32.from(caps.capacity)
+        }
 
-        const totalBonus = computeStorageBonus(decoded, state.capacity)
-        info.capacity = UInt32.from(state.capacity + totalBonus)
-    } else {
-        moduleEntries = assignModulesToSlots(ITEM_WAREHOUSE_T1_PACKED, [], 'Warehouse T1')
+        if (caps.engines) info.engines = caps.engines
+        if (caps.generator) info.generator = caps.generator
+        if (caps.hauler) {
+            info.hauler = ServerContract.Types.hauler_stats.from({
+                capacity: caps.hauler.capacity,
+                efficiency: caps.hauler.efficiency,
+                drain: caps.hauler.drain,
+                capacity_by_tier: caps.hauler.capacityByTier,
+            })
+        }
+        if (caps.warp) info.warp = caps.warp
+        if (caps.launcher) {
+            info.launcher = ServerContract.Types.launcher_stats.from({
+                charge_rate: caps.launcher.chargeRate,
+                velocity: caps.launcher.velocity,
+                drain: caps.launcher.drain,
+            })
+        }
+
+        info.gatherer_lanes = (caps.gathererLanes ?? []).map((l) =>
+            ServerContract.Types.gatherer_lane.from({
+                slot_index: l.slotIndex,
+                yield: l.yield,
+                drain: l.drain,
+                depth: l.depth,
+                output_pct: l.outputPct,
+            })
+        )
+        info.crafter_lanes = (caps.crafterLanes ?? []).map((l) =>
+            ServerContract.Types.crafter_lane.from({
+                slot_index: l.slotIndex,
+                speed: l.speed,
+                drain: l.drain,
+                output_pct: l.outputPct,
+            })
+        )
+        info.builder_lanes = (caps.builderLanes ?? []).map((l) =>
+            ServerContract.Types.builder_lane.from({
+                slot_index: l.slotIndex,
+                speed: l.speed,
+                drain: l.drain,
+                output_pct: l.outputPct,
+            })
+        )
+        info.loader_lanes = (caps.loaderLanes ?? []).map((l) =>
+            ServerContract.Types.loader_lane.from({
+                slot_index: l.slotIndex,
+                mass: l.mass,
+                thrust: l.thrust,
+                output_pct: l.outputPct,
+            })
+        )
     }
 
-    info.modules = moduleEntries
+    if (!info.gatherer_lanes) info.gatherer_lanes = []
+    if (!info.crafter_lanes) info.crafter_lanes = []
+    if (!info.builder_lanes) info.builder_lanes = []
+    if (!info.loader_lanes) info.loader_lanes = []
 
     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: state.cargo || [],
-        modules: [],
-        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)
+    return new Entity(entityInfo)
 }

package/src/entities/slot-multiplier.ts

@@ -0,0 +1,43 @@
+import type {EntitySlot} from '../data/recipes-runtime'
+import type {ServerContract} from '../contracts'
+
+export const U16_MAX = 65535
+
+export interface InstalledModule {
+    slotIndex: number
+    itemId: number
+    stats: bigint
+}
+
+export function packedModulesToInstalled(
+    entries: ServerContract.Types.module_entry[]
+): InstalledModule[] {
+    const installed: InstalledModule[] = []
+    entries.forEach((entry, slotIndex) => {
+        if (!entry.installed) return
+        installed.push({
+            slotIndex,
+            itemId: Number(entry.installed.item_id.value),
+            stats: BigInt(entry.installed.stats.toString()),
+        })
+    })
+    return installed
+}
+
+export function clampUint16(value: number): number {
+    return Math.min(value, U16_MAX)
+}
+
+export const clampUint32 = (v: number): number => Math.min(Math.max(Math.floor(v), 0), 4294967295)
+
+export function applySlotMultiplier(value: number, outputPct: number): number {
+    return clampUint16(Math.floor((value * outputPct) / 100))
+}
+
+export function applySlotMultiplierUint32(value: number, outputPct: number): number {
+    return clampUint32(Math.floor((value * outputPct) / 100))
+}
+
+export function getSlotAmp(layout: EntitySlot[], slotIndex: number): number {
+    return layout[slotIndex]?.outputPct ?? 100
+}