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

package/src/resolution/resolve-item.ts

@@ -39,6 +39,7 @@ import type {ServerContract} from '../contracts'
 import {
     ITEM_CONTAINER_T1_PACKED,
     ITEM_CONTAINER_T2_PACKED,
+    ITEM_EXTRACTOR_T1_PACKED,
     ITEM_SHIP_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
 } from '../data/item-ids'
@@ -155,7 +156,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 +181,7 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_GATHERER: {
-            const caps = computeGathererCapabilities(stats)
+            const caps = computeGathererCapabilities(stats, tier)
             return {
                 capability: 'Gatherer',
                 attributes: [
@@ -223,10 +225,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 +244,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 {
@@ -268,6 +271,8 @@ function hullCapsForEntity(
             return computeShipHullCapabilities(decoded)
         case ITEM_WAREHOUSE_T1_PACKED:
             return computeWarehouseHullCapabilities(decoded)
+        case ITEM_EXTRACTOR_T1_PACKED:
+            return computeShipHullCapabilities(decoded)
         case ITEM_CONTAINER_T1_PACKED:
             return computeContainerCapabilities(decoded)
         case ITEM_CONTAINER_T2_PACKED:
@@ -310,13 +315,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/scheduling/task-cargo.ts

@@ -0,0 +1,47 @@
+import type {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+
+export type TaskCargoDirection = 'in' | 'out'
+
+export interface TaskCargoChange {
+    direction: TaskCargoDirection
+    item_id: number
+    stats: bigint
+    modules: ServerContract.Types.module_entry[]
+    quantity: number
+}
+
+function toChange(
+    item: ServerContract.Types.cargo_item,
+    direction: TaskCargoDirection
+): TaskCargoChange {
+    return {
+        direction,
+        item_id: Number(item.item_id),
+        stats: BigInt(item.stats.toString()),
+        modules: item.modules ?? [],
+        quantity: Number(item.quantity),
+    }
+}
+
+export function taskCargoChanges(task: ServerContract.Types.task): TaskCargoChange[] {
+    const items = task.cargo ?? []
+    if (items.length === 0) return []
+    switch (Number(task.type)) {
+        case TaskType.LOAD:
+        case TaskType.UNWRAP:
+            return items.map((i) => toChange(i, 'in'))
+        case TaskType.GATHER:
+            return task.entitytarget ? [] : items.map((i) => toChange(i, 'in'))
+        case TaskType.UNLOAD:
+        case TaskType.WRAP:
+            return items.map((i) => toChange(i, 'out'))
+        case TaskType.CRAFT:
+            return [
+                ...items.slice(0, -1).map((i) => toChange(i, 'out')),
+                toChange(items[items.length - 1], 'in'),
+            ]
+        default:
+            return []
+    }
+}

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,
@@ -22,6 +22,9 @@ export type EntityInstance = Ship | Warehouse | Container
 
 export interface SubscriptionsOptions {
     url: string
+    minReconnectDelay?: number
+    pingIntervalMs?: number
+    pongTimeoutMs?: number
 }
 
 export interface BoundsSubscriptionHandle {
@@ -31,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
@@ -53,18 +62,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 +156,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 +168,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/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,60 @@
 import {Name} from '@wharfkit/antelope'
+import {
+    ITEM_CONTAINER_T1_PACKED,
+    ITEM_CONTAINER_T2_PACKED,
+    ITEM_EXTRACTOR_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_CONTAINER = Name.from('container')
 
-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':
+            return EntityClass.OrbitalVessel
+        case 'warehouse':
+        case 'extractor':
+            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
+        default:
+            return null
+    }
+}
+
+export type EntityTypeName = 'ship' | 'warehouse' | 'extractor' | 'container'
 
 export interface EntityTraits {
     typeName: Name
     isMovable: boolean
     hasEnergy: boolean
     hasLoaders: boolean
+    hasModules: boolean
     notFoundError: string
 }
 
@@ -19,6 +63,7 @@ export const shipTraits: EntityTraits = {
     isMovable: true,
     hasEnergy: true,
     hasLoaders: true,
+    hasModules: true,
 
     notFoundError: 'ship not found',
 }
@@ -28,15 +73,27 @@ 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 containerTraits: EntityTraits = {
     typeName: ENTITY_CONTAINER,
     isMovable: true,
     hasEnergy: false,
     hasLoaders: false,
+    hasModules: false,
 
     notFoundError: 'container not found',
 }
@@ -49,6 +106,8 @@ export function getEntityTraits(entityType: Name | EntityTypeName): EntityTraits
             return shipTraits
         case 'warehouse':
             return warehouseTraits
+        case 'extractor':
+            return extractorTraits
         case 'container':
             return containerTraits
         default:
@@ -64,6 +123,10 @@ 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 isContainer(entity: {type?: Name}): boolean {
     return entity.type?.equals(ENTITY_CONTAINER) ?? 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}`
+}