@shipload/sdk 1.0.0-next.4 → 1.0.0-next.6

package/src/data/metadata.ts

@@ -11,7 +11,7 @@ export interface EntityMetadata {
 }
 
 export const itemMetadata: Record<number, ItemMetadata> = {
-    // === Resources (raw) ===
+    // === Resources / Ore ===
     101: {name: 'Ore', description: 'Crude metallic ore.', color: '#C26D3F'},
     102: {name: 'Ore', description: 'Refined metallic ore with improved purity.', color: '#C26D3F'},
     103: {
@@ -19,6 +19,15 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         description: 'High-grade metallic ore with exceptional density.',
         color: '#C26D3F',
     },
+    104: {name: 'Ore', description: '', color: '#C26D3F'},
+    105: {name: 'Ore', description: '', color: '#C26D3F'},
+    106: {name: 'Ore', description: '', color: '#C26D3F'},
+    107: {name: 'Ore', description: '', color: '#C26D3F'},
+    108: {name: 'Ore', description: '', color: '#C26D3F'},
+    109: {name: 'Ore', description: '', color: '#C26D3F'},
+    110: {name: 'Ore', description: '', color: '#C26D3F'},
+
+    // === Resources / Crystal ===
     201: {name: 'Crystal', description: 'Raw resonant crystal.', color: '#4ADBFF'},
     202: {
         name: 'Crystal',
@@ -30,6 +39,15 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         description: 'High-grade resonant crystal with exceptional purity.',
         color: '#4ADBFF',
     },
+    204: {name: 'Crystal', description: '', color: '#4ADBFF'},
+    205: {name: 'Crystal', description: '', color: '#4ADBFF'},
+    206: {name: 'Crystal', description: '', color: '#4ADBFF'},
+    207: {name: 'Crystal', description: '', color: '#4ADBFF'},
+    208: {name: 'Crystal', description: '', color: '#4ADBFF'},
+    209: {name: 'Crystal', description: '', color: '#4ADBFF'},
+    210: {name: 'Crystal', description: '', color: '#4ADBFF'},
+
+    // === Resources / Gas ===
     301: {name: 'Gas', description: 'Raw volatile gas.', color: '#B8E4A0'},
     302: {
         name: 'Gas',
@@ -41,6 +59,15 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         description: 'High-grade volatile gas with exceptional energy density.',
         color: '#B8E4A0',
     },
+    304: {name: 'Gas', description: '', color: '#B8E4A0'},
+    305: {name: 'Gas', description: '', color: '#B8E4A0'},
+    306: {name: 'Gas', description: '', color: '#B8E4A0'},
+    307: {name: 'Gas', description: '', color: '#B8E4A0'},
+    308: {name: 'Gas', description: '', color: '#B8E4A0'},
+    309: {name: 'Gas', description: '', color: '#B8E4A0'},
+    310: {name: 'Gas', description: '', color: '#B8E4A0'},
+
+    // === Resources / Regolith ===
     401: {name: 'Regolith', description: 'Crude regolith dust.', color: '#C4A57B'},
     402: {
         name: 'Regolith',
@@ -52,6 +79,15 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         description: 'High-grade regolith with exceptional uniformity.',
         color: '#C4A57B',
     },
+    404: {name: 'Regolith', description: '', color: '#C4A57B'},
+    405: {name: 'Regolith', description: '', color: '#C4A57B'},
+    406: {name: 'Regolith', description: '', color: '#C4A57B'},
+    407: {name: 'Regolith', description: '', color: '#C4A57B'},
+    408: {name: 'Regolith', description: '', color: '#C4A57B'},
+    409: {name: 'Regolith', description: '', color: '#C4A57B'},
+    410: {name: 'Regolith', description: '', color: '#C4A57B'},
+
+    // === Resources / Biomass ===
     501: {name: 'Biomass', description: 'Crude organic biomass.', color: '#5A8B3E'},
     502: {
         name: 'Biomass',
@@ -63,6 +99,13 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         description: 'High-grade biomass with exceptional saturation.',
         color: '#5A8B3E',
     },
+    504: {name: 'Biomass', description: '', color: '#5A8B3E'},
+    505: {name: 'Biomass', description: '', color: '#5A8B3E'},
+    506: {name: 'Biomass', description: '', color: '#5A8B3E'},
+    507: {name: 'Biomass', description: '', color: '#5A8B3E'},
+    508: {name: 'Biomass', description: '', color: '#5A8B3E'},
+    509: {name: 'Biomass', description: '', color: '#5A8B3E'},
+    510: {name: 'Biomass', description: '', color: '#5A8B3E'},
 
     // === Components (T1) ===
     10001: {

package/src/derivation/index.ts

@@ -7,6 +7,7 @@ export {
     getEligibleResources,
     getResourceWeight,
     getLocationCandidates,
+    getLocationProfile,
     getDepthThreshold,
     getResourceTier,
     DEPTH_THRESHOLD_T1,

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/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)
     }

package/src/entities/ship-deploy.ts

@@ -8,6 +8,7 @@ import {
     MODULE_HAULER,
     MODULE_LOADER,
 } from '../capabilities/modules'
+import {getItem} from '../data/catalog'
 
 export function computeShipHullCapabilities(stats: Record<string, number>): {
     hullmass: number
@@ -52,7 +53,38 @@ export function computeGeneratorCapabilities(stats: Record<string, number>): {
     }
 }
 
-export function computeGathererCapabilities(stats: Record<string, number>): {
+export interface GathererDepthParams {
+    readonly floor: number
+    readonly slope: number
+}
+
+export const GATHERER_DEPTH_TABLE: readonly GathererDepthParams[] = [
+    {floor: 500, slope: 5},
+    {floor: 2000, slope: 11},
+    {floor: 7000, slope: 16},
+    {floor: 15000, slope: 18},
+    {floor: 25000, slope: 19},
+    {floor: 35000, slope: 16},
+    {floor: 46000, slope: 12},
+    {floor: 53500, slope: 10},
+    {floor: 60000, slope: 5},
+    {floor: 63500, slope: 2},
+]
+
+export const GATHERER_DEPTH_MAX_TIER = 10
+
+export function gathererDepthForTier(tol: number, tier: number): number {
+    if (tier < 1 || tier > GATHERER_DEPTH_MAX_TIER) {
+        throw new Error(`gatherer tier out of range: ${tier}`)
+    }
+    const p = GATHERER_DEPTH_TABLE[tier - 1]
+    return p.floor + tol * p.slope
+}
+
+export function computeGathererCapabilities(
+    stats: Record<string, number>,
+    tier: number
+): {
     yield: number
     drain: number
     depth: number
@@ -66,7 +98,7 @@ export function computeGathererCapabilities(stats: Record<string, number>): {
     return {
         yield: 200 + str,
         drain: Math.max(250, 1250 - Math.floor((con * 25) / 20)),
-        depth: 200 + Math.floor((tol * 3) / 2),
+        depth: gathererDepthForTier(tol, tier),
         speed: 100 + Math.floor((ref * 4) / 5),
     }
 }
@@ -197,16 +229,20 @@ export function computeShipCapabilities(
     if (gathererModules.length > 0) {
         let totalYield = 0
         let totalDrain = 0
-        let totalDepth = 0
+        let maxDepth = 0
         let totalSpeed = 0
         for (const m of gathererModules) {
-            const caps = computeGathererCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            const tier = getItem(m.itemId).tier
+            const caps = computeGathererCapabilities(
+                decodeCraftedItemStats(m.itemId, m.stats),
+                tier
+            )
             totalYield += caps.yield
             totalDrain += caps.drain
-            totalDepth += caps.depth
+            if (caps.depth > maxDepth) maxDepth = caps.depth
             totalSpeed += caps.speed
         }
-        ship.gatherer = {yield: totalYield, drain: totalDrain, depth: totalDepth, speed: totalSpeed}
+        ship.gatherer = {yield: totalYield, drain: totalDrain, depth: maxDepth, speed: totalSpeed}
     }
 
     const haulerModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_HAULER)

package/src/entities/ship.ts

@@ -2,7 +2,9 @@ import {type UInt16, type UInt16Type, UInt32, UInt64, type UInt64Type} from '@wh
 import {ServerContract} from '../contracts'
 import {Coordinates, type CoordinatesType} from '../types'
 import {
+    type FloatPosition,
     getDestinationLocation,
+    getInterpolatedPosition,
     getPositionAt,
     getFlightOrigin as travelGetFlightOrigin,
 } from '../travel/travel'
@@ -55,6 +57,14 @@ export class Ship extends ServerContract.Types.entity_info {
         return this.entity_name
     }
 
+    get entityClass(): 'mobile' {
+        return 'mobile'
+    }
+
+    get canUndeploy(): boolean {
+        return true
+    }
+
     get inv(): InventoryAccessor {
         this._inv ??= new InventoryAccessor(this)
         return this._inv
@@ -87,12 +97,19 @@ export class Ship extends ServerContract.Types.entity_info {
         return dest ? Coordinates.from(dest) : undefined
     }
 
+    /** Chain-tile coordinates at `now`. For smooth visual position use interpolatedPositionAt. */
     positionAt(now: Date): Coordinates {
         const taskIndex = this.sched.currentTaskIndex(now)
         const progress = this.sched.currentTaskProgress(now)
         return Coordinates.from(getPositionAt(this, taskIndex, progress))
     }
 
+    interpolatedPositionAt(now: Date): FloatPosition {
+        const taskIndex = this.sched.currentTaskIndex(now)
+        const progress = this.sched.currentTaskProgressFloat(now)
+        return getInterpolatedPosition(this, taskIndex, progress)
+    }
+
     isInFlight(now: Date): boolean {
         return schedule.isInFlight(this, now)
     }

package/src/entities/warehouse.ts

@@ -31,6 +31,14 @@ export class Warehouse extends ServerContract.Types.entity_info {
         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

package/src/index-module.ts

@@ -86,6 +86,7 @@ export {
     getEligibleResources,
     getResourceWeight,
     getLocationCandidates,
+    getLocationProfile,
     getDepthThreshold,
     getResourceTier,
     DEPTH_THRESHOLD_T1,
@@ -117,30 +118,35 @@ export {
     distanceBetweenCoordinates,
     distanceBetweenPoints,
     findNearbyPlanets,
-    lerp,
-    rotation,
-    calc_ship_mass,
     calc_acceleration,
+    calc_energyusage,
     calc_flighttime,
-    calc_ship_flighttime,
-    calc_ship_acceleration,
-    calc_rechargetime,
-    calc_ship_rechargetime,
-    calc_loader_flighttime,
     calc_loader_acceleration,
-    calc_energyusage,
+    calc_loader_flighttime,
     calc_orbital_altitude,
+    calc_rechargetime,
+    calc_ship_acceleration,
+    calc_ship_flighttime,
+    calc_ship_mass,
+    calc_ship_rechargetime,
     calc_transfer_duration,
-    calculateTransferTime,
+    calculateFlightTime,
     calculateLoadTimeBreakdown,
     calculateRefuelingTime,
-    calculateFlightTime,
-    estimateTravelTime,
+    calculateTransferTime,
+    easeFlightProgress,
     estimateDealTravelTime,
-    hasEnergyForDistance,
-    getFlightOrigin,
+    estimateTravelTime,
+    flightSpeedFactor,
+    type FloatPosition,
     getDestinationLocation,
+    getFlightOrigin,
+    getInterpolatedPosition,
     getPositionAt,
+    hasEnergyForDistance,
+    interpolateFlightPosition,
+    lerp,
+    rotation,
 } from './travel/travel'
 export type {
     LoadTimeBreakdown,
@@ -246,8 +252,11 @@ export {
     computeWarehouseHullCapabilities,
     computeStorageCapabilities,
     computeShipCapabilities,
+    GATHERER_DEPTH_TABLE,
+    GATHERER_DEPTH_MAX_TIER,
+    gathererDepthForTier,
 } from './entities/ship-deploy'
-export type {ShipCapabilities} from './entities/ship-deploy'
+export type {ShipCapabilities, GathererDepthParams} from './entities/ship-deploy'
 
 export {resolveItem} from './resolution/resolve-item'
 export type {

package/src/managers/actions.ts

@@ -15,7 +15,7 @@ import {type CoordinatesType, EntityType, type EntityTypeName} from '../types'
 import {ServerContract} from '../contracts'
 
 export type EntityRefInput = {
-    entityType: EntityTypeName
+    entityType: NameType
     entityId: UInt64Type
 }
 
@@ -244,6 +244,29 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    undeploy(host: EntityRefInput, target: EntityRefInput): Action {
+        return this.server.action('undeploy', {
+            host_type: Name.from(host.entityType),
+            host_id: UInt64.from(host.entityId),
+            target_type: Name.from(target.entityType),
+            target_id: UInt64.from(target.entityId),
+        })
+    }
+
+    wrapEntity(entity: EntityRefInput): Action {
+        return this.server.action('wrapentity', {
+            entity_type: Name.from(entity.entityType),
+            entity_id: UInt64.from(entity.entityId),
+        })
+    }
+
+    demolish(entity: EntityRefInput): Action {
+        return this.server.action('demolish', {
+            entity_type: Name.from(entity.entityType),
+            entity_id: UInt64.from(entity.entityId),
+        })
+    }
+
     joinGame(account: NameType, companyName: string): Action[] {
         return [this.foundCompany(account, companyName), this.join(account)]
     }

package/src/nft/description.ts

@@ -4,6 +4,7 @@ import {
     MODULE_ENGINE,
     MODULE_GATHERER,
     MODULE_GENERATOR,
+    MODULE_HAULER,
     MODULE_LOADER,
     MODULE_STORAGE,
     MODULE_WARP,
@@ -15,6 +16,7 @@ import {
     ITEM_ENGINE_T1,
     ITEM_GATHERER_T1,
     ITEM_GENERATOR_T1,
+    ITEM_HAULER_T1,
     ITEM_LOADER_T1,
     ITEM_SHIP_T1_PACKED,
     ITEM_STORAGE_T1,
@@ -22,6 +24,8 @@ import {
     ITEM_WARP_T1,
 } from '../data/item-ids'
 import {decodeStat} from '../derivation/crafting'
+import {gathererDepthForTier} from '../entities/ship-deploy'
+import {getItem} from '../data/catalog'
 
 function idiv(a: number, b: number): number {
     return Math.floor(a / b)
@@ -49,12 +53,16 @@ export const computeGeneratorRech = (fin: number): number => 1 + idiv(fin * 3, 1
 export const computeGathererYield = (str: number): number => 200 + str
 export const computeGathererDrain = (con: number): number =>
     Math.max(250, 1250 - idiv(con * 25, 20))
-export const computeGathererDepth = (tol: number): number => 200 + idiv(tol * 3, 2)
+export const computeGathererDepth = (tol: number, tier: number): number =>
+    gathererDepthForTier(tol, tier)
 export const computeGathererSpeed = (ref: number): number => 100 + idiv(ref * 4, 5)
 export const computeLoaderMass = (ins: number): number => Math.max(200, 2000 - ins * 2)
 export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla, 500)
 export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
 export const computeCrafterDrain = (fin: number): number => Math.max(5, 30 - idiv(fin, 33))
+export const computeHaulerCapacity = (fin: number): number => Math.max(1, 1 + idiv(fin, 400))
+export const computeHaulerEfficiency = (con: number): number => 2000 + con * 6
+export const computeHaulerDrain = (com: number): number => Math.max(3, 15 - idiv(com, 80))
 export const computeWarpRange = (stat: number): number => 100 + stat * 3
 
 export function entityDisplayName(itemId: number): string {
@@ -86,6 +94,8 @@ export function moduleDisplayName(itemId: number): string {
             return 'Crafter'
         case ITEM_STORAGE_T1:
             return 'Storage'
+        case ITEM_HAULER_T1:
+            return 'Hauler'
         case ITEM_WARP_T1:
             return 'Warp'
         default:
@@ -121,8 +131,10 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             const tol = decodeStat(stats, 1)
             const con = decodeStat(stats, 3)
             const ref = decodeStat(stats, 4)
+            const tier = getItem(itemId).tier
             out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
-                tol
+                tol,
+                tier
             )}  Speed ${computeGathererSpeed(ref)}  Drain ${computeGathererDrain(con)}`
             break
         }
@@ -147,6 +159,13 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             out += `  +${pct}% capacity`
             break
         }
+        case MODULE_HAULER: {
+            const fin = decodeStat(stats, 0)
+            const con = decodeStat(stats, 1)
+            const com = decodeStat(stats, 2)
+            out += `  Capacity ${computeHaulerCapacity(fin)}  Efficiency ${computeHaulerEfficiency(con)}  Drain ${computeHaulerDrain(com)}`
+            break
+        }
         case MODULE_WARP: {
             const stat = decodeStat(stats, 0)
             out += `  Range ${computeWarpRange(stat)}`