@shipload/sdk 1.0.0-next.6 → 1.0.0-next.60

package/src/types.ts

@@ -1,35 +1,47 @@
 import {
     type Int64Type,
-    Name,
     type UInt16,
     type UInt16Type,
     type UInt32,
     type UInt32Type,
     UInt64,
+    type UInt64Type,
 } from '@wharfkit/antelope'
 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
 
 export const TRAVEL_MAX_DURATION = 86400
 
+export const BASE_HAUL_PENALTY_MILLI = 300
+export const HAULER_EFFICIENCY_DENOM = 10000
+
 export const MIN_ORBITAL_ALTITUDE = 800
 export const MAX_ORBITAL_ALTITUDE = 3000
 
 export const BASE_ORBITAL_MASS = 100000
 
+export const MIN_TRANSFER_DISTANCE_PLANETARY_STRUCTURE = 100
+export const MIN_TRANSFER_DISTANCE_ORBITAL_VESSEL = 200
+
+export interface ClusterSlotType {
+    hub: UInt64Type
+    gx: number
+    gy: number
+}
+
 export interface ShipLike {
     coordinates: ServerContract.Types.coordinates
     hullmass?: UInt32
-    energy?: UInt16
+    energy?: UInt32
     engines?: ServerContract.Types.movement_stats
     generator?: ServerContract.Types.energy_stats
-    loaders?: ServerContract.Types.loader_stats
+    loader_lanes?: ServerContract.Types.loader_lane[]
     hauler?: ServerContract.Types.hauler_stats
     capacity?: UInt32
 }
@@ -48,12 +60,32 @@ export enum TaskType {
     GATHER = 5,
     WARP = 6,
     CRAFT = 7,
-    DEPLOY = 8,
-    WRAP = 9,
+    TRANSIT = 9,
     UNWRAP = 10,
     UNDEPLOY = 11,
-    WRAP_ENTITY = 12,
+    LAUNCH = 12,
     DEMOLISH = 13,
+    BUILDPLOT = 15,
+    CHARGE = 16,
+    UPGRADE = 17,
+    SHUTTLE = 18,
+    REFIT = 19,
+}
+
+export enum RefitOp {
+    ADD = 0,
+    REMOVE = 1,
+    SWAP = 2,
+}
+
+export enum HoldKind {
+    PULL = 1,
+    PUSH = 2,
+    GATHER = 3,
+    BUILD = 4,
+    FLIGHT = 5,
+    UPGRADE = 6,
+    SOURCE = 7,
 }
 
 export enum LocationType {
@@ -70,14 +102,6 @@ export enum TaskCancelable {
     ALWAYS = 2,
 }
 
-export const EntityType = {
-    SHIP: Name.from('ship'),
-    WAREHOUSE: Name.from('warehouse'),
-    CONTAINER: Name.from('container'),
-} as const
-
-export type EntityTypeName = (typeof EntityType)[keyof typeof EntityType]
-
 export type CoordinatesType =
     | Coordinates
     | ServerContract.Types.coordinates
@@ -123,11 +147,15 @@ export type ModuleType =
     | 'loader'
     | 'warp'
     | 'crafter'
+    | 'builder'
     | 'launcher'
     | 'storage'
     | 'hauler'
+    | 'battery'
+    | 'catcher'
+    | 'aux'
 
-export const TIER_ADJECTIVES: Record<number, string> = {
+export const RESOURCE_TIER_ADJECTIVES: Record<number, string> = {
     1: 'Crude',
     2: 'Dense',
     3: 'Pure',
@@ -140,6 +168,9 @@ export const TIER_ADJECTIVES: Record<number, string> = {
     10: 'Ascendant',
 }
 
+export const COMPONENT_TIER_PREFIXES: Record<number, string> = {}
+export const MODULE_TIER_PREFIXES: Record<number, string> = {}
+
 export const CATEGORY_LABELS: Record<ResourceCategory, string> = {
     ore: 'Ore',
     crystal: 'Crystal',
@@ -163,3 +194,7 @@ export interface Item {
 export function formatTier(tier: number): string {
     return 'T' + tier
 }
+
+export function tierAdjective(tier: number): string {
+    return RESOURCE_TIER_ADJECTIVES[tier] ?? `T${tier}`
+}

package/src/utils/cargo.test.ts

@@ -0,0 +1,14 @@
+import {describe, expect, test} from 'bun:test'
+import {cargoRef} from './cargo'
+
+describe('cargoRef', () => {
+    test('forwards entity_id when provided', () => {
+        const ref = cargoRef({item_id: 10201, stats: 196849n, modules: [], entity_id: 42n})
+        expect(ref.entity_id).toBe(42n)
+    })
+
+    test('omits entity_id when absent', () => {
+        const ref = cargoRef({item_id: 10201, stats: 196849n})
+        expect(ref.entity_id).toBeUndefined()
+    })
+})

package/src/utils/cargo.ts

@@ -0,0 +1,29 @@
+import type {ServerContract} from '../contracts'
+
+export function cargoRef(src: {
+    item_id: number
+    stats: bigint | number
+    modules?: ServerContract.Types.module_entry[]
+    entity_id?: bigint | number
+}): ServerContract.ActionParams.Type.cargo_ref {
+    return {
+        item_id: src.item_id,
+        stats: src.stats,
+        modules: src.modules ?? [],
+        entity_id: src.entity_id,
+    }
+}
+
+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,
+    }
+}

package/src/utils/display-name.ts

@@ -0,0 +1,70 @@
+export interface DisplayNameResult {
+    valid: boolean
+    reason?: string
+    name: string
+}
+
+const MAX_DISPLAY_NAME_BYTES = 32
+const ASCII_SPACE = 0x20
+const ZERO_WIDTH_CODE_POINTS = new Set([0x200b, 0x200c, 0x200d, 0x2060, 0xfeff])
+const textEncoder = new TextEncoder()
+
+function isControlCharacter(codePoint: number): boolean {
+    return codePoint <= 0x1f || codePoint === 0x7f || (codePoint >= 0x80 && codePoint <= 0x9f)
+}
+
+function isLoneSurrogate(codePoint: number): boolean {
+    return codePoint >= 0xd800 && codePoint <= 0xdfff
+}
+
+function isBidiControl(codePoint: number): boolean {
+    return (
+        (codePoint >= 0x202a && codePoint <= 0x202e) || (codePoint >= 0x2066 && codePoint <= 0x2069)
+    )
+}
+
+function isInvalidDisplayNameCodePoint(codePoint: number): boolean {
+    return (
+        isControlCharacter(codePoint) ||
+        isLoneSurrogate(codePoint) ||
+        ZERO_WIDTH_CODE_POINTS.has(codePoint) ||
+        isBidiControl(codePoint)
+    )
+}
+
+export function normalizeDisplayName(input: string): string {
+    let start = 0
+    let end = input.length
+
+    while (start < end && input.charCodeAt(start) === ASCII_SPACE) start++
+    while (end > start && input.charCodeAt(end - 1) === ASCII_SPACE) end--
+
+    return input.slice(start, end)
+}
+
+export interface ValidateDisplayNameOptions {
+    allowEmpty?: boolean
+}
+
+export function validateDisplayName(
+    input: string,
+    opts: ValidateDisplayNameOptions = {}
+): DisplayNameResult {
+    const name = normalizeDisplayName(input)
+
+    if (name.length === 0) {
+        return opts.allowEmpty ? {valid: true, name} : {valid: false, reason: 'empty', name}
+    }
+    if (textEncoder.encode(name).length > MAX_DISPLAY_NAME_BYTES) {
+        return {valid: false, reason: 'too_long', name}
+    }
+
+    for (const character of name) {
+        const codePoint = character.codePointAt(0)!
+        if (isInvalidDisplayNameCodePoint(codePoint)) {
+            return {valid: false, reason: 'invalid_char', name}
+        }
+    }
+
+    return {valid: true, name}
+}

package/src/utils/system.ts

@@ -3,12 +3,12 @@ import {hash512} from './hash'
 import {Coordinates, type CoordinatesType, LocationType} from '../types'
 import {ServerContract} from '../contracts'
 import {deriveLocationSize} from '../derivation/location-size'
+import {wormholeAt} from '../derivation/wormhole'
 import syllables from '../data/syllables.json'
 import nebulaAdjectives from '../data/nebula-adjectives.json'
 import nebulaNouns from '../data/nebula-nouns.json'
 
 const LOCATION_EXISTS_THRESHOLD = 0x10
-const LOCATION_ACTIVE_THRESHOLD = 0x80
 
 export function getLocationType(
     gameSeed: Checksum256Type,
@@ -111,6 +111,16 @@ export function hasSystem(gameSeed: Checksum256Type, coordinates: CoordinatesTyp
     return getLocationType(gameSeed, coordinates) !== LocationType.EMPTY
 }
 
+export function getLocationKind(
+    gameSeed: Checksum256Type,
+    x: number,
+    y: number
+): 'wormhole' | 'system' | 'empty' {
+    if (wormholeAt(gameSeed, x, y)) return 'wormhole'
+    if (hasSystem(gameSeed, {x, y})) return 'system'
+    return 'empty'
+}
+
 export function deriveLocationStatic(
     gameSeed: Checksum256Type,
     coordinates: CoordinatesType
@@ -151,31 +161,20 @@ export function deriveLocationStatic(
     return loc
 }
 
-export function deriveLocationEpoch(
-    epochSeed: Checksum256Type,
+export function isLocationBuildable(
+    gameSeed: Checksum256Type,
     coordinates: CoordinatesType
-): ServerContract.Types.location_epoch {
-    const seed = Checksum256.from(epochSeed)
-    const coords = Coordinates.from(coordinates)
-    const str = `system-epoch-${coords.x}-${coords.y}`
-    const hashResult = hash512(seed, str)
-
-    return ServerContract.Types.location_epoch.from({
-        active: hashResult.array[0] < LOCATION_ACTIVE_THRESHOLD,
-        seed0: hashResult.array[1],
-        seed1: hashResult.array[2],
-    })
+): boolean {
+    return getLocationType(gameSeed, coordinates) === LocationType.PLANET
 }
 
 export function deriveLocation(
     gameSeed: Checksum256Type,
-    epochSeed: Checksum256Type,
     coordinates: CoordinatesType
 ): ServerContract.Types.location_derived {
     const staticProps = deriveLocationStatic(gameSeed, coordinates)
     return ServerContract.Types.location_derived.from({
         static_props: staticProps,
-        epoch_props: deriveLocationEpoch(epochSeed, coordinates),
         size: deriveLocationSize(staticProps),
     })
 }

package/src/capabilities/loading.ts

@@ -1,8 +0,0 @@
-import {UInt32, type UInt64} from '@wharfkit/antelope'
-import type {LoaderCapability} from '../types/capabilities'
-
-export function calcLoadDuration(entity: LoaderCapability, cargoMass: UInt64): UInt32 {
-    const totalThrust = entity.loaders.thrust.toNumber() * entity.loaders.quantity.toNumber()
-    if (totalThrust === 0) return UInt32.from(0)
-    return UInt32.from(Math.ceil(Number(cargoMass) / totalThrust))
-}

package/src/entities/container.ts

@@ -1,123 +0,0 @@
-import {UInt64, type UInt64Type} from '@wharfkit/antelope'
-import {ServerContract} from '../contracts'
-import type {CoordinatesType} from '../types'
-import {type FloatPosition, getInterpolatedPosition} from '../travel/travel'
-import {Location} from './location'
-import {ScheduleAccessor} from '../scheduling/accessor'
-import * as schedule from '../scheduling/schedule'
-
-export interface ContainerStateInput {
-    id: UInt64Type
-    owner: string
-    name: string
-    coordinates: CoordinatesType | {x: number; y: number; z?: number}
-    hullmass: number
-    capacity: number
-    cargomass?: number
-    cargo?: ServerContract.Types.cargo_item[]
-    schedule?: ServerContract.Types.schedule
-}
-
-export class Container extends ServerContract.Types.entity_info {
-    private _sched?: ScheduleAccessor
-
-    get name(): string {
-        return this.entity_name
-    }
-
-    get entityClass(): 'mobile' {
-        return 'mobile'
-    }
-
-    get canUndeploy(): boolean {
-        return true
-    }
-
-    get sched(): ScheduleAccessor {
-        this._sched ??= new ScheduleAccessor(this)
-        return this._sched
-    }
-
-    get isIdle(): boolean {
-        return this.is_idle
-    }
-
-    interpolatedPositionAt(now: Date): FloatPosition {
-        const taskIndex = this.sched.currentTaskIndex(now)
-        const progress = this.sched.currentTaskProgressFloat(now)
-        return getInterpolatedPosition(this, taskIndex, progress)
-    }
-
-    isLoading(now: Date): boolean {
-        return schedule.isLoading(this, now)
-    }
-
-    isUnloading(now: Date): boolean {
-        return schedule.isUnloading(this, now)
-    }
-
-    get location(): Location {
-        return Location.from(this.coordinates)
-    }
-
-    get totalMass(): UInt64 {
-        return UInt64.from(this.hullmass ?? 0).adding(this.cargomass)
-    }
-
-    get maxCapacity(): UInt64 {
-        return UInt64.from(this.capacity)
-    }
-
-    get availableCapacity(): UInt64 {
-        const cargo = UInt64.from(this.cargomass)
-        return cargo.gte(this.maxCapacity) ? UInt64.from(0) : this.maxCapacity.subtracting(cargo)
-    }
-
-    hasSpace(additionalMass: UInt64): boolean {
-        return UInt64.from(this.cargomass).adding(additionalMass).lte(this.maxCapacity)
-    }
-
-    get isFull(): boolean {
-        return UInt64.from(this.cargomass).gte(this.maxCapacity)
-    }
-
-    get orbitalAltitude(): number {
-        return this.coordinates.z?.toNumber() || 0
-    }
-}
-
-export function computeContainerCapabilities(stats: Record<string, number>): {
-    hullmass: number
-    capacity: number
-} {
-    const density = stats.density
-    const strength = stats.strength
-    const hardness = stats.hardness
-    const saturation = stats.saturation
-
-    const hullmass = 25000 + 75 * density
-
-    const statSum = strength + hardness + saturation
-    const exponent = statSum / 2997
-    const capacity = Math.floor(1000000 * 10 ** exponent)
-
-    return {hullmass, capacity}
-}
-
-export function computeContainerT2Capabilities(stats: Record<string, number>): {
-    hullmass: number
-    capacity: number
-} {
-    const strength = stats.strength
-    const density = stats.density
-    const hardness = stats.hardness
-    const saturation = stats.saturation
-
-    const hullmass = 20000 + 50 * density
-
-    const statSum = strength + hardness + saturation
-    const exponent = statSum / 2500
-    const capacity = Math.floor(1500000 * 10 ** exponent)
-
-    return {hullmass, capacity}
-}