@shipload/sdk 1.0.0-next.5 → 1.0.0-next.50

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,
@@ -22,12 +22,10 @@ export function getLocationType(
         return LocationType.EMPTY
     }
 
-    if (hashResult.array[1] < 96) {
-        return LocationType.PLANET
-    } else if (hashResult.array[1] < 176) {
-        return LocationType.ASTEROID
-    }
-    return LocationType.NEBULA
+    if (hashResult.array[1] < 96) return LocationType.PLANET
+    if (hashResult.array[1] < 149) return LocationType.ASTEROID
+    if (hashResult.array[1] < 202) return LocationType.NEBULA
+    return LocationType.ICE_FIELD
 }
 
 export function isGatherableLocation(locationType: LocationType): boolean {
@@ -44,6 +42,8 @@ export function getLocationTypeName(type: LocationType): string {
             return 'Asteroid'
         case LocationType.NEBULA:
             return 'Nebula'
+        case LocationType.ICE_FIELD:
+            return 'Ice Field'
     }
 }
 
@@ -76,6 +76,15 @@ function generateNebulaName(hashResult: Checksum512): string {
     return `${nebulaAdjectives[adjIdx]} ${nebulaNouns[nounIdx]}`
 }
 
+function generateIceFieldName(hashResult: Checksum512): string {
+    const A = 65
+    const letter1 = String.fromCharCode(A + (hashResult.array[0] % 26))
+    const letter2 = String.fromCharCode(A + (hashResult.array[1] % 26))
+    const subId = (hashResult.array[2] % 9) + 1
+    const num = (uint16(hashResult, 3) % 9000) + 1000
+    return `${letter1}${letter2}-${subId}/${num}`
+}
+
 export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string {
     const seed = Checksum256.from(gameSeed)
     const locationType = getLocationType(seed, location)
@@ -91,6 +100,8 @@ export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesTy
             return generateAsteroidName(hashResult)
         case LocationType.NEBULA:
             return generateNebulaName(hashResult)
+        case LocationType.ICE_FIELD:
+            return generateIceFieldName(hashResult)
         default:
             return generatePlanetName(hashResult)
     }
@@ -100,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
@@ -123,10 +144,12 @@ export function deriveLocationStatic(
 
     if (hashResult.array[1] < 96) {
         loc.type = UInt8.from(LocationType.PLANET)
-    } else if (hashResult.array[1] < 176) {
+    } else if (hashResult.array[1] < 149) {
         loc.type = UInt8.from(LocationType.ASTEROID)
-    } else {
+    } else if (hashResult.array[1] < 202) {
         loc.type = UInt8.from(LocationType.NEBULA)
+    } else {
+        loc.type = UInt8.from(LocationType.ICE_FIELD)
     }
 
     loc.subtype = UInt8.from(
@@ -138,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}
-}

package/src/entities/ship-deploy.ts

@@ -1,295 +0,0 @@
-import {decodeCraftedItemStats} from '../derivation/crafting'
-import {
-    getModuleCapabilityType,
-    MODULE_CRAFTER,
-    MODULE_ENGINE,
-    MODULE_GATHERER,
-    MODULE_GENERATOR,
-    MODULE_HAULER,
-    MODULE_LOADER,
-} from '../capabilities/modules'
-import {getItem} from '../data/catalog'
-
-export function computeShipHullCapabilities(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.0
-    const capacity = Math.floor(1000000 * 10 ** exponent)
-
-    return {hullmass, capacity}
-}
-
-export function computeEngineCapabilities(stats: Record<string, number>): {
-    thrust: number
-    drain: number
-} {
-    const vol = stats.volatility
-    const thm = stats.thermal
-
-    return {
-        thrust: 400 + Math.floor((vol * 3) / 4),
-        drain: Math.max(30, 50 - Math.floor(thm / 70)),
-    }
-}
-
-export function computeGeneratorCapabilities(stats: Record<string, number>): {
-    capacity: number
-    recharge: number
-} {
-    const com = stats.composition
-    const fin = stats.fineness
-
-    return {
-        capacity: 300 + Math.floor(com / 6),
-        recharge: 1 + Math.floor((fin * 3) / 1000),
-    }
-}
-
-export interface GathererDepthParams {
-    readonly floor: number
-    readonly slope: number
-}
-
-export const GATHERER_DEPTH_TABLE: readonly GathererDepthParams[] = [
-    {floor: 500, slope: 5},
-    {floor: 2000, slope: 11},
-    {floor: 7000, slope: 16},
-    {floor: 15000, slope: 18},
-    {floor: 25000, slope: 19},
-    {floor: 35000, slope: 16},
-    {floor: 46000, slope: 12},
-    {floor: 53500, slope: 10},
-    {floor: 60000, slope: 5},
-    {floor: 63500, slope: 2},
-]
-
-export const GATHERER_DEPTH_MAX_TIER = 10
-
-export function gathererDepthForTier(tol: number, tier: number): number {
-    if (tier < 1 || tier > GATHERER_DEPTH_MAX_TIER) {
-        throw new Error(`gatherer tier out of range: ${tier}`)
-    }
-    const p = GATHERER_DEPTH_TABLE[tier - 1]
-    return p.floor + tol * p.slope
-}
-
-export function computeGathererCapabilities(
-    stats: Record<string, number>,
-    tier: number
-): {
-    yield: number
-    drain: number
-    depth: number
-    speed: number
-} {
-    const str = stats.strength
-    const con = stats.conductivity
-    const ref = stats.reflectivity
-    const tol = stats.tolerance
-
-    return {
-        yield: 200 + str,
-        drain: Math.max(250, 1250 - Math.floor((con * 25) / 20)),
-        depth: gathererDepthForTier(tol, tier),
-        speed: 100 + Math.floor((ref * 4) / 5),
-    }
-}
-
-export function computeLoaderCapabilities(stats: Record<string, number>): {
-    mass: number
-    thrust: number
-    quantity: number
-} {
-    const insulation = stats.insulation
-    const plasticity = stats.plasticity
-
-    return {
-        mass: Math.max(200, 2000 - Math.floor(insulation * 2)),
-        thrust: 1 + Math.floor(plasticity / 500),
-        quantity: 1,
-    }
-}
-
-export function computeCrafterCapabilities(stats: Record<string, number>): {
-    speed: number
-    drain: number
-} {
-    const rea = stats.reactivity
-    const fin = stats.fineness
-
-    return {
-        speed: 100 + Math.floor((rea * 4) / 5),
-        drain: Math.max(5, 30 - Math.floor(fin / 33)),
-    }
-}
-
-export function computeHaulerCapabilities(stats: Record<string, number>): {
-    capacity: number
-    efficiency: number
-    drain: number
-} {
-    const fineness = stats.fineness
-    const conductivity = stats.conductivity
-    const composition = stats.composition
-
-    return {
-        capacity: Math.max(1, 1 + Math.floor(fineness / 400)),
-        efficiency: 2000 + conductivity * 6,
-        drain: Math.max(3, 15 - Math.floor(composition / 80)),
-    }
-}
-
-export function computeStorageCapabilities(
-    stats: Record<string, number>,
-    baseCapacity: number
-): {
-    capacityBonus: number
-} {
-    const strength = stats.strength
-    const density = stats.density
-    const hardness = stats.hardness
-    const saturation = stats.saturation
-
-    const statSum = strength + density + hardness + saturation
-    const capacityBonus = Math.floor(
-        (baseCapacity * (10 + Math.floor((statSum * 10) / 2997))) / 100
-    )
-
-    return {capacityBonus}
-}
-
-export function computeWarehouseHullCapabilities(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.0
-    const capacity = Math.floor(20000000 * 10 ** exponent)
-
-    return {hullmass, capacity}
-}
-
-export interface ShipCapabilities {
-    engines?: {thrust: number; drain: number}
-    generator?: {capacity: number; recharge: number}
-    gatherer?: {yield: number; drain: number; depth: number; speed: number}
-    hauler?: {capacity: number; efficiency: number; drain: number}
-    loaders?: {mass: number; thrust: number; quantity: number}
-    crafter?: {speed: number; drain: number}
-}
-
-export function computeShipCapabilities(
-    modules: {itemId: number; stats: bigint}[]
-): ShipCapabilities {
-    const ship: ShipCapabilities = {}
-
-    const engineModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_ENGINE)
-    if (engineModules.length > 0) {
-        let totalThrust = 0
-        let totalDrain = 0
-        for (const m of engineModules) {
-            const caps = computeEngineCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalThrust += caps.thrust
-            totalDrain += caps.drain
-        }
-        ship.engines = {thrust: totalThrust, drain: totalDrain}
-    }
-
-    const generatorModules = modules.filter(
-        (m) => getModuleCapabilityType(m.itemId) === MODULE_GENERATOR
-    )
-    if (generatorModules.length > 0) {
-        let totalCapacity = 0
-        let totalRecharge = 0
-        for (const m of generatorModules) {
-            const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalCapacity += caps.capacity
-            totalRecharge += caps.recharge
-        }
-        ship.generator = {capacity: totalCapacity, recharge: totalRecharge}
-    }
-
-    const gathererModules = modules.filter(
-        (m) => getModuleCapabilityType(m.itemId) === MODULE_GATHERER
-    )
-    if (gathererModules.length > 0) {
-        let totalYield = 0
-        let totalDrain = 0
-        let maxDepth = 0
-        let totalSpeed = 0
-        for (const m of gathererModules) {
-            const tier = getItem(m.itemId).tier
-            const caps = computeGathererCapabilities(
-                decodeCraftedItemStats(m.itemId, m.stats),
-                tier
-            )
-            totalYield += caps.yield
-            totalDrain += caps.drain
-            if (caps.depth > maxDepth) maxDepth = caps.depth
-            totalSpeed += caps.speed
-        }
-        ship.gatherer = {yield: totalYield, drain: totalDrain, depth: maxDepth, speed: totalSpeed}
-    }
-
-    const haulerModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_HAULER)
-    if (haulerModules.length > 0) {
-        let totalCapacity = 0
-        let weightedEffNum = 0
-        let totalDrain = 0
-        for (const m of haulerModules) {
-            const caps = computeHaulerCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalCapacity += caps.capacity
-            weightedEffNum += caps.efficiency * caps.capacity
-            totalDrain += caps.drain
-        }
-        ship.hauler = {
-            capacity: totalCapacity,
-            efficiency: totalCapacity > 0 ? Math.floor(weightedEffNum / totalCapacity) : 0,
-            drain: totalDrain,
-        }
-    }
-
-    const loaderModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_LOADER)
-    if (loaderModules.length > 0) {
-        let totalMass = 0
-        let totalThrust = 0
-        let totalQuantity = 0
-        for (const m of loaderModules) {
-            const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalMass += caps.mass
-            totalThrust += caps.thrust
-            totalQuantity += caps.quantity
-        }
-        ship.loaders = {mass: totalMass, thrust: totalThrust, quantity: totalQuantity}
-    }
-
-    const crafterModules = modules.filter(
-        (m) => getModuleCapabilityType(m.itemId) === MODULE_CRAFTER
-    )
-    if (crafterModules.length > 0) {
-        let totalSpeed = 0
-        let totalDrain = 0
-        for (const m of crafterModules) {
-            const caps = computeCrafterCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalSpeed += caps.speed
-            totalDrain += caps.drain
-        }
-        ship.crafter = {speed: totalSpeed, drain: totalDrain}
-    }
-
-    return ship
-}