@shipload/sdk 2.0.0-rc1 → 2.0.0-rc2

package/src/types.ts

@@ -1,15 +1,59 @@
-import {Int64Type, Name, Struct, UInt16, UInt16Type, UInt32, UInt32Type} from '@wharfkit/antelope'
+import {
+    Int64Type,
+    Name,
+    Struct,
+    UInt16,
+    UInt16Type,
+    UInt32,
+    UInt32Type,
+    UInt64,
+} from '@wharfkit/antelope'
 import {ServerContract} from './contracts'
 
 export const PRECISION = 10000
 
-export const INITIAL_SHIP_MASS = 500000
+// Ship constants
+export const INITIAL_SHIP_GENERATOR_CAPACITY = 350
+export const INITIAL_SHIP_DRAIN = 25
+export const INITIAL_SHIP_ENERGY = 350
+export const INITIAL_SHIP_HULLMASS = 100000
+export const INITIAL_SHIP_CAPACITY = 500000
+export const INITIAL_SHIP_Z = 800
+export const INITIAL_SHIP_RECHARGE = 10
+export const INITIAL_SHIP_THRUST = 250
+
+// Loader constants
+export const INITIAL_LOADER_MASS = 1000
+export const INITIAL_LOADER_QUANTITY = 1
+export const INITIAL_LOADER_THRUST = 1
+
+// Warehouse constants
+export const WAREHOUSE_Z = 500
+export const INITIAL_WAREHOUSE_CAPACITY = 10000000
+
+// Container constants
+export const CONTAINER_Z = 300
+export const INITIAL_CONTAINER_HULLMASS = 50000
+export const INITIAL_CONTAINER_CAPACITY = 2000000
+
+// Mechanics
+export const TRAVEL_MAX_DURATION = 86400
+
+// Altitude limits (for UI/calculations)
 export const MIN_ORBITAL_ALTITUDE = 800
 export const MAX_ORBITAL_ALTITUDE = 3000
 
+// Legacy alias (deprecated, use INITIAL_SHIP_CAPACITY)
+export const INITIAL_SHIP_MASS = 500000
+
+// Extractor constants
+export const INITIAL_EXTRACTOR_RATE = 700
+export const INITIAL_EXTRACTOR_DRAIN = 2500
+export const INITIAL_EXTRACTOR_EFFICIENCY = 5000
+
 export interface ShipLike {
-    location: ServerContract.Types.coordinates
-    mass: UInt32
+    coordinates: ServerContract.Types.coordinates
+    hullmass: UInt32
     energy: UInt16
     engines: ServerContract.Types.movement_stats
     generator: ServerContract.Types.energy_stats
@@ -23,10 +67,19 @@ export interface CargoMassInfo {
 }
 
 export enum TaskType {
-    RECHARGE = 0,
-    LOAD = 1,
-    UNLOAD = 2,
-    FLIGHT = 3,
+    IDLE = 0,
+    TRAVEL = 1,
+    RECHARGE = 2,
+    LOAD = 3,
+    UNLOAD = 4,
+    EXTRACT = 5,
+}
+
+export enum LocationType {
+    EMPTY = 0,
+    PLANET = 1,
+    ASTEROID = 2,
+    NEBULA = 3,
 }
 
 export enum TaskCancelable {
@@ -38,6 +91,7 @@ export enum TaskCancelable {
 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]
@@ -56,6 +110,19 @@ export class Coordinates extends ServerContract.Types.coordinates {
         const coords = Coordinates.from(other)
         return this.x.equals(coords.x) && this.y.equals(coords.y)
     }
+
+    toLocationId(): UInt64 {
+        return coordsToLocationId(this)
+    }
+}
+
+export function coordsToLocationId(coords: CoordinatesType): UInt64 {
+    const c = Coordinates.from(coords)
+    const mask = BigInt(0xffffffff)
+    const x = BigInt(c.x.toNumber()) & mask
+    const y = BigInt(c.y.toNumber()) & mask
+    const id = (x << BigInt(32)) | y
+    return UInt64.from(id)
 }
 
 export interface Distance {

package/src/utils/hash.ts

@@ -1,6 +1,6 @@
 import {Bytes, Checksum256, Checksum256Type, Checksum512} from '@wharfkit/antelope'
 
-export function hash(seed: Checksum256Type, string: string): Checksum512 {
+export function hash(seed: Checksum256Type, string: string): Checksum256 {
     const bytes = Bytes.from(`${seed}${string}`, 'utf8')
     return Checksum256.hash(bytes)
 }

package/src/utils/system.ts

@@ -1,8 +1,36 @@
-import {Checksum256, Checksum256Type} from '@wharfkit/antelope'
+import {Checksum256, Checksum256Type, UInt8} from '@wharfkit/antelope'
 import {hash512} from './hash'
-import {CoordinatesType} from '../types'
+import {Coordinates, CoordinatesType, LocationType, PRECISION} from '../types'
+import {ServerContract} from '../contracts'
 import syllables from '../data/syllables.json'
 
+const LOCATION_EXISTS_THRESHOLD = 0x10
+const LOCATION_ACTIVE_THRESHOLD = 0x80
+
+export function getLocationType(
+    gameSeed: Checksum256Type,
+    coordinates: CoordinatesType
+): LocationType {
+    const seed = Checksum256.from(gameSeed)
+    const str = ['system', coordinates.x, coordinates.y].join('-')
+    const hashResult = hash512(seed, str)
+
+    if (hashResult.array[0] >= LOCATION_EXISTS_THRESHOLD) {
+        return LocationType.EMPTY
+    }
+
+    if (hashResult.array[1] < 96) {
+        return LocationType.PLANET
+    } else if (hashResult.array[1] < 176) {
+        return LocationType.ASTEROID
+    }
+    return LocationType.NEBULA
+}
+
+export function isExtractableLocation(locationType: LocationType): boolean {
+    return locationType === LocationType.ASTEROID || locationType === LocationType.NEBULA
+}
+
 export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string {
     const seed = Checksum256.from(gameSeed)
     if (!hasSystem(seed, location)) {
@@ -21,7 +49,107 @@ export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesTy
 }
 
 export function hasSystem(gameSeed: Checksum256Type, coordinates: CoordinatesType): boolean {
+    return getLocationType(gameSeed, coordinates) !== LocationType.EMPTY
+}
+
+export function deriveLocationStatic(
+    gameSeed: Checksum256Type,
+    coordinates: CoordinatesType
+): ServerContract.Types.location_static {
     const seed = Checksum256.from(gameSeed)
-    const str = ['system', coordinates.x, coordinates.y].join('-')
-    return String(hash512(seed, str)).slice(0, 2) === '00'
+    const coords = Coordinates.from(coordinates)
+    const str = `system-${coords.x}-${coords.y}`
+    const hashResult = hash512(seed, str)
+
+    const loc = ServerContract.Types.location_static.from({
+        coords: coords,
+        type: LocationType.EMPTY,
+        subtype: 0,
+        seed0: 0,
+        seed1: 0,
+    })
+
+    if (hashResult.array[0] >= LOCATION_EXISTS_THRESHOLD) {
+        return loc
+    }
+
+    if (hashResult.array[1] < 96) {
+        loc.type = UInt8.from(LocationType.PLANET)
+    } else if (hashResult.array[1] < 176) {
+        loc.type = UInt8.from(LocationType.ASTEROID)
+    } else {
+        loc.type = UInt8.from(LocationType.NEBULA)
+    }
+
+    loc.subtype = UInt8.from(hashResult.array[2])
+    loc.seed0 = UInt8.from(hashResult.array[3])
+    loc.seed1 = UInt8.from(hashResult.array[4])
+
+    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 {
+    return ServerContract.Types.location_derived.from({
+        static_props: deriveLocationStatic(gameSeed, coordinates),
+        epoch_props: deriveLocationEpoch(epochSeed, coordinates),
+    })
+}
+
+export function deriveLocationMixture(
+    location: ServerContract.Types.location_derived,
+    epochSeed: Checksum256Type
+): ServerContract.Types.mixture_info {
+    const locationType = location.static_props.type.toNumber()
+
+    if (locationType === LocationType.NEBULA) {
+        return ServerContract.Types.mixture_info.from({
+            components: [{good_id: 1, purity: PRECISION}],
+        })
+    }
+
+    if (locationType === LocationType.ASTEROID) {
+        const seed = Checksum256.from(epochSeed)
+        const coords = location.static_props.coords
+        const str = `mixture-${coords.x}-${coords.y}`
+        const hashResult = hash512(seed, str)
+
+        const ironPrimary = location.static_props.subtype.toNumber() % 2 === 0
+        const purityRange = 0.3
+        const purityRoll = hashResult.array[0] / 255
+        const primaryPurity = 0.5 + purityRoll * purityRange
+
+        const primaryId = ironPrimary ? 26 : 29
+        const secondaryId = ironPrimary ? 29 : 26
+        const primaryAmt = Math.floor(primaryPurity * PRECISION)
+        const secondaryAmt = PRECISION - primaryAmt
+
+        return ServerContract.Types.mixture_info.from({
+            components: [
+                {good_id: primaryId, purity: primaryAmt},
+                {good_id: secondaryId, purity: secondaryAmt},
+            ],
+        })
+    }
+
+    return ServerContract.Types.mixture_info.from({components: []})
 }