@shipload/sdk 0.7.1 → 1.0.0-next.0

package/src/entities/location.ts

@@ -0,0 +1,60 @@
+import {Checksum256, type Checksum256Type, type UInt16Type, type UInt64} from '@wharfkit/antelope'
+import {Coordinates, type CoordinatesType, type Distance, type LocationType} from '../types'
+import {getLocationType, hasSystem, isGatherableLocation} 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)
+    }
+
+    isGatherableAt(gameSeed: Checksum256Type): boolean {
+        return isGatherableLocation(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,196 @@
+import {Name, UInt16, UInt32, UInt64, UInt8} 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 {getEntityLayout} 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'
+
+function assignModulesToSlots(
+    packedEntityItemId: number,
+    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 slotIdx = result.findIndex((r) => !r.installed && moduleAccepts(r.type, modType))
+        if (slotIdx === -1) {
+            let modName: string
+            try {
+                modName = getItem(itemId).name
+            } catch {
+                modName = itemMetadata[itemId]?.name ?? `item ${itemId}`
+            }
+            throw new Error(
+                `No compatible slot for module ${modName} (type ${modType}) on ${entityLabel}`
+            )
+        }
+        result[slotIdx].installed = ServerContract.Types.packed_module.from({
+            item_id: UInt16.from(mod.itemId),
+            stats: UInt64.from(mod.stats),
+        })
+    }
+
+    return result.map((r) =>
+        ServerContract.Types.module_entry.from({
+            type: UInt8.from(r.type),
+            installed: r.installed,
+        })
+    )
+}
+
+function decodePackedInput(m: PackedModuleInput): {itemId: number; stats: bigint} {
+    return {
+        itemId: Number(UInt16.from(m.itemId).value.toString()),
+        stats: BigInt(UInt64.from(m.stats).toString()),
+    }
+}
+
+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
+    }
+    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}
+}
+
+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.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.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
+    }
+
+    info.modules = moduleEntries
+
+    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.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
+
+        const totalBonus = computeStorageBonus(decoded, state.capacity)
+        info.capacity = UInt32.from(state.capacity + totalBonus)
+    } else {
+        moduleEntries = assignModulesToSlots(ITEM_WAREHOUSE_T1_PACKED, [], 'Warehouse T1')
+    }
+
+    info.modules = moduleEntries
+
+    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)
+}

package/src/entities/player.ts

@@ -0,0 +1,15 @@
+import {Name, type 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)
+    }
+}

package/src/entities/ship-deploy.ts

@@ -0,0 +1,258 @@
+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 hardness = stats.hardness ?? 500
+    const saturation = stats.saturation ?? 500
+
+    const hullmass = 25000 + 75 * density
+    const statSum = strength + hardness + saturation
+    const exponent = statSum / 2997.0
+    const capacity = Math.floor(1000000 * 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 ref = stats.reflectivity ?? 500
+
+    return {
+        capacity: 300 + Math.floor(res / 6),
+        recharge: 1 + Math.floor((ref * 3) / 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(250, 1250 - Math.floor((con * 25) / 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 hrd = stats.hardness ?? 500
+    const pla = stats.plasticity ?? 500
+
+    return {
+        mass: Math.max(200, 2000 - Math.floor(hrd * 2)),
+        thrust: 1 + Math.floor(pla / 500),
+        quantity: 1,
+    }
+}
+
+export function computeCrafterCapabilities(stats: Record<string, number>): {
+    speed: number
+    drain: number
+} {
+    const rea = stats.reactivity ?? 500
+    const com = stats.composition ?? 500
+
+    return {
+        speed: 100 + Math.floor((rea * 4) / 5),
+        drain: Math.max(5, 30 - Math.floor(com / 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 ref = stats.reflectivity ?? 500
+
+    return {
+        capacity: Math.max(1, 1 + Math.floor(res / 400)),
+        efficiency: 2000 + con * 6,
+        drain: Math.max(3, 15 - Math.floor(ref / 80)),
+    }
+}
+
+export function computeStorageCapabilities(
+    stats: Record<string, number>,
+    baseCapacity: number
+): {
+    capacityBonus: number
+} {
+    const strength = stats.strength ?? 500
+    const hardness = stats.hardness ?? 500
+    const saturation = stats.saturation ?? 500
+
+    const statSum = strength + hardness + saturation
+    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 hardness = stats.hardness ?? 500
+    const saturation = stats.saturation ?? 500
+
+    const hullmass = 25000 + 75 * density
+    const statSum = strength + hardness + saturation
+    const exponent = statSum / 2997.0
+    const capacity = Math.floor(20000000 * 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; stats: 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.stats))
+            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.stats))
+            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.stats))
+            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 caps = computeHaulerCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            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.stats))
+            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 = computeCrafterCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            totalSpeed += caps.speed
+            totalDrain += caps.drain
+        }
+        ship.crafter = {speed: totalSpeed, drain: totalDrain}
+    }
+
+    return ship
+}