@shipload/sdk 1.0.0-next.7 → 1.0.0-next.8

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "1.0.0-next.7",
+    "version": "1.0.0-next.8",
     "homepage": "https://github.com/shipload/toolkit/tree/master/packages/sdk",
     "repository": {
         "type": "git",

package/src/index-module.ts

@@ -71,6 +71,7 @@ export {
     getLocationType,
     getLocationTypeName,
     isGatherableLocation,
+    isLocationBuildable,
     deriveLocationStatic,
     deriveLocation,
 } from './utils/system'
@@ -179,8 +180,16 @@ export type {
     ProjectionOptions,
 } from './scheduling/projection'
 
+export {predictTaskCargoEffects} from './scheduling/predict-cargo'
+export type {
+    PredictedCargoAddition,
+    PredictedCargoTarget,
+    TaskCargoEffect,
+} from './scheduling/predict-cargo'
+
 export * from './types/capabilities'
 export * from './types/entity'
+export {EntityClass, getEntityClass, getPackedEntityType} from './types/entity-traits'
 export * from './capabilities'
 
 export {

package/src/scheduling/predict-cargo.ts

@@ -0,0 +1,151 @@
+import type {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+
+export type PredictedCargoTarget = {kind: 'existing'; rowId: bigint} | {kind: 'new'; label: string}
+
+export interface PredictedCargoAddition {
+    item_id: number
+    stats: bigint
+    modules: ServerContract.Types.module_entry[]
+    quantity: number
+    target: PredictedCargoTarget
+}
+
+export interface TaskCargoEffect {
+    additions: PredictedCargoAddition[]
+}
+
+interface StackState {
+    item_id: number
+    stats: bigint
+    modules: ServerContract.Types.module_entry[]
+    quantity: number
+    target: PredictedCargoTarget
+}
+
+function modulesEqual(
+    a: ServerContract.Types.module_entry[],
+    b: ServerContract.Types.module_entry[]
+): boolean {
+    if (a.length !== b.length) return false
+    for (let i = 0; i < a.length; i++) {
+        const ai = a[i]
+        const bi = b[i]
+        if (Number(ai.type) !== Number(bi.type)) return false
+        const aInst = ai.installed
+        const bInst = bi.installed
+        if (!aInst && !bInst) continue
+        if (!aInst || !bInst) return false
+        if (Number(aInst.item_id) !== Number(bInst.item_id)) return false
+        if (BigInt(aInst.stats.toString()) !== BigInt(bInst.stats.toString())) return false
+    }
+    return true
+}
+
+function findStack(
+    state: StackState[],
+    item_id: number,
+    stats: bigint,
+    modules: ServerContract.Types.module_entry[]
+): number {
+    for (let i = 0; i < state.length; i++) {
+        const s = state[i]
+        if (s.item_id !== item_id) continue
+        if (s.stats !== stats) continue
+        if (!modulesEqual(s.modules, modules)) continue
+        return i
+    }
+    return -1
+}
+
+function applyAddition(
+    state: StackState[],
+    item: ServerContract.Types.cargo_item,
+    nextNewLabel: () => string
+): PredictedCargoAddition {
+    const item_id = Number(item.item_id)
+    const stats = BigInt(item.stats.toString())
+    const modules = item.modules ?? []
+    const quantity = Number(item.quantity)
+
+    const idx = findStack(state, item_id, stats, modules)
+    if (idx === -1) {
+        const target: PredictedCargoTarget = {kind: 'new', label: nextNewLabel()}
+        state.push({item_id, stats, modules, quantity, target})
+        return {item_id, stats, modules, quantity, target}
+    }
+    state[idx].quantity += quantity
+    return {item_id, stats, modules, quantity, target: state[idx].target}
+}
+
+function applyRemoval(state: StackState[], item: ServerContract.Types.cargo_item): void {
+    const item_id = Number(item.item_id)
+    const stats = BigInt(item.stats.toString())
+    const modules = item.modules ?? []
+    const quantity = Number(item.quantity)
+
+    const idx = findStack(state, item_id, stats, modules)
+    if (idx === -1) return
+    state[idx].quantity -= quantity
+    if (state[idx].quantity <= 0) state.splice(idx, 1)
+}
+
+export function predictTaskCargoEffects(
+    cargo: readonly ServerContract.Types.cargo_view[],
+    tasks: readonly ServerContract.Types.task[]
+): TaskCargoEffect[] {
+    const state: StackState[] = cargo.map((c) => ({
+        item_id: Number(c.item_id),
+        stats: BigInt(c.stats.toString()),
+        modules: c.modules ?? [],
+        quantity: Number(c.quantity),
+        target: {kind: 'existing', rowId: BigInt(c.id.toString())},
+    }))
+
+    let newCounter = 0
+    const nextNewLabel = () => {
+        newCounter += 1
+        return `new#${newCounter}`
+    }
+
+    const effects: TaskCargoEffect[] = []
+
+    for (const task of tasks) {
+        const type = Number(task.type)
+        const items = task.cargo ?? []
+        const additions: PredictedCargoAddition[] = []
+
+        switch (type) {
+            case TaskType.LOAD:
+            case TaskType.UNWRAP: {
+                for (const item of items) additions.push(applyAddition(state, item, nextNewLabel))
+                break
+            }
+            case TaskType.GATHER: {
+                if (!task.entitytarget) {
+                    for (const item of items)
+                        additions.push(applyAddition(state, item, nextNewLabel))
+                }
+                break
+            }
+            case TaskType.UNLOAD:
+            case TaskType.WRAP: {
+                for (const item of items) applyRemoval(state, item)
+                break
+            }
+            case TaskType.CRAFT: {
+                if (items.length > 0) {
+                    for (let i = 0; i < items.length - 1; i++) applyRemoval(state, items[i])
+                    additions.push(applyAddition(state, items[items.length - 1], nextNewLabel))
+                }
+                break
+            }
+            default:
+                break
+        }
+
+        effects.push({additions})
+    }
+
+    return effects
+}

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,
@@ -547,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,9 +1,47 @@
 import {Name} from '@wharfkit/antelope'
+import {
+    ITEM_CONTAINER_T1_PACKED,
+    ITEM_CONTAINER_T2_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_CONTAINER = Name.from('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':
+            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
+        default:
+            return null
+    }
+}
+
 export type EntityTypeName = 'ship' | 'warehouse' | 'container'
 
 export interface EntityTraits {

package/src/types.ts

@@ -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

package/src/utils/system.ts

@@ -150,6 +150,13 @@ export function deriveLocationStatic(
     return loc
 }
 
+export function isLocationBuildable(
+    gameSeed: Checksum256Type,
+    coordinates: CoordinatesType
+): boolean {
+    return getLocationType(gameSeed, coordinates) === LocationType.PLANET
+}
+
 export function deriveLocation(
     gameSeed: Checksum256Type,
     coordinates: CoordinatesType