@shipload/sdk 0.7.1 → 1.0.0-next.0

package/src/types/capabilities.ts

@@ -0,0 +1,76 @@
+import type {Name, UInt16, UInt32} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+
+export interface MovementCapability {
+    engines: ServerContract.Types.movement_stats
+    generator: ServerContract.Types.energy_stats
+}
+
+export interface EnergyCapability {
+    energy: UInt16
+}
+
+export interface StorageCapability {
+    capacity: UInt32
+    cargomass: UInt32
+    cargo: ServerContract.Types.cargo_item[]
+}
+
+export interface LoaderCapability {
+    loaders: ServerContract.Types.loader_stats
+}
+
+export interface GathererCapability {
+    gatherer: ServerContract.Types.gatherer_stats
+}
+
+export interface MassCapability {
+    hullmass: UInt32
+}
+
+export interface ScheduleCapability {
+    schedule?: ServerContract.Types.schedule
+}
+
+export interface EntityCapabilities {
+    hullmass?: UInt32
+    capacity?: UInt32
+    engines?: ServerContract.Types.movement_stats
+    generator?: ServerContract.Types.energy_stats
+    loaders?: ServerContract.Types.loader_stats
+    gatherer?: ServerContract.Types.gatherer_stats
+    crafter?: ServerContract.Types.crafter_stats
+    hauler?: ServerContract.Types.hauler_stats
+}
+
+export interface EntityState {
+    owner: Name
+    location: ServerContract.Types.coordinates
+    energy?: UInt16
+    cargomass: UInt32
+    cargo: ServerContract.Types.cargo_item[]
+}
+
+export function capsHasMovement(caps: EntityCapabilities): boolean {
+    return caps.engines !== undefined && caps.generator !== undefined
+}
+
+export function capsHasStorage(caps: EntityCapabilities): boolean {
+    return caps.capacity !== undefined
+}
+
+export function capsHasLoaders(caps: EntityCapabilities): boolean {
+    return caps.loaders !== undefined
+}
+
+export function capsHasGatherer(caps: EntityCapabilities): boolean {
+    return caps.gatherer !== undefined
+}
+
+export function capsHasMass(caps: EntityCapabilities): boolean {
+    return caps.hullmass !== undefined
+}
+
+export function capsHasHauler(caps: EntityCapabilities): boolean {
+    return caps.hauler !== undefined
+}

package/src/types/entity-traits.ts

@@ -0,0 +1,69 @@
+import {Name} from '@wharfkit/antelope'
+
+export const ENTITY_SHIP = Name.from('ship')
+export const ENTITY_WAREHOUSE = Name.from('warehouse')
+export const ENTITY_CONTAINER = Name.from('container')
+
+export type EntityTypeName = 'ship' | 'warehouse' | 'container'
+
+export interface EntityTraits {
+    typeName: Name
+    isMovable: boolean
+    hasEnergy: boolean
+    hasLoaders: boolean
+    notFoundError: string
+}
+
+export const shipTraits: EntityTraits = {
+    typeName: ENTITY_SHIP,
+    isMovable: true,
+    hasEnergy: true,
+    hasLoaders: true,
+
+    notFoundError: 'ship not found',
+}
+
+export const warehouseTraits: EntityTraits = {
+    typeName: ENTITY_WAREHOUSE,
+    isMovable: false,
+    hasEnergy: false,
+    hasLoaders: true,
+
+    notFoundError: 'warehouse not found',
+}
+
+export const containerTraits: EntityTraits = {
+    typeName: ENTITY_CONTAINER,
+    isMovable: true,
+    hasEnergy: false,
+    hasLoaders: false,
+
+    notFoundError: 'container not found',
+}
+
+export function getEntityTraits(entityType: Name | EntityTypeName): EntityTraits {
+    const typeName = typeof entityType === 'string' ? entityType : entityType.toString()
+
+    switch (typeName) {
+        case 'ship':
+            return shipTraits
+        case 'warehouse':
+            return warehouseTraits
+        case 'container':
+            return containerTraits
+        default:
+            throw new Error(`Unknown entity type: ${typeName}`)
+    }
+}
+
+export function isShip(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_SHIP) ?? false
+}
+
+export function isWarehouse(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_WAREHOUSE) ?? false
+}
+
+export function isContainer(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_CONTAINER) ?? false
+}

package/src/types/entity.ts

@@ -0,0 +1,39 @@
+import type {Name, UInt64} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+import type {Coordinates} from '../types'
+import type {
+    EnergyCapability,
+    LoaderCapability,
+    MassCapability,
+    MovementCapability,
+    ScheduleCapability,
+    StorageCapability,
+} from './capabilities'
+
+export interface Entity {
+    id: UInt64
+    type: Name
+    owner: Name
+    entity_name: string
+    location: Coordinates | ServerContract.Types.coordinates
+}
+
+export type ShipEntity = Entity &
+    Partial<MovementCapability> &
+    Partial<EnergyCapability> &
+    StorageCapability &
+    Partial<LoaderCapability> &
+    MassCapability &
+    ScheduleCapability & {
+        gatherer?: ServerContract.Types.gatherer_stats
+    }
+
+export type WarehouseEntity = Entity &
+    StorageCapability &
+    Partial<LoaderCapability> &
+    MassCapability &
+    ScheduleCapability
+
+export type ContainerEntity = Entity & StorageCapability & MassCapability & ScheduleCapability
+
+export type AnyEntity = ShipEntity | WarehouseEntity | ContainerEntity

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './capabilities'
+export * from './entity'
+export * from './entity-traits'

package/src/types.ts

@@ -1,16 +1,106 @@
-import {Struct, UInt16, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {
+    type Int64Type,
+    Name,
+    type UInt16,
+    type UInt16Type,
+    type UInt32,
+    type UInt32Type,
+    UInt64,
+} from '@wharfkit/antelope'
 import {ServerContract} from './contracts'
 
 export const PRECISION = 10000
-export const TRAVEL_MAXMASS_PENALTY = 5 // Penalty (in seconds) for exceeding the maximum mass per 1000 unit
+export const CRAFT_ENERGY_DIVISOR = 150000
 
-export interface CameraPosition extends ServerContract.ActionParams.Type.coordinates {
-    z: number
+export const WAREHOUSE_Z = 500
+
+export const CONTAINER_Z = 300
+
+export const TRAVEL_MAX_DURATION = 86400
+
+export const MIN_ORBITAL_ALTITUDE = 800
+export const MAX_ORBITAL_ALTITUDE = 3000
+
+export const BASE_ORBITAL_MASS = 100000
+
+export interface ShipLike {
+    coordinates: ServerContract.Types.coordinates
+    hullmass?: UInt32
+    energy?: UInt16
+    engines?: ServerContract.Types.movement_stats
+    generator?: ServerContract.Types.energy_stats
+    loaders?: ServerContract.Types.loader_stats
+    hauler?: ServerContract.Types.hauler_stats
+    capacity?: UInt32
+}
+
+export interface CargoMassInfo {
+    item_id: UInt16Type
+    quantity: UInt32Type
+}
+
+export enum TaskType {
+    IDLE = 0,
+    TRAVEL = 1,
+    RECHARGE = 2,
+    LOAD = 3,
+    UNLOAD = 4,
+    GATHER = 5,
+    WARP = 6,
+    CRAFT = 7,
+    DEPLOY = 8,
+    WRAP = 9,
+    UNWRAP = 10,
+}
+
+export enum LocationType {
+    EMPTY = 0,
+    PLANET = 1,
+    ASTEROID = 2,
+    NEBULA = 3,
+}
+
+export enum TaskCancelable {
+    NEVER = 0,
+    BEFORE_START = 1,
+    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
+    | {x: Int64Type; y: Int64Type}
+
+export class Coordinates extends ServerContract.Types.coordinates {
+    static from(value: CoordinatesType): Coordinates {
+        return super.from(value) as Coordinates
+    }
+
+    equals(other: CoordinatesType): boolean {
+        const coords = Coordinates.from(other)
+        return this.x.equals(coords.x) && this.y.equals(coords.y)
+    }
+
+    toLocationId(): UInt64 {
+        return coordsToLocationId(this)
+    }
 }
 
-export interface Dimensions {
-    width: number
-    height: number
+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 {
@@ -19,38 +109,53 @@ export interface Distance {
     distance: UInt16
 }
 
-@Struct.type('good')
-export class Good extends Struct {
-    @Struct.field(UInt16)
-    id!: UInt16
-    @Struct.field('string')
-    name!: string
-    @Struct.field('string')
-    description!: string
-    @Struct.field(UInt64)
-    base_price!: UInt64
-    @Struct.field(UInt64)
-    mass!: UInt64
+export type ItemType = 'resource' | 'component' | 'module' | 'entity'
+export type ResourceCategory = 'ore' | 'crystal' | 'gas' | 'regolith' | 'biomass'
+export type ModuleType =
+    | 'any'
+    | 'engine'
+    | 'generator'
+    | 'gatherer'
+    | 'loader'
+    | 'warp'
+    | 'crafter'
+    | 'launcher'
+    | 'storage'
+    | 'hauler'
+
+export const TIER_ADJECTIVES: Record<number, string> = {
+    1: 'Crude',
+    2: 'Dense',
+    3: 'Pure',
+    4: 'Prime',
+    5: 'Pristine',
+    6: 'Radiant',
+    7: 'Exotic',
+    8: 'Mythic',
+    9: 'Cosmic',
+    10: 'Ascendant',
+}
+
+export const CATEGORY_LABELS: Record<ResourceCategory, string> = {
+    ore: 'Ore',
+    crystal: 'Crystal',
+    gas: 'Gas',
+    regolith: 'Regolith',
+    biomass: 'Biomass',
 }
 
-export interface GoodType {
-    id: UInt16Type
+export interface Item {
+    id: number
     name: string
     description: string
-    base_price: UInt64Type
-    mass: UInt64Type
+    color: string
+    mass: number
+    type: ItemType
+    tier: number
+    category?: ResourceCategory
+    moduleType?: ModuleType
 }
 
-@Struct.type('GoodPrice')
-export class GoodPrice extends Struct {
-    @Struct.field(UInt16)
-    id!: UInt16
-    @Struct.field(Good)
-    good!: Good
-    @Struct.field(UInt64)
-    price!: UInt64
-    @Struct.field(UInt64)
-    supply!: UInt64
+export function formatTier(tier: number): string {
+    return 'T' + tier
 }
-
-export interface Coordinates extends ServerContract.ActionParams.Type.coordinates {}

package/src/{hash.ts → utils/hash.ts}

@@ -1,6 +1,6 @@
-import {Bytes, Checksum256, Checksum256Type, Checksum512} from '@wharfkit/antelope'
+import {Bytes, Checksum256, type 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

@@ -0,0 +1,168 @@
+import {Checksum256, type Checksum256Type, type Checksum512, UInt8} from '@wharfkit/antelope'
+import {hash512} from './hash'
+import {Coordinates, type CoordinatesType, LocationType} from '../types'
+import {ServerContract} from '../contracts'
+import {deriveLocationSize} from '../derivation/location-size'
+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,
+    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 isGatherableLocation(locationType: LocationType): boolean {
+    return locationType !== LocationType.EMPTY
+}
+
+export function getLocationTypeName(type: LocationType): string {
+    switch (type) {
+        case LocationType.EMPTY:
+            return 'Empty'
+        case LocationType.PLANET:
+            return 'Planet'
+        case LocationType.ASTEROID:
+            return 'Asteroid'
+        case LocationType.NEBULA:
+            return 'Nebula'
+    }
+}
+
+function uint16(hash: Checksum512, offset: number): number {
+    return (hash.array[offset] << 8) | hash.array[offset + 1]
+}
+
+function generatePlanetName(hashResult: Checksum512): string {
+    const syllableCount = 2 + (hashResult.array[0] % 2)
+    const name: string[] = []
+    for (let i = 0; i < syllableCount; i++) {
+        const index = uint16(hashResult, 1 + i * 2) % syllables.length
+        const syllable = syllables[index]
+        name.push(i > 0 ? syllable.toLowerCase() : syllable)
+    }
+    return name.join('')
+}
+
+function generateAsteroidName(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 num = (uint16(hashResult, 2) % 9000) + 1000
+    return `${letter1}${letter2}-${num}`
+}
+
+function generateNebulaName(hashResult: Checksum512): string {
+    const adjIdx = uint16(hashResult, 0) % nebulaAdjectives.length
+    const nounIdx = uint16(hashResult, 2) % nebulaNouns.length
+    return `${nebulaAdjectives[adjIdx]} ${nebulaNouns[nounIdx]}`
+}
+
+export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string {
+    const seed = Checksum256.from(gameSeed)
+    const locationType = getLocationType(seed, location)
+    if (locationType === LocationType.EMPTY) {
+        throw new Error("System doesn't exist at location")
+    }
+    const seedStr = `${location.x}-${location.y}-${locationType}-name`
+    const hashResult = hash512(seed, seedStr)
+    switch (locationType) {
+        case LocationType.PLANET:
+            return generatePlanetName(hashResult)
+        case LocationType.ASTEROID:
+            return generateAsteroidName(hashResult)
+        case LocationType.NEBULA:
+            return generateNebulaName(hashResult)
+        default:
+            return generatePlanetName(hashResult)
+    }
+}
+
+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 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(
+        Number(loc.type) === LocationType.PLANET ? hashResult.array[2] % 6 : 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 {
+    const staticProps = deriveLocationStatic(gameSeed, coordinates)
+    return ServerContract.Types.location_derived.from({
+        static_props: staticProps,
+        epoch_props: deriveLocationEpoch(epochSeed, coordinates),
+        size: deriveLocationSize(staticProps),
+    })
+}

package/src/goods.ts

@@ -1,124 +0,0 @@
-import {UInt16, UInt16Type, UInt64} from '@wharfkit/antelope'
-import {Coordinates, Good, GoodType, PRECISION} from './types'
-
-// List of goods with titles and descriptions
-const goods: GoodType[] = [
-    {
-        id: 1,
-        name: 'FizzGlo',
-        description: 'Pops with flavor! A neon drink that makes your burps glow.',
-        base_price: 50,
-        mass: 35_000,
-    },
-    // {
-    //     id: 2,
-    //     name: 'ZapSnacks',
-    //     description: 'Electric taste! Spicy edible energy sparks for a tongue-tingling experience.',
-    //     base_price: 0,
-    //     mass: 0,
-    // },
-    {
-        id: 3,
-        name: 'Blob Buddies',
-        description: 'Squishy friends! Clingy, cute and mood-matching pet blobs for every home!',
-        base_price: 95,
-        mass: 60_000,
-    },
-    {
-        id: 4,
-        name: 'TuneTooth',
-        description: 'Whistle while you eat! Edible instrument treats that play tunes when chewed.',
-        base_price: 145,
-        mass: 75_000,
-    },
-    {
-        id: 5,
-        name: 'SunPods',
-        description: 'Miniature suns in your pocket providing on-demand light & warmth.',
-        base_price: 295,
-        mass: 135_000,
-    },
-    // {
-    //     id: 6,
-    //     name: 'Fuzzix',
-    //     description: 'Pocket-sized quantum fluff generator for instant comfy.',
-    //     base_price: 0,
-    //     mass: 0,
-    // },
-    {
-        id: 7,
-        name: 'GlowGo',
-        description: 'Ingestible bioluminescent jelly, your inside glows in the dark!',
-        base_price: 650,
-        mass: 255_000,
-    },
-    // {
-    //     id: 8,
-    //     name: 'KrackleKaps',
-    //     description: 'Capsules packed with tiny firecrackers, spice up meals and parties.',
-    //     base_price: 0,
-    //     mass: 0,
-    // },
-    {
-        id: 9,
-        name: 'PlasmaMints',
-        description: 'Hypercharged candy giving plasma breath capable of cutting through steel.',
-        base_price: 3450,
-        mass: 1_100_000,
-    },
-    {
-        id: 10,
-        name: 'TimeTreats',
-        description: 'Confectionery morsels releasing slow-mo effect over a limited period.',
-        base_price: 8500,
-        mass: 2_100_000,
-    },
-    {
-        id: 11,
-        name: 'QuantumQuencher',
-        description:
-            'Bottled hyper-fluid quenching thirst across multiple parallel realities simultaneously.',
-        base_price: 20_500,
-        mass: 4_100_000,
-    },
-    // {
-    //     id: 12,
-    //     name: 'TransmatterTruffles',
-    //     description: 'Delectable chocolates instantly teleporting consumers short distances.',
-    //     base_price: 0,
-    //     mass: 0,
-    // },
-    {
-        id: 13,
-        name: 'MemoryGum',
-        description: 'Chewable gum storing or replaying memories while being chewed.',
-        base_price: 52_500,
-        mass: 9_500_000,
-    },
-    {
-        id: 14,
-        name: 'SymbioSnack',
-        description: 'Edible alien larvae adopting owner’s taste preference upon consumption.',
-        base_price: 115_000,
-        mass: 16_000_000,
-    },
-]
-
-export const goodIds = goods.map((g) => g.id)
-
-export function getGood(good_id: UInt16Type): Good {
-    const good = goods.find((g) => UInt16.from(good_id).equals(g.id))
-    if (!good) {
-        throw new Error('Good does not exist')
-    }
-    return Good.from({
-        ...good,
-        id: UInt16.from(good.id),
-        base_price: UInt64.from(good.base_price),
-        mass: UInt64.from(good.mass).multiplying(PRECISION),
-    })
-}
-
-export function getGoods(): Good[] {
-    return goods.map((g) => getGood(g.id))
-}