@shipload/sdk 1.0.0-next.3 → 1.0.0-next.5

package/src/index-module.ts

@@ -117,30 +117,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,
@@ -202,14 +207,19 @@ export type {PlanetSubtypeInfo} from './data/locations'
 export {
     capabilityNames,
     capabilityAttributes,
-    statMappings,
     isInvertedAttribute,
     getCapabilityAttributes,
+} from './data/capabilities'
+export type {CapabilityAttribute, StatMapping} from './data/capabilities'
+
+export {
+    deriveStatMappings,
     getStatMappings,
     getStatMappingsForStat,
     getStatMappingsForCapability,
-} from './data/capabilities'
-export type {CapabilityAttribute, StatMapping} from './data/capabilities'
+} from './derivation/capability-mappings'
+export {SLOT_FORMULAS} from './data/capability-formulas'
+export type {SlotConsumer, SlotConsumerKind} from './data/capability-formulas'
 
 export {
     encodeStats,
@@ -241,8 +251,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 {
@@ -302,6 +315,7 @@ export {
     computeLoaderThrust,
     computeCrafterSpeed,
     computeCrafterDrain,
+    computeWarpRange,
 } from './nft/description'
 
 export {

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)
@@ -44,17 +48,21 @@ export function computeBaseCapacityWarehouse(stats: bigint): number {
 
 export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
 export const computeEngineDrain = (thm: number): number => Math.max(30, 50 - idiv(thm, 70))
-export const computeGeneratorCap = (res: number): number => 300 + idiv(res, 6)
-export const computeGeneratorRech = (ref: number): number => 1 + idiv(ref * 3, 1000)
+export const computeGeneratorCap = (com: number): number => 300 + idiv(com, 6)
+export const computeGeneratorRech = (fin: number): number => 1 + idiv(fin * 3, 1000)
 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 = (fin: number): number => Math.max(200, 2000 - fin * 2)
+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 = (com: number): number => Math.max(5, 30 - idiv(com, 33))
+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)}`

package/src/resolution/resolve-item.ts

@@ -155,7 +155,8 @@ function resolveComponent(id: number, stats?: UInt64Type): ResolvedItem {
 
 function computeCapabilityGroup(
     moduleType: number,
-    stats: Record<string, number>
+    stats: Record<string, number>,
+    tier: number
 ): ResolvedAttributeGroup | undefined {
     switch (moduleType) {
         case MODULE_ENGINE: {
@@ -179,7 +180,7 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_GATHERER: {
-            const caps = computeGathererCapabilities(stats)
+            const caps = computeGathererCapabilities(stats, tier)
             return {
                 capability: 'Gatherer',
                 attributes: [
@@ -223,10 +224,11 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_STORAGE: {
-            const str = stats.strength ?? 500
-            const hrd = stats.hardness ?? 500
-            const sat = stats.saturation ?? 500
-            const statSum = str + hrd + sat
+            const str = stats.strength
+            const den = stats.density
+            const hrd = stats.hardness
+            const sat = stats.saturation
+            const statSum = str + den + hrd + sat
             const pct = 10 + Math.floor((statSum * 10) / 2997)
             return {capability: 'Storage', attributes: [{label: 'Capacity Bonus', value: pct}]}
         }
@@ -241,7 +243,7 @@ function resolveModule(id: number, stats?: UInt64Type): ResolvedItem {
     if (stats !== undefined) {
         const decoded = decodeCraftedItemStats(id, toBigStats(stats))
         const modType = getModuleCapabilityType(id)
-        const group = computeCapabilityGroup(modType, decoded)
+        const group = computeCapabilityGroup(modType, decoded, item.tier)
         if (group) attributes = [group]
     }
     return {
@@ -310,13 +312,16 @@ function resolveEntity(
                 const modStats = BigInt(mod.installed.stats.toString())
                 const decodedStats = decodeCraftedItemStats(modItemId, modStats)
                 const modType = getModuleCapabilityType(modItemId)
-                const group = computeCapabilityGroup(modType, decodedStats)
                 let modName = 'Module'
+                let modTier = 1
                 try {
-                    modName = getItem(modItemId).name
+                    const modItem = getItem(modItemId)
+                    modName = modItem.name
+                    modTier = modItem.tier
                 } catch {
                     modName = itemMetadata[modItemId]?.name ?? 'Module'
                 }
+                const group = computeCapabilityGroup(modType, decodedStats, modTier)
                 return {
                     name: modName,
                     installed: true,

package/src/scheduling/accessor.ts

@@ -72,6 +72,10 @@ export class ScheduleAccessor {
         return schedule.currentTaskProgress(this.entity, now)
     }
 
+    currentTaskProgressFloat(now: Date): number {
+        return schedule.currentTaskProgressFloat(this.entity, now)
+    }
+
     progress(now: Date): number {
         return schedule.scheduleProgress(this.entity, now)
     }

package/src/scheduling/projection.ts

@@ -267,6 +267,10 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
         case TaskType.DEPLOY:
             applyDeployTask(projected, task)
             break
+        case TaskType.UNDEPLOY:
+        case TaskType.WRAP_ENTITY:
+        case TaskType.DEMOLISH:
+            break
     }
 }
 
@@ -448,6 +452,10 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
             case TaskType.DEPLOY:
                 if (taskComplete) applyDeployTask(projected, task)
                 break
+            case TaskType.UNDEPLOY:
+            case TaskType.WRAP_ENTITY:
+            case TaskType.DEMOLISH:
+                break
         }
     }
 

package/src/scheduling/schedule.ts

@@ -77,7 +77,7 @@ export function currentTaskIndex(entity: ScheduleData, now: Date): number {
         timeAccum += taskDuration
     }
 
-    return entity.schedule.tasks.length - 1
+    return -1
 }
 
 export function currentTask(entity: ScheduleData, now: Date): Task | undefined {
@@ -147,6 +147,20 @@ export function currentTaskProgress(entity: ScheduleData, now: Date): number {
     return Math.min(1, elapsed / duration)
 }
 
+export function currentTaskProgressFloat(entity: ScheduleData, now: Date): number {
+    if (!entity.schedule || entity.schedule.tasks.length === 0) return 0
+    const index = currentTaskIndex(entity, now)
+    if (index < 0) return 0
+    const task = entity.schedule.tasks[index]
+    const durationMs = task.duration.toNumber() * 1000
+    if (durationMs === 0) return 1
+    const startedMs = entity.schedule.started.toDate().getTime()
+    const taskStartMs = startedMs + getTaskStartTime(entity, index) * 1000
+    const elapsedMs = now.getTime() - taskStartMs
+    if (elapsedMs <= 0) return 0
+    return Math.min(1, elapsedMs / durationMs)
+}
+
 export function scheduleProgress(entity: ScheduleData, now: Date): number {
     const duration = scheduleDuration(entity)
     if (duration === 0) return hasSchedule(entity) ? 1 : 0

package/src/subscriptions/manager.ts

@@ -34,6 +34,12 @@ export interface BoundsSubscriptionHandle {
     current: Map<number, EntityInstance>
 }
 
+export interface OwnerSubscriptionHandle {
+    readonly subId: string
+    unsubscribe(): void
+    current: Map<number, EntityInstance>
+}
+
 export interface EntitySubscriptionHandle {
     readonly subId: string
     readonly entityType: SubscriptionEntityType
@@ -62,7 +68,7 @@ export class SubscriptionsManager {
             onSnapshot?: (entities: EntityInstance[]) => void
             onUpdate?: (entity: EntityInstance) => void
             onBoundsDelta?: (entered: EntityInstance[], exited: number[]) => void
-            handle: BoundsSubscriptionHandle
+            handle: BoundsSubscriptionHandle | OwnerSubscriptionHandle
         }
     >()
     private subCounter = 0
@@ -162,6 +168,36 @@ export class SubscriptionsManager {
         return handle
     }
 
+    subscribeOwner(
+        owner: string,
+        handlers: {
+            onSnapshot?: (entities: EntityInstance[]) => void
+            onUpdate?: (entity: EntityInstance) => void
+        } = {}
+    ): OwnerSubscriptionHandle {
+        const subId = this.generateSubID('own')
+        const msg: SubscribeMessage = {
+            type: 'subscribe',
+            sub_id: subId,
+            owner,
+        }
+        const handle: OwnerSubscriptionHandle = {
+            subId,
+            unsubscribe: () => this.unsubscribeBounds(subId),
+            current: new Map(),
+        }
+        this.boundsSubs.set(subId, {
+            bounds: undefined,
+            owner,
+            prioritizeOwner: undefined,
+            onSnapshot: handlers.onSnapshot,
+            onUpdate: handlers.onUpdate,
+            handle,
+        })
+        this.sendMessage(msg)
+        return handle
+    }
+
     private unsubscribeBounds(subId: string) {
         this.boundsSubs.delete(subId)
         this.sendMessage({type: 'unsubscribe', sub_id: subId})

package/src/travel/travel.ts

@@ -77,6 +77,59 @@ export function lerp(
     }
 }
 
+export interface FloatPosition {
+    x: number
+    y: number
+}
+
+export function easeFlightProgress(t: number): number {
+    if (t <= 0) return 0
+    if (t >= 1) return 1
+    return t < 0.5 ? 2 * t * t : 1 - 2 * (1 - t) * (1 - t)
+}
+
+export function flightSpeedFactor(t: number): number {
+    if (t <= 0 || t >= 1) return 0
+    return t < 0.5 ? 4 * t : 4 * (1 - t)
+}
+
+export function interpolateFlightPosition(
+    origin: {x: Int64Type | number; y: Int64Type | number},
+    destination: {x: Int64Type | number; y: Int64Type | number},
+    taskProgress: number,
+    options?: {easing?: 'physics' | 'linear'}
+): FloatPosition {
+    const t = options?.easing === 'linear' ? taskProgress : easeFlightProgress(taskProgress)
+    return {
+        x: (1 - t) * Number(origin.x) + t * Number(destination.x),
+        y: (1 - t) * Number(origin.y) + t * Number(destination.y),
+    }
+}
+
+export function getInterpolatedPosition(
+    entity: HasScheduleAndLocation,
+    taskIndex: number,
+    taskProgress: number
+): FloatPosition {
+    if (!entity.schedule || entity.schedule.tasks.length === 0) {
+        return {x: Number(entity.coordinates.x), y: Number(entity.coordinates.y)}
+    }
+    if (taskIndex < 0) {
+        const settled = getFlightOrigin(entity, entity.schedule.tasks.length)
+        return {x: Number(settled.x), y: Number(settled.y)}
+    }
+    const task = entity.schedule.tasks[taskIndex]
+    if (!task.type.equals(TaskType.TRAVEL) || !task.coordinates) {
+        const origin = getFlightOrigin(entity, taskIndex)
+        return {x: Number(origin.x), y: Number(origin.y)}
+    }
+    return interpolateFlightPosition(
+        getFlightOrigin(entity, taskIndex),
+        task.coordinates,
+        taskProgress
+    )
+}
+
 export function rotation(
     origin: ServerContract.ActionParams.Type.coordinates,
     destination: ServerContract.ActionParams.Type.coordinates
@@ -408,14 +461,18 @@ export function getDestinationLocation(
     return undefined
 }
 
+/** Returns chain-tile coordinates (rounded). For visual position use getInterpolatedPosition. */
 export function getPositionAt(
     entity: HasScheduleAndLocation,
     taskIndex: number,
     taskProgress: number
 ): ServerContract.ActionParams.Type.coordinates {
-    if (!entity.schedule || entity.schedule.tasks.length === 0 || taskIndex < 0) {
+    if (!entity.schedule || entity.schedule.tasks.length === 0) {
         return entity.coordinates
     }
+    if (taskIndex < 0) {
+        return getFlightOrigin(entity, entity.schedule.tasks.length)
+    }
 
     const task = entity.schedule.tasks[taskIndex]
 

package/src/types.ts

@@ -51,6 +51,9 @@ export enum TaskType {
     DEPLOY = 8,
     WRAP = 9,
     UNWRAP = 10,
+    UNDEPLOY = 11,
+    WRAP_ENTITY = 12,
+    DEMOLISH = 13,
 }
 
 export enum LocationType {