@shipload/sdk 2.0.0-rc2 → 2.0.0-rc21

package/src/scheduling/projection.ts

@@ -8,28 +8,44 @@ import {
     EntityCapabilities,
     EntityState,
 } from '../types/capabilities'
+import {
+    ENTITY_CAPACITY_EXCEEDED,
+    RECIPE_INPUTS_EXCESS,
+    RECIPE_INPUTS_INSUFFICIENT,
+    RECIPE_INPUTS_INVALID,
+    RECIPE_NOT_FOUND,
+    SHIP_CARGO_NOT_LOADED,
+} from '../errors'
+import {getRecipe, RecipeInput} from '../data/recipes-runtime'
+import {getItem} from '../market/items'
 import {distanceBetweenCoordinates, lerp} from '../travel/travel'
-import {calcCargoMass} from '../capabilities/storage'
-import {getGood} from '../market/goods'
+import {
+    calcStacksMass,
+    cargoItemToStack,
+    CargoStack,
+    mergeStacks,
+    removeFromStacks,
+    stackToCargoItem,
+} from '../capabilities/storage'
 import * as schedule from './schedule'
 import {ScheduleData} from './schedule'
 
 export interface ProjectedEntity {
     location: Coordinates
     energy: UInt16
-    cargoMass: UInt64
+    cargo: CargoStack[]
     shipMass: UInt32
     capacity?: UInt64
     engines?: ServerContract.Types.movement_stats
     loaders?: ServerContract.Types.loader_stats
     generator?: ServerContract.Types.energy_stats
-    trade?: ServerContract.Types.trade_stats
+    hauler?: ServerContract.Types.hauler_stats
+    readonly cargoMass: UInt64
     readonly totalMass: UInt64
 
     hasMovement(): boolean
     hasStorage(): boolean
     hasLoaders(): boolean
-    hasTrade(): boolean
 
     capabilities(): EntityCapabilities
     state(): EntityState
@@ -42,7 +58,7 @@ export interface Projectable extends ScheduleData {
     generator?: ServerContract.Types.energy_stats
     engines?: ServerContract.Types.movement_stats
     loaders?: ServerContract.Types.loader_stats
-    trade?: ServerContract.Types.trade_stats
+    hauler?: ServerContract.Types.hauler_stats
     capacity?: UInt32
     cargo: ServerContract.Types.cargo_item[]
     cargomass: UInt32
@@ -54,24 +70,29 @@ function getHullMass(entity: Projectable): UInt32 {
 }
 
 export function createProjectedEntity(entity: Projectable): ProjectedEntity {
-    const cargoMass = calcCargoMass(entity)
     const shipMass = getHullMass(entity)
     const loaders = entity.loaders
     const engines = entity.engines
     const generator = entity.generator
-    const trade = entity.trade
+    const hauler = entity.hauler
     const capacity = entity.capacity
 
+    const cargo: CargoStack[] = entity.cargo.map(cargoItemToStack)
+
     const projected: ProjectedEntity = {
         location: Coordinates.from(entity.coordinates),
         energy: UInt16.from(entity.energy ?? 0),
-        cargoMass,
+        cargo,
         shipMass,
         capacity: capacity ? UInt64.from(capacity) : undefined,
         engines,
         generator,
+        hauler,
         loaders,
-        trade,
+
+        get cargoMass() {
+            return calcStacksMass(this.cargo)
+        },
 
         get totalMass() {
             let mass = UInt64.from(this.shipMass).adding(this.cargoMass)
@@ -93,10 +114,6 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
             return capsHasLoaders(this.capabilities())
         },
 
-        hasTrade() {
-            return this.trade !== undefined
-        },
-
         capabilities(): EntityCapabilities {
             return {
                 hullmass: this.shipMass,
@@ -104,7 +121,6 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
                 engines: this.engines,
                 generator: this.generator,
                 loaders: this.loaders,
-                trade: this.trade,
             }
         },
 
@@ -114,7 +130,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
                 location: ServerContract.Types.coordinates.from(this.location),
                 energy: this.energy,
                 cargomass: UInt32.from(this.cargoMass),
-                cargo: entity.cargo,
+                cargo: this.cargo.map(stackToCargoItem),
             }
         },
     }
@@ -169,76 +185,191 @@ function applyFlightTask(
     }
 }
 
-function getGoodMass(good_id: UInt16 | number): UInt32 {
-    const good = getGood(good_id)
-    return good.mass
+function addCargoItem(projected: ProjectedEntity, item: ServerContract.Types.cargo_item): void {
+    projected.cargo = mergeStacks(projected.cargo, cargoItemToStack(item))
+}
+
+function removeCargoItem(projected: ProjectedEntity, item: ServerContract.Types.cargo_item): void {
+    projected.cargo = removeFromStacks(projected.cargo, cargoItemToStack(item))
 }
 
-function applyLoadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+function applyAddCargoTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     for (const item of task.cargo) {
-        const good_mass = getGoodMass(item.good_id)
-        projected.cargoMass = projected.cargoMass.adding(good_mass.multiplying(item.quantity))
+        addCargoItem(projected, item)
     }
 }
 
-function applyUnloadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+function applyRemoveCargoTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     for (const item of task.cargo) {
-        const good_mass = getGoodMass(item.good_id)
-        const cargoMass = good_mass.multiplying(item.quantity)
-        projected.cargoMass = projected.cargoMass.gt(cargoMass)
-            ? projected.cargoMass.subtracting(cargoMass)
-            : UInt64.from(0)
+        removeCargoItem(projected, item)
     }
 }
 
-function applyExtractTask(
+function applyEnergyCost(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    if (!task.energy_cost) return
+    const energyCost = UInt16.from(task.energy_cost)
+    projected.energy = projected.energy.gt(energyCost)
+        ? UInt16.from(projected.energy.subtracting(energyCost))
+        : UInt16.from(0)
+}
+
+function applyGatherTask(
     projected: ProjectedEntity,
     task: ServerContract.Types.task,
     options: {complete: boolean}
 ): void {
     if (!options.complete) return
+    applyEnergyCost(projected, task)
+    if (!task.entitytarget) {
+        applyAddCargoTask(projected, task)
+    }
+}
 
-    if (task.energy_cost) {
-        const energyCost = UInt16.from(task.energy_cost)
-        projected.energy = projected.energy.gt(energyCost)
-            ? UInt16.from(projected.energy.subtracting(energyCost))
-            : UInt16.from(0)
+function applyCraftTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    applyEnergyCost(projected, task)
+    if (task.cargo.length === 0) return
+
+    for (let i = 0; i < task.cargo.length - 1; i++) {
+        removeCargoItem(projected, task.cargo[i])
     }
+    addCargoItem(projected, task.cargo[task.cargo.length - 1])
+}
 
-    for (const item of task.cargo) {
-        const good_mass = getGoodMass(item.good_id)
-        projected.cargoMass = projected.cargoMass.adding(good_mass.multiplying(item.quantity))
+function applyDeployTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    applyEnergyCost(projected, task)
+    if (task.cargo.length > 0) {
+        removeCargoItem(projected, task.cargo[0])
     }
 }
 
-export function projectEntity(entity: Projectable): ProjectedEntity {
+function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    switch (task.type.toNumber()) {
+        case TaskType.RECHARGE:
+            applyRechargeTask(projected, task, {complete: true})
+            break
+        case TaskType.TRAVEL:
+            applyFlightTask(projected, task, {complete: true})
+            break
+        case TaskType.LOAD:
+        case TaskType.UNWRAP:
+            applyAddCargoTask(projected, task)
+            break
+        case TaskType.UNLOAD:
+        case TaskType.WRAP:
+            applyRemoveCargoTask(projected, task)
+            break
+        case TaskType.GATHER:
+            applyGatherTask(projected, task, {complete: true})
+            break
+        case TaskType.CRAFT:
+            applyCraftTask(projected, task)
+            break
+        case TaskType.DEPLOY:
+            applyDeployTask(projected, task)
+            break
+    }
+}
+
+export interface ProjectionOptions {
+    upToTaskIndex?: number
+}
+
+export function projectEntity(entity: Projectable, options?: ProjectionOptions): ProjectedEntity {
     const projected = createProjectedEntity(entity)
+    if (!entity.schedule || entity.schedule.tasks.length === 0) return projected
 
-    if (!entity.schedule) {
-        return projected
+    const tasks = entity.schedule.tasks
+    const taskCount =
+        options?.upToTaskIndex !== undefined
+            ? Math.max(0, Math.min(options.upToTaskIndex, tasks.length))
+            : tasks.length
+
+    for (let i = 0; i < taskCount; i++) {
+        applyTask(projected, tasks[i])
     }
+    return projected
+}
 
-    for (const task of entity.schedule.tasks) {
-        switch (task.type.toNumber()) {
-            case TaskType.RECHARGE:
-                applyRechargeTask(projected, task, {complete: true})
-                break
-            case TaskType.TRAVEL:
-                applyFlightTask(projected, task, {complete: true})
-                break
-            case TaskType.LOAD:
-                applyLoadTask(projected, task)
-                break
-            case TaskType.UNLOAD:
-                applyUnloadTask(projected, task)
-                break
-            case TaskType.EXTRACT:
-                applyExtractTask(projected, task, {complete: true})
+function getRecipeInputsForOutput(outputItemId: number): RecipeInput[] | undefined {
+    const recipe = getRecipe(outputItemId)
+    return recipe?.inputs
+}
+
+function validateCraftTask(task: ServerContract.Types.task, projected: ProjectedEntity): void {
+    if (task.cargo.length === 0) return
+
+    const output = task.cargo[task.cargo.length - 1]
+    const inputs = task.cargo.slice(0, -1)
+    const craftQuantity = output.quantity.toNumber()
+
+    const recipe = getRecipeInputsForOutput(output.item_id.toNumber())
+    if (!recipe) throw new Error(RECIPE_NOT_FOUND)
+
+    const groupedInputs: ServerContract.Types.cargo_item[][] = recipe.map(() => [])
+    for (const input of inputs) {
+        let matched = false
+        for (let ri = 0; ri < recipe.length; ri++) {
+            const req = recipe[ri]
+            if ('itemId' in req) {
+                if (input.item_id.toNumber() === req.itemId) {
+                    groupedInputs[ri].push(input)
+                    matched = true
+                    break
+                }
+            } else {
+                const item = getItem(input.item_id)
+                if (item.category === req.category && item.tier === req.tier) {
+                    groupedInputs[ri].push(input)
+                    matched = true
+                    break
+                }
+            }
+        }
+        if (!matched) throw new Error(RECIPE_INPUTS_INVALID)
+    }
+
+    for (let ri = 0; ri < recipe.length; ri++) {
+        const stacks = groupedInputs[ri]
+        let provided = 0
+        for (const stack of stacks) {
+            provided += stack.quantity.toNumber()
+        }
+        const required = recipe[ri].quantity * craftQuantity
+        if (provided < required) throw new Error(RECIPE_INPUTS_INSUFFICIENT)
+        if (provided !== required) throw new Error(RECIPE_INPUTS_EXCESS)
+    }
+
+    for (const input of inputs) {
+        let found = false
+        for (const pc of projected.cargo) {
+            if (
+                pc.item_id.toNumber() === input.item_id.toNumber() &&
+                pc.stats.toString() === input.stats.toString()
+            ) {
+                if (pc.quantity.toNumber() < input.quantity.toNumber()) {
+                    throw new Error(RECIPE_INPUTS_INSUFFICIENT)
+                }
+                found = true
                 break
+            }
         }
+        if (!found) throw new Error(SHIP_CARGO_NOT_LOADED)
     }
+}
 
-    return projected
+export function validateSchedule(entity: Projectable): void {
+    if (!entity.schedule || entity.schedule.tasks.length === 0) return
+
+    const projected = createProjectedEntity(entity)
+    for (const task of entity.schedule.tasks) {
+        if (task.type.toNumber() === TaskType.CRAFT) {
+            validateCraftTask(task, projected)
+        }
+        applyTask(projected, task)
+        if (projected.capacity && projected.cargoMass.gt(projected.capacity)) {
+            throw new Error(ENTITY_CAPACITY_EXCEEDED)
+        }
+    }
 }
 
 export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity {
@@ -269,19 +400,21 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
                 applyFlightTask(projected, task, {complete: taskComplete, progress})
                 break
             case TaskType.LOAD:
-                if (taskComplete) {
-                    applyLoadTask(projected, task)
-                }
+            case TaskType.UNWRAP:
+                if (taskComplete) applyAddCargoTask(projected, task)
                 break
             case TaskType.UNLOAD:
-                if (taskComplete) {
-                    applyUnloadTask(projected, task)
-                }
+            case TaskType.WRAP:
+                if (taskComplete) applyRemoveCargoTask(projected, task)
                 break
-            case TaskType.EXTRACT:
-                if (taskComplete) {
-                    applyExtractTask(projected, task, {complete: true})
-                }
+            case TaskType.GATHER:
+                if (taskComplete) applyGatherTask(projected, task, {complete: true})
+                break
+            case TaskType.CRAFT:
+                if (taskComplete) applyCraftTask(projected, task)
+                break
+            case TaskType.DEPLOY:
+                if (taskComplete) applyDeployTask(projected, task)
                 break
         }
     }

package/src/scheduling/schedule.ts

@@ -174,6 +174,6 @@ export function isUnloading(entity: ScheduleData, now: Date): boolean {
     return isTaskType(entity, TaskType.UNLOAD, now)
 }
 
-export function isExtracting(entity: ScheduleData, now: Date): boolean {
-    return isTaskType(entity, TaskType.EXTRACT, now)
+export function isGathering(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.GATHER, now)
 }

package/src/shipload.ts

@@ -7,15 +7,16 @@ import {GameContext} from './managers/context'
 import {EntitiesManager} from './managers/entities'
 import {PlayersManager} from './managers/players'
 import {LocationsManager} from './managers/locations'
-import {TradesManager} from './managers/trades'
 import {EpochsManager} from './managers/epochs'
 import {ActionsManager} from './managers/actions'
+import {SubscriptionsManager} from './subscriptions/manager'
 import {GameState} from './entities/gamestate'
 
 interface ShiploadOptions {
     platformContractName?: string
     serverContractName?: string
     client?: APIClient
+    subscriptionsUrl?: string
 }
 
 interface ShiploadConstructorOptions extends ShiploadOptions {
@@ -39,6 +40,10 @@ export class Shipload {
             : new ServerContract.Contract({client: apiClient})
 
         this._context = new GameContext(apiClient, server, platform)
+
+        if (constructorOptions?.subscriptionsUrl) {
+            this._context.setSubscriptionsUrl(constructorOptions.subscriptionsUrl)
+        }
     }
 
     static async load(
@@ -94,10 +99,6 @@ export class Shipload {
         return this._context.locations
     }
 
-    get trades(): TradesManager {
-        return this._context.trades
-    }
-
     get epochs(): EpochsManager {
         return this._context.epochs
     }
@@ -106,6 +107,10 @@ export class Shipload {
         return this._context.actions
     }
 
+    get subscriptions(): SubscriptionsManager {
+        return this._context.subscriptions
+    }
+
     async getGame(reload = false): Promise<PlatformContract.Types.game_row> {
         return this._context.getGame(reload)
     }

package/src/subscriptions/connection.ts

@@ -0,0 +1,154 @@
+import type {ClientMessage, ServerMessage} from './types'
+import {debug} from './debug'
+
+export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting'
+
+export interface WebSocketConnectionOptions {
+    url: string
+    onMessage: (message: ServerMessage) => void
+    onStateChange?: (state: ConnectionState) => void
+}
+
+export class WebSocketConnection {
+    private ws: WebSocket | null = null
+    private url: string
+    private onMessage: (message: ServerMessage) => void
+    private onStateChange?: (state: ConnectionState) => void
+    private reconnectAttempts = 0
+    private reconnectTimeout: ReturnType<typeof setTimeout> | null = null
+    private _state: ConnectionState = 'disconnected'
+    private shouldReconnect = true
+    private sendQueue: string[] = []
+
+    private static readonly MIN_RECONNECT_DELAY = 1000
+    private static readonly MAX_RECONNECT_DELAY = 30000
+    private static readonly RECONNECT_MULTIPLIER = 2
+
+    constructor(options: WebSocketConnectionOptions) {
+        this.url = options.url
+        this.onMessage = options.onMessage
+        this.onStateChange = options.onStateChange
+    }
+
+    get state(): ConnectionState {
+        return this._state
+    }
+
+    private setState(state: ConnectionState) {
+        if (this._state !== state) {
+            this._state = state
+            this.onStateChange?.(state)
+        }
+    }
+
+    connect() {
+        if (this.ws) {
+            return
+        }
+
+        this.shouldReconnect = true
+        this.setState('connecting')
+        debug('Connecting to', this.url)
+
+        try {
+            this.ws = new WebSocket(this.url)
+
+            this.ws.onopen = () => {
+                debug('Connected')
+                this.reconnectAttempts = 0
+                this.setState('connected')
+                while (
+                    this.sendQueue.length > 0 &&
+                    this.ws &&
+                    this.ws.readyState === WebSocket.OPEN
+                ) {
+                    this.ws.send(this.sendQueue.shift()!)
+                }
+            }
+
+            this.ws.onmessage = (event) => {
+                try {
+                    const message = JSON.parse(event.data) as ServerMessage
+                    this.onMessage(message)
+                } catch (e) {
+                    // eslint-disable-next-line no-console
+                    console.error('[WS] Failed to parse message:', e)
+                }
+            }
+
+            this.ws.onclose = () => {
+                this.ws = null
+                this.sendQueue.length = 0
+
+                if (this.shouldReconnect) {
+                    this.setState('reconnecting')
+                    this.scheduleReconnect()
+                } else {
+                    this.setState('disconnected')
+                }
+            }
+        } catch (e) {
+            // eslint-disable-next-line no-console
+            console.error('[WS] Failed to create connection:', e)
+            this.ws = null
+            if (this.shouldReconnect) {
+                this.setState('reconnecting')
+                this.scheduleReconnect()
+            }
+        }
+    }
+
+    private scheduleReconnect() {
+        if (this.reconnectTimeout) {
+            return
+        }
+
+        const delay = Math.min(
+            WebSocketConnection.MIN_RECONNECT_DELAY *
+                Math.pow(WebSocketConnection.RECONNECT_MULTIPLIER, this.reconnectAttempts),
+            WebSocketConnection.MAX_RECONNECT_DELAY
+        )
+
+        debug(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts + 1})`)
+
+        this.reconnectTimeout = setTimeout(() => {
+            this.reconnectTimeout = null
+            this.reconnectAttempts++
+            this.connect()
+        }, delay)
+    }
+
+    disconnect() {
+        this.shouldReconnect = false
+
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout)
+            this.reconnectTimeout = null
+        }
+
+        if (this.ws) {
+            this.ws.close()
+            this.ws = null
+        }
+
+        this.sendQueue.length = 0
+        this.setState('disconnected')
+    }
+
+    close() {
+        this.disconnect()
+    }
+
+    send(message: ClientMessage) {
+        const data = JSON.stringify(message)
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(data)
+            return
+        }
+        this.sendQueue.push(data)
+    }
+
+    get isConnected(): boolean {
+        return this._state === 'connected'
+    }
+}

package/src/subscriptions/debug.ts

@@ -0,0 +1,17 @@
+/* eslint-disable no-console */
+
+let enabled = false
+
+export function setSubscriptionsDebug(on: boolean): void {
+    enabled = on
+}
+
+export function isSubscriptionsDebugEnabled(): boolean {
+    return enabled
+}
+
+export function debug(...args: unknown[]): void {
+    if (enabled) {
+        console.log('[WS]', ...args)
+    }
+}

package/src/subscriptions/index.ts

@@ -0,0 +1,5 @@
+export * from './connection'
+export * from './types'
+export * from './manager'
+export * from './mappers'
+export {setSubscriptionsDebug, isSubscriptionsDebugEnabled} from './debug'