@shipload/sdk 1.0.0-next.1 → 1.0.0-next.11

package/src/subscriptions/connection.ts

@@ -7,6 +7,9 @@ export interface WebSocketConnectionOptions {
     url: string
     onMessage: (message: ServerMessage) => void
     onStateChange?: (state: ConnectionState) => void
+    minReconnectDelay?: number
+    pingIntervalMs?: number
+    pongTimeoutMs?: number
 }
 
 export class WebSocketConnection {
@@ -19,15 +22,26 @@ export class WebSocketConnection {
     private _state: ConnectionState = 'disconnected'
     private shouldReconnect = true
     private sendQueue: string[] = []
+    private minReconnectDelay: number
+    private pingIntervalMs: number
+    private pongTimeoutMs: number
+    private pingTimer: ReturnType<typeof setInterval> | null = null
+    private staleTimer: ReturnType<typeof setTimeout> | null = null
 
-    private static readonly MIN_RECONNECT_DELAY = 1000
+    private static readonly DEFAULT_MIN_RECONNECT_DELAY = 1000
     private static readonly MAX_RECONNECT_DELAY = 30000
     private static readonly RECONNECT_MULTIPLIER = 2
+    private static readonly DEFAULT_PING_INTERVAL_MS = 25000
+    private static readonly DEFAULT_PONG_TIMEOUT_MS = 10000
 
     constructor(options: WebSocketConnectionOptions) {
         this.url = options.url
         this.onMessage = options.onMessage
         this.onStateChange = options.onStateChange
+        this.minReconnectDelay =
+            options.minReconnectDelay ?? WebSocketConnection.DEFAULT_MIN_RECONNECT_DELAY
+        this.pingIntervalMs = options.pingIntervalMs ?? WebSocketConnection.DEFAULT_PING_INTERVAL_MS
+        this.pongTimeoutMs = options.pongTimeoutMs ?? WebSocketConnection.DEFAULT_PONG_TIMEOUT_MS
     }
 
     get state(): ConnectionState {
@@ -64,9 +78,11 @@ export class WebSocketConnection {
                 ) {
                     this.ws.send(this.sendQueue.shift()!)
                 }
+                this.startHeartbeat()
             }
 
             this.ws.onmessage = (event) => {
+                this.resetStaleTimer()
                 try {
                     const message = JSON.parse(event.data) as ServerMessage
                     this.onMessage(message)
@@ -77,6 +93,7 @@ export class WebSocketConnection {
             }
 
             this.ws.onclose = () => {
+                this.stopHeartbeat()
                 this.ws = null
                 this.sendQueue.length = 0
 
@@ -104,7 +121,7 @@ export class WebSocketConnection {
         }
 
         const delay = Math.min(
-            WebSocketConnection.MIN_RECONNECT_DELAY *
+            this.minReconnectDelay *
                 WebSocketConnection.RECONNECT_MULTIPLIER ** this.reconnectAttempts,
             WebSocketConnection.MAX_RECONNECT_DELAY
         )
@@ -126,6 +143,8 @@ export class WebSocketConnection {
             this.reconnectTimeout = null
         }
 
+        this.stopHeartbeat()
+
         if (this.ws) {
             this.ws.close()
             this.ws = null
@@ -135,6 +154,35 @@ export class WebSocketConnection {
         this.setState('disconnected')
     }
 
+    private startHeartbeat() {
+        this.stopHeartbeat()
+        this.resetStaleTimer()
+        this.pingTimer = setInterval(() => {
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({type: 'ping'}))
+            }
+        }, this.pingIntervalMs)
+    }
+
+    private stopHeartbeat() {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer)
+            this.pingTimer = null
+        }
+        if (this.staleTimer) {
+            clearTimeout(this.staleTimer)
+            this.staleTimer = null
+        }
+    }
+
+    private resetStaleTimer() {
+        if (this.staleTimer) clearTimeout(this.staleTimer)
+        this.staleTimer = setTimeout(() => {
+            debug('No frames within ping interval + pong timeout — forcing reconnect')
+            if (this.ws) this.ws.close()
+        }, this.pingIntervalMs + this.pongTimeoutMs)
+    }
+
     close() {
         this.disconnect()
     }

package/src/subscriptions/manager.ts

@@ -1,4 +1,4 @@
-import {WebSocketConnection} from './connection'
+import {WebSocketConnection, type ConnectionState} from './connection'
 import type {
     BoundingBox,
     BoundsDeltaMessage,
@@ -16,12 +16,16 @@ import {mapEntity, parseWireEntity} from './mappers'
 import type {Ship} from '../entities/ship'
 import type {Warehouse} from '../entities/warehouse'
 import type {Container} from '../entities/container'
+import type {Nexus} from '../entities/nexus'
 
-export type SubscriptionEntityType = 'ship' | 'warehouse' | 'container'
-export type EntityInstance = Ship | Warehouse | Container
+export type SubscriptionEntityType = 'ship' | 'warehouse' | 'container' | 'nexus'
+export type EntityInstance = Ship | Warehouse | Container | Nexus
 
 export interface SubscriptionsOptions {
     url: string
+    minReconnectDelay?: number
+    pingIntervalMs?: number
+    pongTimeoutMs?: number
 }
 
 export interface BoundsSubscriptionHandle {
@@ -31,6 +35,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
@@ -53,18 +63,26 @@ export class SubscriptionsManager {
     private readonly boundsSubs = new Map<
         string,
         {
+            bounds?: BoundingBox
+            owner?: string
+            prioritizeOwner?: string
             onSnapshot?: (entities: EntityInstance[]) => void
             onUpdate?: (entity: EntityInstance) => void
             onBoundsDelta?: (entered: EntityInstance[], exited: number[]) => void
-            handle: BoundsSubscriptionHandle
+            handle: BoundsSubscriptionHandle | OwnerSubscriptionHandle
         }
     >()
     private subCounter = 0
+    private hasConnected = false
 
     constructor(opts: SubscriptionsOptions) {
         this.conn = new WebSocketConnection({
             url: opts.url,
             onMessage: (m) => this.onMessage(m),
+            onStateChange: (s) => this.onStateChange(s),
+            minReconnectDelay: opts.minReconnectDelay,
+            pingIntervalMs: opts.pingIntervalMs,
+            pongTimeoutMs: opts.pongTimeoutMs,
         })
         this.conn.connect()
     }
@@ -139,6 +157,9 @@ export class SubscriptionsManager {
             current: new Map(),
         }
         this.boundsSubs.set(subId, {
+            bounds,
+            owner: handlers.owner,
+            prioritizeOwner: handlers.prioritizeOwner,
             onSnapshot: handlers.onSnapshot,
             onUpdate: handlers.onUpdate,
             onBoundsDelta: handlers.onBoundsDelta,
@@ -148,16 +169,75 @@ 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})
     }
 
     private updateBounds(subId: string, bounds: BoundingBox) {
+        const entry = this.boundsSubs.get(subId)
+        if (entry) entry.bounds = bounds
         const msg: UpdateBoundsMessage = {type: 'update_bounds', sub_id: subId, bounds}
         this.sendMessage(msg)
     }
 
+    private onStateChange(state: ConnectionState) {
+        if (state !== 'connected') return
+        if (!this.hasConnected) {
+            this.hasConnected = true
+            return
+        }
+        for (const [subId, entry] of this.entitySubs) {
+            const msg: SubscribeEntityMessage = {
+                type: 'subscribe_entity',
+                sub_id: subId,
+                entity_type: entry.type,
+                entity_id: entry.id,
+            }
+            this.sendMessage(msg)
+        }
+        for (const [subId, entry] of this.boundsSubs) {
+            const msg: SubscribeMessage = {
+                type: 'subscribe',
+                sub_id: subId,
+                bounds: entry.bounds,
+                owner: entry.owner,
+                prioritize_owner: entry.prioritizeOwner,
+            }
+            this.sendMessage(msg)
+        }
+    }
+
     private onMessage(msg: ServerMessage) {
         switch (msg.type) {
             case 'snapshot':

package/src/subscriptions/mappers.ts

@@ -2,12 +2,16 @@ import {ServerContract} from '../contracts'
 import {Ship} from '../entities/ship'
 import {Warehouse} from '../entities/warehouse'
 import {Container} from '../entities/container'
+import {Nexus} from '../entities/nexus'
 import type {WireEntity} from './types'
 
-export function mapEntity(ei: ServerContract.Types.entity_info): Ship | Warehouse | Container {
+export function mapEntity(
+    ei: ServerContract.Types.entity_info
+): Ship | Warehouse | Container | Nexus {
     if (ei.type.equals('ship')) return new Ship(ei)
     if (ei.type.equals('warehouse')) return new Warehouse(ei)
     if (ei.type.equals('container')) return new Container(ei)
+    if (ei.type.equals('nexus')) return new Nexus(ei)
     throw new Error(`mapEntity: unknown entity type ${ei.type.toString()}`)
 }
 

package/src/subscriptions/types.ts

@@ -39,7 +39,7 @@ export type UnsubscribeMessage = {
 export type SubscribeEntityMessage = {
     type: 'subscribe_entity'
     sub_id: string
-    entity_type: 'ship' | 'warehouse' | 'container'
+    entity_type: 'ship' | 'warehouse' | 'container' | 'nexus'
     entity_id: string
 }
 
@@ -80,7 +80,7 @@ export type AckMessage = {
 
 export type WireEntity = Record<string, unknown> & {
     type: number
-    type_name: 'ship' | 'warehouse' | 'container'
+    type_name: 'ship' | 'warehouse' | 'container' | 'nexus'
     id: string | number
     owner: string
     coordinates: WireCoordinates

package/src/travel/travel.ts

@@ -28,6 +28,7 @@ import {
     type Distance,
     MAX_ORBITAL_ALTITUDE,
     MIN_ORBITAL_ALTITUDE,
+    MIN_TRANSFER_DISTANCE,
     PRECISION,
     type ShipLike,
     TaskType,
@@ -77,6 +78,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 +462,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]
 
@@ -490,7 +548,8 @@ export function calc_transfer_duration(
             : (source.location.z?.toNumber() ?? 0)
     const destZ =
         typeof dest.location.z === 'number' ? dest.location.z : (dest.location.z?.toNumber() ?? 0)
-    const distance = Math.abs(sourceZ - destZ)
+    const rawDistance = Math.abs(sourceZ - destZ)
+    const distance = rawDistance < MIN_TRANSFER_DISTANCE ? MIN_TRANSFER_DISTANCE : rawDistance
 
     const totalMass = cargoMass + totalLoaderMass
     const acceleration = calc_acceleration(totalThrust, totalMass)

package/src/types/entity-traits.ts

@@ -1,16 +1,67 @@
 import {Name} from '@wharfkit/antelope'
+import {
+    ITEM_CONTAINER_T1_PACKED,
+    ITEM_CONTAINER_T2_PACKED,
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_FACTORY_T1_PACKED,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_WAREHOUSE_T1_PACKED,
+} from '../data/item-ids'
 
 export const ENTITY_SHIP = Name.from('ship')
 export const ENTITY_WAREHOUSE = Name.from('warehouse')
+export const ENTITY_EXTRACTOR = Name.from('extractor')
+export const ENTITY_FACTORY = Name.from('factory')
 export const ENTITY_CONTAINER = Name.from('container')
+export const ENTITY_NEXUS = Name.from('nexus')
 
-export type EntityTypeName = 'ship' | 'warehouse' | 'container'
+export enum EntityClass {
+    OrbitalVessel = 0,
+    PlanetaryStructure = 1,
+}
+
+export function getEntityClass(entityType: Name | EntityTypeName): EntityClass {
+    const typeName = typeof entityType === 'string' ? entityType : entityType.toString()
+    switch (typeName) {
+        case 'ship':
+        case 'container':
+        case 'nexus':
+            return EntityClass.OrbitalVessel
+        case 'warehouse':
+        case 'extractor':
+        case 'factory':
+            return EntityClass.PlanetaryStructure
+        default:
+            throw new Error(`Entity type has no class: ${typeName}`)
+    }
+}
+
+export function getPackedEntityType(itemId: number): Name | null {
+    switch (itemId) {
+        case ITEM_SHIP_T1_PACKED:
+            return ENTITY_SHIP
+        case ITEM_CONTAINER_T1_PACKED:
+        case ITEM_CONTAINER_T2_PACKED:
+            return ENTITY_CONTAINER
+        case ITEM_WAREHOUSE_T1_PACKED:
+            return ENTITY_WAREHOUSE
+        case ITEM_EXTRACTOR_T1_PACKED:
+            return ENTITY_EXTRACTOR
+        case ITEM_FACTORY_T1_PACKED:
+            return ENTITY_FACTORY
+        default:
+            return null
+    }
+}
+
+export type EntityTypeName = 'ship' | 'warehouse' | 'extractor' | 'factory' | 'container' | 'nexus'
 
 export interface EntityTraits {
     typeName: Name
     isMovable: boolean
     hasEnergy: boolean
     hasLoaders: boolean
+    hasModules: boolean
     notFoundError: string
 }
 
@@ -19,6 +70,7 @@ export const shipTraits: EntityTraits = {
     isMovable: true,
     hasEnergy: true,
     hasLoaders: true,
+    hasModules: true,
 
     notFoundError: 'ship not found',
 }
@@ -28,19 +80,51 @@ export const warehouseTraits: EntityTraits = {
     isMovable: false,
     hasEnergy: false,
     hasLoaders: true,
+    hasModules: true,
 
     notFoundError: 'warehouse not found',
 }
 
+export const extractorTraits: EntityTraits = {
+    typeName: ENTITY_EXTRACTOR,
+    isMovable: false,
+    hasEnergy: true,
+    hasLoaders: false,
+    hasModules: true,
+
+    notFoundError: 'extractor not found',
+}
+
+export const factoryTraits: EntityTraits = {
+    typeName: ENTITY_FACTORY,
+    isMovable: false,
+    hasEnergy: true,
+    hasLoaders: false,
+    hasModules: true,
+
+    notFoundError: 'factory not found',
+}
+
 export const containerTraits: EntityTraits = {
     typeName: ENTITY_CONTAINER,
     isMovable: true,
     hasEnergy: false,
     hasLoaders: false,
+    hasModules: false,
 
     notFoundError: 'container not found',
 }
 
+export const nexusTraits: EntityTraits = {
+    typeName: ENTITY_NEXUS,
+    isMovable: false,
+    hasEnergy: false,
+    hasLoaders: false,
+    hasModules: false,
+
+    notFoundError: 'nexus not found',
+}
+
 export function getEntityTraits(entityType: Name | EntityTypeName): EntityTraits {
     const typeName = typeof entityType === 'string' ? entityType : entityType.toString()
 
@@ -49,8 +133,14 @@ export function getEntityTraits(entityType: Name | EntityTypeName): EntityTraits
             return shipTraits
         case 'warehouse':
             return warehouseTraits
+        case 'extractor':
+            return extractorTraits
+        case 'factory':
+            return factoryTraits
         case 'container':
             return containerTraits
+        case 'nexus':
+            return nexusTraits
         default:
             throw new Error(`Unknown entity type: ${typeName}`)
     }
@@ -64,6 +154,18 @@ export function isWarehouse(entity: {type?: Name}): boolean {
     return entity.type?.equals(ENTITY_WAREHOUSE) ?? false
 }
 
+export function isExtractor(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_EXTRACTOR) ?? false
+}
+
+export function isFactory(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_FACTORY) ?? false
+}
+
 export function isContainer(entity: {type?: Name}): boolean {
     return entity.type?.equals(ENTITY_CONTAINER) ?? false
 }
+
+export function isNexus(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_NEXUS) ?? false
+}

package/src/types.ts

@@ -12,7 +12,7 @@ import {ServerContract} from './contracts'
 export const PRECISION = 10000
 export const CRAFT_ENERGY_DIVISOR = 150000
 
-export const WAREHOUSE_Z = 500
+export const PLANETARY_STRUCTURE_Z = 0
 
 export const CONTAINER_Z = 300
 
@@ -23,6 +23,8 @@ export const MAX_ORBITAL_ALTITUDE = 3000
 
 export const BASE_ORBITAL_MASS = 100000
 
+export const MIN_TRANSFER_DISTANCE = 100
+
 export interface ShipLike {
     coordinates: ServerContract.Types.coordinates
     hullmass?: UInt32
@@ -51,6 +53,9 @@ export enum TaskType {
     DEPLOY = 8,
     WRAP = 9,
     UNWRAP = 10,
+    UNDEPLOY = 11,
+    WRAP_ENTITY = 12,
+    DEMOLISH = 13,
 }
 
 export enum LocationType {
@@ -58,6 +63,7 @@ export enum LocationType {
     PLANET = 1,
     ASTEROID = 2,
     NEBULA = 3,
+    ICE_FIELD = 4,
 }
 
 export enum TaskCancelable {
@@ -159,3 +165,7 @@ export interface Item {
 export function formatTier(tier: number): string {
     return 'T' + tier
 }
+
+export function tierAdjective(tier: number): string {
+    return TIER_ADJECTIVES[tier] ?? `T${tier}`
+}

package/src/utils/cargo.ts

@@ -0,0 +1,27 @@
+import type {ServerContract} from '../contracts'
+
+export function cargoRef(src: {
+    item_id: number
+    stats: bigint | number
+    modules?: ServerContract.Types.module_entry[]
+}): ServerContract.ActionParams.Type.cargo_ref {
+    return {
+        item_id: src.item_id,
+        stats: src.stats,
+        modules: src.modules ?? [],
+    }
+}
+
+export function cargoItem(
+    src: {
+        item_id: number
+        stats: bigint | number
+        modules?: ServerContract.Types.module_entry[]
+    },
+    quantity: bigint | number
+): ServerContract.ActionParams.Type.cargo_item {
+    return {
+        ...cargoRef(src),
+        quantity,
+    }
+}