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

package/src/derivation/resources.ts

@@ -1,4 +1,5 @@
 import {getItem} from '../data/catalog'
+import {LocationType} from '../types'
 
 export const DEPTH_THRESHOLD_T1 = 0
 export const DEPTH_THRESHOLD_T2 = 1500
@@ -75,37 +76,107 @@ export function getResourceWeight(itemId: number, stratum: number): number {
     }
 }
 
-const ASTEROID_RESOURCES = [101, 102, 103, 201, 202]
-const NEBULA_RESOURCES = [202, 203, 301, 302, 303]
-const GAS_GIANT_RESOURCES = [301, 302, 303, 401, 501]
-const ROCKY_RESOURCES = [101, 102, 103, 401, 402, 403, 503]
-const TERRESTRIAL_RESOURCES = [201, 202, 401, 402, 501, 502, 503]
-const ICY_RESOURCES = [101, 301, 302, 401, 403, 501, 502]
-const OCEAN_RESOURCES = [201, 203, 301, 303, 501, 502, 503]
-const INDUSTRIAL_RESOURCES = [101, 102, 103, 201, 203, 402, 403]
+const RESOURCE_ORE = 0
+const RESOURCE_GAS = 1
+const RESOURCE_REGOLITH = 2
+const RESOURCE_BIOMASS = 3
+const RESOURCE_CRYSTAL = 4
 
-export function getLocationCandidates(locationType: number, subtype: number): number[] {
-    if (locationType === 2) return ASTEROID_RESOURCES
-    if (locationType === 3) return NEBULA_RESOURCES
-    if (locationType === 1) {
+interface LocationProfileEntry {
+    category: number
+    maxTier: number
+}
+
+function categoryBaseId(category: number): number {
+    switch (category) {
+        case RESOURCE_ORE:
+            return 100
+        case RESOURCE_CRYSTAL:
+            return 200
+        case RESOURCE_GAS:
+            return 300
+        case RESOURCE_REGOLITH:
+            return 400
+        case RESOURCE_BIOMASS:
+            return 500
+        default:
+            return 0
+    }
+}
+
+function resourceId(category: number, tier: number): number {
+    return categoryBaseId(category) + tier
+}
+
+export function getLocationProfile(locationType: number, subtype: number): LocationProfileEntry[] {
+    if (locationType === LocationType.ASTEROID) {
+        return [
+            {category: RESOURCE_ORE, maxTier: 5},
+            {category: RESOURCE_CRYSTAL, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.NEBULA) {
+        return [
+            {category: RESOURCE_GAS, maxTier: 5},
+            {category: RESOURCE_REGOLITH, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.ICE_FIELD) {
+        return [
+            {category: RESOURCE_GAS, maxTier: 5},
+            {category: RESOURCE_BIOMASS, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.PLANET) {
         switch (subtype) {
             case PLANET_SUBTYPE_GAS_GIANT:
-                return GAS_GIANT_RESOURCES
+                return [
+                    {category: RESOURCE_GAS, maxTier: 10},
+                    {category: RESOURCE_CRYSTAL, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_ROCKY:
-                return ROCKY_RESOURCES
+                return [
+                    {category: RESOURCE_REGOLITH, maxTier: 10},
+                    {category: RESOURCE_ORE, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_TERRESTRIAL:
-                return TERRESTRIAL_RESOURCES
+                return [
+                    {category: RESOURCE_ORE, maxTier: 10},
+                    {category: RESOURCE_BIOMASS, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_ICY:
-                return ICY_RESOURCES
+                return [
+                    {category: RESOURCE_CRYSTAL, maxTier: 10},
+                    {category: RESOURCE_REGOLITH, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_OCEAN:
-                return OCEAN_RESOURCES
+                return [
+                    {category: RESOURCE_BIOMASS, maxTier: 10},
+                    {category: RESOURCE_GAS, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_INDUSTRIAL:
-                return INDUSTRIAL_RESOURCES
+                return [
+                    {category: RESOURCE_ORE, maxTier: 3},
+                    {category: RESOURCE_CRYSTAL, maxTier: 3},
+                    {category: RESOURCE_REGOLITH, maxTier: 3},
+                    {category: RESOURCE_BIOMASS, maxTier: 3},
+                ]
         }
     }
     return []
 }
 
+export function getLocationCandidates(locationType: number, subtype: number): number[] {
+    const profile = getLocationProfile(locationType, subtype)
+    const ids: number[] = []
+    for (const {category, maxTier} of profile) {
+        for (let tier = 1; tier <= maxTier; tier++) {
+            ids.push(resourceId(category, tier))
+        }
+    }
+    return ids
+}
+
 export function getEligibleResources(
     locationType: number,
     subtype: number,

package/src/index-module.ts

@@ -31,7 +31,6 @@ export type container_row = ServerContract.Types.container_row
 export type gatherer_stats = ServerContract.Types.gatherer_stats
 
 export type location_static = ServerContract.Types.location_static
-export type location_epoch = ServerContract.Types.location_epoch
 export type location_derived = ServerContract.Types.location_derived
 export type location_row = ServerContract.Types.location_row
 export {Player} from './entities/player'
@@ -63,7 +62,6 @@ export {
     categoryLabel,
     categoryFromIndex,
     categoryLabelFromIndex,
-    tierLabel,
 } from './data/catalog'
 export {getCurrentEpoch, getEpochInfo} from './scheduling/epoch'
 export type {EpochInfo} from './scheduling/epoch'
@@ -74,7 +72,6 @@ export {
     getLocationTypeName,
     isGatherableLocation,
     deriveLocationStatic,
-    deriveLocationEpoch,
     deriveLocation,
 } from './utils/system'
 
@@ -86,6 +83,7 @@ export {
     getEligibleResources,
     getResourceWeight,
     getLocationCandidates,
+    getLocationProfile,
     getDepthThreshold,
     getResourceTier,
     DEPTH_THRESHOLD_T1,
@@ -164,6 +162,8 @@ export type {HasCargo} from './entities/inventory-accessor'
 export * as cargoUtils from './entities/cargo-utils'
 export type {CargoData} from './entities/cargo-utils'
 
+export {cargoRef, cargoItem} from './utils/cargo'
+
 export {
     createProjectedEntity,
     projectEntity,
@@ -186,7 +186,6 @@ export * from './capabilities'
 export {
     categoryColors,
     tierColors,
-    tierLabels,
     categoryIcons,
     categoryIconShapes,
     componentIcon,

package/src/managers/actions.ts

@@ -90,18 +90,15 @@ export class ActionsManager extends BaseManager {
         sourceId: UInt64Type,
         destType: EntityTypeName,
         destId: UInt64Type,
-        itemId: UInt64Type,
-        stats: UInt64Type,
-        quantity: UInt64Type
+        items: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
+        const cargoItems = items.map((i) => ServerContract.Types.cargo_item.from(i))
         return this.server.action('transfer', {
             source_type: sourceType,
             source_id: UInt64.from(sourceId),
             dest_type: destType,
             dest_id: UInt64.from(destId),
-            item_id: UInt16.from(itemId),
-            stats: UInt64.from(stats),
-            quantity: UInt32.from(quantity),
+            items: cargoItems,
         })
     }
 
@@ -187,14 +184,12 @@ export class ActionsManager extends BaseManager {
     deploy(
         entityType: EntityTypeName,
         entityId: UInt64Type,
-        packedItemId: number,
-        stats: bigint
+        ref: ServerContract.ActionParams.Type.cargo_ref
     ): Action {
         return this.server.action('deploy', {
             entity_type: entityType,
             id: UInt64.from(entityId),
-            packed_item_id: UInt16.from(packedItemId),
-            stats: UInt64.from(stats),
+            ref: ServerContract.Types.cargo_ref.from(ref),
         })
     }
 
@@ -202,15 +197,15 @@ export class ActionsManager extends BaseManager {
         entityType: EntityTypeName,
         entityId: UInt64Type,
         moduleIndex: number,
-        moduleCargoId: UInt64Type,
-        targetCargoId: UInt64Type = UInt64.from(0)
+        moduleRef: ServerContract.ActionParams.Type.cargo_ref,
+        targetRef: ServerContract.ActionParams.Type.cargo_ref | null = null
     ): Action {
         return this.server.action('addmodule', {
             entity_type: entityType,
             entity_id: UInt64.from(entityId),
             module_index: moduleIndex,
-            module_cargo_id: UInt64.from(moduleCargoId),
-            target_cargo_id: UInt64.from(targetCargoId),
+            module_ref: ServerContract.Types.cargo_ref.from(moduleRef),
+            target_ref: targetRef ? ServerContract.Types.cargo_ref.from(targetRef) : null,
         })
     }
 
@@ -218,13 +213,13 @@ export class ActionsManager extends BaseManager {
         entityType: EntityTypeName,
         entityId: UInt64Type,
         moduleIndex: number,
-        targetCargoId: UInt64Type = UInt64.from(0)
+        targetRef: ServerContract.ActionParams.Type.cargo_ref | null = null
     ): Action {
         return this.server.action('rmmodule', {
             entity_type: entityType,
             entity_id: UInt64.from(entityId),
             module_index: moduleIndex,
-            target_cargo_id: UInt64.from(targetCargoId),
+            target_ref: targetRef ? ServerContract.Types.cargo_ref.from(targetRef) : null,
         })
     }
 
@@ -232,15 +227,14 @@ export class ActionsManager extends BaseManager {
         owner: NameType,
         entityType: EntityTypeName,
         entityId: UInt64Type,
-        cargoId: UInt64Type,
-        quantity: UInt64Type
+        items: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
+        const cargoItems = items.map((i) => ServerContract.Types.cargo_item.from(i))
         return this.server.action('wrap', {
             owner: Name.from(owner),
             entity_type: entityType,
             entity_id: UInt64.from(entityId),
-            cargo_id: UInt64.from(cargoId),
-            quantity: UInt64.from(quantity),
+            items: cargoItems,
         })
     }
 

package/src/types.ts

@@ -61,6 +61,7 @@ export enum LocationType {
     PLANET = 1,
     ASTEROID = 2,
     NEBULA = 3,
+    ICE_FIELD = 4,
 }
 
 export enum TaskCancelable {
@@ -162,3 +163,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}`
+}

package/src/utils/cargo.ts

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

@@ -8,7 +8,6 @@ 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 +21,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 +41,8 @@ export function getLocationTypeName(type: LocationType): string {
             return 'Asteroid'
         case LocationType.NEBULA:
             return 'Nebula'
+        case LocationType.ICE_FIELD:
+            return 'Ice Field'
     }
 }
 
@@ -76,6 +75,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 +99,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)
     }
@@ -123,10 +133,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 +150,13 @@ export function deriveLocationStatic(
     return loc
 }
 
-export function deriveLocationEpoch(
-    epochSeed: 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],
-    })
-}
-
 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),
     })
 }