@shipload/sdk 1.0.0-next.0 → 1.0.0-next.10

package/src/derivation/resources.ts

@@ -1,10 +1,16 @@
 import {getItem} from '../data/catalog'
+import {LocationType} from '../types'
 
 export const DEPTH_THRESHOLD_T1 = 0
-export const DEPTH_THRESHOLD_T2 = 2000
-export const DEPTH_THRESHOLD_T3 = 10000
-export const DEPTH_THRESHOLD_T4 = 30000
-export const DEPTH_THRESHOLD_T5 = 55000
+export const DEPTH_THRESHOLD_T2 = 1500
+export const DEPTH_THRESHOLD_T3 = 5000
+export const DEPTH_THRESHOLD_T4 = 12000
+export const DEPTH_THRESHOLD_T5 = 22000
+export const DEPTH_THRESHOLD_T6 = 32000
+export const DEPTH_THRESHOLD_T7 = 42000
+export const DEPTH_THRESHOLD_T8 = 50000
+export const DEPTH_THRESHOLD_T9 = 57000
+export const DEPTH_THRESHOLD_T10 = 63000
 
 export const LOCATION_MIN_DEPTH = 500
 export const LOCATION_MAX_DEPTH = 65535
@@ -18,19 +24,22 @@ export const PLANET_SUBTYPE_ICY = 3
 export const PLANET_SUBTYPE_OCEAN = 4
 export const PLANET_SUBTYPE_INDUSTRIAL = 5
 
+const DEPTH_THRESHOLD_TABLE = [
+    DEPTH_THRESHOLD_T1,
+    DEPTH_THRESHOLD_T2,
+    DEPTH_THRESHOLD_T3,
+    DEPTH_THRESHOLD_T4,
+    DEPTH_THRESHOLD_T5,
+    DEPTH_THRESHOLD_T6,
+    DEPTH_THRESHOLD_T7,
+    DEPTH_THRESHOLD_T8,
+    DEPTH_THRESHOLD_T9,
+    DEPTH_THRESHOLD_T10,
+]
+
 export function getDepthThreshold(tier: number): number {
-    switch (tier) {
-        case 1:
-            return DEPTH_THRESHOLD_T1
-        case 2:
-            return DEPTH_THRESHOLD_T2
-        case 3:
-            return DEPTH_THRESHOLD_T3
-        case 4:
-            return DEPTH_THRESHOLD_T4
-        default:
-            return DEPTH_THRESHOLD_T5
-    }
+    if (tier < 1 || tier > 10) return 65535
+    return DEPTH_THRESHOLD_TABLE[tier - 1]
 }
 
 export function getResourceTier(itemId: number): number {
@@ -46,9 +55,9 @@ export function getResourceWeight(itemId: number, stratum: number): number {
 
     switch (tier) {
         case 1:
-            if (stratum < 2000) return 100
-            if (stratum < 10000) return 80
-            if (stratum < 30000) return 50
+            if (stratum < DEPTH_THRESHOLD_T2) return 100
+            if (stratum < DEPTH_THRESHOLD_T3) return 80
+            if (stratum < DEPTH_THRESHOLD_T4) return 50
             return 30
         case 2:
             if (depthAbove < 3000) return 40
@@ -67,37 +76,107 @@ export function getResourceWeight(itemId: number, stratum: number): number {
     }
 }
 
-const ASTEROID_RESOURCES = [101, 102, 103, 201, 202]
-const NEBULA_RESOURCES = [202, 203, 301, 302, 303]
-const GAS_GIANT_RESOURCES = [301, 302, 303, 401, 501]
-const ROCKY_RESOURCES = [101, 102, 103, 401, 402, 403, 503]
-const TERRESTRIAL_RESOURCES = [201, 202, 401, 402, 501, 502, 503]
-const ICY_RESOURCES = [101, 301, 302, 401, 403, 501, 502]
-const OCEAN_RESOURCES = [201, 203, 301, 303, 501, 502, 503]
-const INDUSTRIAL_RESOURCES = [101, 102, 103, 201, 203, 402, 403]
+const RESOURCE_ORE = 0
+const RESOURCE_GAS = 1
+const RESOURCE_REGOLITH = 2
+const RESOURCE_BIOMASS = 3
+const RESOURCE_CRYSTAL = 4
 
-export function getLocationCandidates(locationType: number, subtype: number): number[] {
-    if (locationType === 2) return ASTEROID_RESOURCES
-    if (locationType === 3) return NEBULA_RESOURCES
-    if (locationType === 1) {
+interface LocationProfileEntry {
+    category: number
+    maxTier: number
+}
+
+function categoryBaseId(category: number): number {
+    switch (category) {
+        case RESOURCE_ORE:
+            return 100
+        case RESOURCE_CRYSTAL:
+            return 200
+        case RESOURCE_GAS:
+            return 300
+        case RESOURCE_REGOLITH:
+            return 400
+        case RESOURCE_BIOMASS:
+            return 500
+        default:
+            return 0
+    }
+}
+
+function resourceId(category: number, tier: number): number {
+    return categoryBaseId(category) + tier
+}
+
+export function getLocationProfile(locationType: number, subtype: number): LocationProfileEntry[] {
+    if (locationType === LocationType.ASTEROID) {
+        return [
+            {category: RESOURCE_ORE, maxTier: 5},
+            {category: RESOURCE_CRYSTAL, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.NEBULA) {
+        return [
+            {category: RESOURCE_GAS, maxTier: 5},
+            {category: RESOURCE_REGOLITH, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.ICE_FIELD) {
+        return [
+            {category: RESOURCE_GAS, maxTier: 5},
+            {category: RESOURCE_BIOMASS, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.PLANET) {
         switch (subtype) {
             case PLANET_SUBTYPE_GAS_GIANT:
-                return GAS_GIANT_RESOURCES
+                return [
+                    {category: RESOURCE_GAS, maxTier: 10},
+                    {category: RESOURCE_CRYSTAL, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_ROCKY:
-                return ROCKY_RESOURCES
+                return [
+                    {category: RESOURCE_REGOLITH, maxTier: 10},
+                    {category: RESOURCE_ORE, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_TERRESTRIAL:
-                return TERRESTRIAL_RESOURCES
+                return [
+                    {category: RESOURCE_ORE, maxTier: 10},
+                    {category: RESOURCE_BIOMASS, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_ICY:
-                return ICY_RESOURCES
+                return [
+                    {category: RESOURCE_CRYSTAL, maxTier: 10},
+                    {category: RESOURCE_REGOLITH, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_OCEAN:
-                return OCEAN_RESOURCES
+                return [
+                    {category: RESOURCE_BIOMASS, maxTier: 10},
+                    {category: RESOURCE_GAS, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_INDUSTRIAL:
-                return INDUSTRIAL_RESOURCES
+                return [
+                    {category: RESOURCE_ORE, maxTier: 3},
+                    {category: RESOURCE_CRYSTAL, maxTier: 3},
+                    {category: RESOURCE_REGOLITH, maxTier: 3},
+                    {category: RESOURCE_BIOMASS, maxTier: 3},
+                ]
         }
     }
     return []
 }
 
+export function getLocationCandidates(locationType: number, subtype: number): number[] {
+    const profile = getLocationProfile(locationType, subtype)
+    const ids: number[] = []
+    for (const {category, maxTier} of profile) {
+        for (let tier = 1; tier <= maxTier; tier++) {
+            ids.push(resourceId(category, tier))
+        }
+    }
+    return ids
+}
+
 export function getEligibleResources(
     locationType: number,
     subtype: number,

package/src/derivation/stats.ts

@@ -25,8 +25,7 @@ const ORE_STATS: StatDefinition[] = [
         key: 'density',
         label: 'Density',
         abbreviation: 'DEN',
-        purpose: 'Mass per unit',
-        inverted: true,
+        purpose: 'Structural integrity — higher rolls produce lighter hulls',
     },
 ]
 

package/src/entities/container.ts

@@ -1,6 +1,7 @@
 import {UInt64, type UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import type {CoordinatesType} from '../types'
+import {type FloatPosition, getInterpolatedPosition} from '../travel/travel'
 import {Location} from './location'
 import {ScheduleAccessor} from '../scheduling/accessor'
 import * as schedule from '../scheduling/schedule'
@@ -24,6 +25,14 @@ export class Container extends ServerContract.Types.entity_info {
         return this.entity_name
     }
 
+    get entityClass(): 'mobile' {
+        return 'mobile'
+    }
+
+    get canUndeploy(): boolean {
+        return true
+    }
+
     get sched(): ScheduleAccessor {
         this._sched ??= new ScheduleAccessor(this)
         return this._sched
@@ -33,6 +42,12 @@ export class Container extends ServerContract.Types.entity_info {
         return this.is_idle
     }
 
+    interpolatedPositionAt(now: Date): FloatPosition {
+        const taskIndex = this.sched.currentTaskIndex(now)
+        const progress = this.sched.currentTaskProgressFloat(now)
+        return getInterpolatedPosition(this, taskIndex, progress)
+    }
+
     isLoading(now: Date): boolean {
         return schedule.isLoading(this, now)
     }
@@ -75,12 +90,12 @@ export function computeContainerCapabilities(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 density = stats.density
+    const strength = stats.strength
+    const hardness = stats.hardness
+    const saturation = stats.saturation
 
-    const hullmass = 25000 + 75 * density
+    const hullmass = 100000 - 75 * density
 
     const statSum = strength + hardness + saturation
     const exponent = statSum / 2997
@@ -93,12 +108,12 @@ export function computeContainerT2Capabilities(stats: Record<string, number>): {
     hullmass: number
     capacity: number
 } {
-    const strength = stats['strength'] ?? 0
-    const density = stats['density'] ?? 0
-    const hardness = stats['hardness'] ?? 0
-    const saturation = stats['saturation'] ?? 0
+    const strength = stats.strength
+    const density = stats.density
+    const hardness = stats.hardness
+    const saturation = stats.saturation
 
-    const hullmass = 20000 + 50 * density
+    const hullmass = 70000 - 50 * density
 
     const statSum = strength + hardness + saturation
     const exponent = statSum / 2500

package/src/entities/extractor.ts

@@ -0,0 +1,144 @@
+import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import type {CoordinatesType} from '../types'
+import {Location} from './location'
+import {ScheduleAccessor} from '../scheduling/accessor'
+import {InventoryAccessor} from './inventory-accessor'
+import type {EntityInventory} from './entity-inventory'
+import type {PackedModuleInput} from './ship'
+import {decodeCraftedItemStats} from '../derivation/crafting'
+import {getModuleCapabilityType, MODULE_GATHERER, MODULE_GENERATOR} from '../capabilities/modules'
+import {computeGathererCapabilities, computeGeneratorCapabilities} from './ship-deploy'
+import {applySlotMultiplier, clampUint16, getSlotAmp, type InstalledModule} from './slot-multiplier'
+import type {EntitySlot} from '../data/recipes-runtime'
+import {getItem} from '../data/catalog'
+
+export interface ExtractorStateInput {
+    id: UInt64Type
+    owner: string
+    name: string
+    coordinates: CoordinatesType | {x: number; y: number; z?: number}
+    hullmass?: number
+    capacity?: number
+    energy?: number
+    modules?: PackedModuleInput[]
+    schedule?: ServerContract.Types.schedule
+    cargo?: ServerContract.Types.cargo_item[]
+}
+
+export class Extractor extends ServerContract.Types.entity_info {
+    private _sched?: ScheduleAccessor
+    private _inv?: InventoryAccessor
+
+    get name(): string {
+        return this.entity_name
+    }
+
+    get entityClass(): 'building' {
+        return 'building'
+    }
+
+    get canDemolish(): boolean {
+        return true
+    }
+
+    get inv(): InventoryAccessor {
+        this._inv ??= new InventoryAccessor(this)
+        return this._inv
+    }
+
+    get inventory(): EntityInventory[] {
+        return this.inv.items
+    }
+
+    get sched(): ScheduleAccessor {
+        this._sched ??= new ScheduleAccessor(this)
+        return this._sched
+    }
+
+    get isIdle(): boolean {
+        return this.is_idle
+    }
+
+    get location(): Location {
+        return Location.from(this.coordinates)
+    }
+
+    get totalCargoMass(): UInt64 {
+        return this.inv.totalMass
+    }
+
+    get maxCapacity(): UInt64 {
+        return UInt64.from(this.capacity)
+    }
+
+    get availableCapacity(): UInt64 {
+        const cargo = this.totalCargoMass
+        return cargo.gte(this.maxCapacity) ? UInt64.from(0) : this.maxCapacity.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)
+    }
+}
+
+export interface ExtractorCapabilities {
+    generator?: {capacity: number; recharge: number}
+    gatherer?: {yield: number; drain: number; depth: number; speed: number}
+}
+
+export function computeExtractorCapabilities(
+    modules: InstalledModule[],
+    layout: EntitySlot[]
+): ExtractorCapabilities {
+    const out: ExtractorCapabilities = {}
+
+    const genModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_GENERATOR)
+    if (genModules.length > 0) {
+        let totalCapacity = 0
+        let totalRecharge = 0
+        for (const m of genModules) {
+            const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            const amp = getSlotAmp(layout, m.slotIndex)
+            totalCapacity += applySlotMultiplier(caps.capacity, amp)
+            totalRecharge += applySlotMultiplier(caps.recharge, amp)
+        }
+        out.generator = {
+            capacity: clampUint16(totalCapacity),
+            recharge: clampUint16(totalRecharge),
+        }
+    }
+
+    const gathModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_GATHERER)
+    if (gathModules.length > 0) {
+        let totalYield = 0
+        let totalDrain = 0
+        let maxDepth = 0
+        let totalSpeed = 0
+        for (const m of gathModules) {
+            const tier = getItem(m.itemId).tier
+            const caps = computeGathererCapabilities(
+                decodeCraftedItemStats(m.itemId, m.stats),
+                tier
+            )
+            const amp = getSlotAmp(layout, m.slotIndex)
+            totalYield += applySlotMultiplier(caps.yield, amp)
+            totalDrain += caps.drain
+            if (caps.depth > maxDepth) maxDepth = caps.depth
+            totalSpeed += applySlotMultiplier(caps.speed, amp)
+        }
+        out.gatherer = {
+            yield: clampUint16(totalYield),
+            drain: totalDrain,
+            depth: maxDepth,
+            speed: clampUint16(totalSpeed),
+        }
+    }
+
+    return out
+}

package/src/entities/gamestate.ts

@@ -58,13 +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)
      */
@@ -137,14 +130,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

@@ -3,8 +3,13 @@ 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 {Extractor, computeExtractorCapabilities, type ExtractorStateInput} from './extractor'
+import {
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_WAREHOUSE_T1_PACKED,
+} from '../data/item-ids'
+import {getEntityLayout, type EntitySlot} from '../data/recipes-runtime'
 import {itemMetadata} from '../data/metadata'
 import {getItem} from '../data/catalog'
 import {
@@ -14,6 +19,7 @@ import {
     moduleSlotTypeToCode,
 } from '../capabilities/modules'
 import {computeShipCapabilities, computeStorageCapabilities} from './ship-deploy'
+import type {InstalledModule} from './slot-multiplier'
 import {decodeCraftedItemStats} from '../derivation/crafting'
 
 function assignModulesToSlots(
@@ -56,19 +62,22 @@ 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()),
-    }
+function toInstalledModules(entries: ServerContract.Types.module_entry[]): InstalledModule[] {
+    const installed: InstalledModule[] = []
+    entries.forEach((entry, slotIndex) => {
+        if (!entry.installed) return
+        installed.push({
+            slotIndex,
+            itemId: Number(UInt16.from(entry.installed.item_id).value.toString()),
+            stats: BigInt(UInt64.from(entry.installed.stats).toString()),
+        })
+    })
+    return installed
 }
 
-function computeStorageBonus(
-    decoded: {itemId: number; stats: bigint}[],
-    baseCapacity: number
-): number {
+function computeStorageBonus(modules: InstalledModule[], baseCapacity: number): number {
     let totalBonus = 0
-    for (const m of decoded) {
+    for (const m of modules) {
         if (getModuleCapabilityType(m.itemId) !== MODULE_STORAGE) continue
         const stats = decodeCraftedItemStats(m.itemId, m.stats)
         const {capacityBonus} = computeStorageCapabilities(stats, baseCapacity)
@@ -78,15 +87,16 @@ function computeStorageBonus(
 }
 
 function deriveShipFromModules(
-    modules: PackedModuleInput[],
+    moduleEntries: ServerContract.Types.module_entry[],
+    layout: EntitySlot[],
     baseCapacity: number
 ): {
     capabilities: ReturnType<typeof computeShipCapabilities>
     finalCapacity: number
 } {
-    const decoded = modules.map(decodePackedInput)
-    const capabilities = computeShipCapabilities(decoded)
-    const totalBonus = computeStorageBonus(decoded, baseCapacity)
+    const installed = toInstalledModules(moduleEntries)
+    const capabilities = computeShipCapabilities(installed, layout)
+    const totalBonus = computeStorageBonus(installed, baseCapacity)
     return {capabilities, finalCapacity: baseCapacity + totalBonus}
 }
 
@@ -109,10 +119,12 @@ export function makeShip(state: ShipStateInput): Ship {
     if (state.schedule) info.schedule = state.schedule
 
     let moduleEntries: ServerContract.Types.module_entry[] = []
+    const shipLayout = getEntityLayout(ITEM_SHIP_T1_PACKED)?.slots ?? []
     if (state.modules && state.modules.length > 0) {
         moduleEntries = assignModulesToSlots(ITEM_SHIP_T1_PACKED, state.modules, 'Ship T1')
         const {capabilities, finalCapacity} = deriveShipFromModules(
-            state.modules,
+            moduleEntries,
+            shipLayout,
             state.capacity ?? 0
         )
         if (capabilities.engines) info.engines = capabilities.engines
@@ -152,17 +164,18 @@ export function makeWarehouse(state: WarehouseStateInput): Warehouse {
     if (state.schedule) info.schedule = state.schedule
 
     let moduleEntries: ServerContract.Types.module_entry[] = []
+    const warehouseLayout = getEntityLayout(ITEM_WAREHOUSE_T1_PACKED)?.slots ?? []
     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)
+        const installed = toInstalledModules(moduleEntries)
+        const capabilities = computeWarehouseCapabilities(installed, warehouseLayout)
         if (capabilities.loaders) info.loaders = capabilities.loaders
 
-        const totalBonus = computeStorageBonus(decoded, state.capacity)
+        const totalBonus = computeStorageBonus(installed, state.capacity)
         info.capacity = UInt32.from(state.capacity + totalBonus)
     } else {
         moduleEntries = assignModulesToSlots(ITEM_WAREHOUSE_T1_PACKED, [], 'Warehouse T1')
@@ -174,6 +187,44 @@ export function makeWarehouse(state: WarehouseStateInput): Warehouse {
     return new Warehouse(entityInfo)
 }
 
+export function makeExtractor(state: ExtractorStateInput): Extractor {
+    const info: Record<string, unknown> = {
+        type: Name.from('extractor'),
+        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
+    if (state.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
+
+    const moduleEntries = assignModulesToSlots(
+        ITEM_EXTRACTOR_T1_PACKED,
+        state.modules ?? [],
+        'Extractor T1'
+    )
+    if (state.modules && state.modules.length > 0) {
+        const layout = getEntityLayout(ITEM_EXTRACTOR_T1_PACKED)?.slots ?? []
+        const installed = toInstalledModules(moduleEntries)
+        const capabilities = computeExtractorCapabilities(installed, layout)
+        if (capabilities.generator) info.generator = capabilities.generator
+        if (capabilities.gatherer) info.gatherer = capabilities.gatherer
+    }
+
+    info.modules = moduleEntries
+
+    const entityInfo = ServerContract.Types.entity_info.from(info)
+    return new Extractor(entityInfo)
+}
+
 export function makeContainer(state: ContainerStateInput): Container {
     const entityInfo = ServerContract.Types.entity_info.from({
         type: Name.from('container'),