@shipload/sdk 2.0.0-rc2 → 2.0.0-rc4

package/src/types.ts

@@ -62,7 +62,7 @@ export interface ShipLike {
 }
 
 export interface CargoMassInfo {
-    good_id: UInt16Type
+    item_id: UInt16Type
     quantity: UInt32Type
 }
 
@@ -73,6 +73,7 @@ export enum TaskType {
     LOAD = 3,
     UNLOAD = 4,
     EXTRACT = 5,
+    WARP = 6,
 }
 
 export enum LocationType {
@@ -131,8 +132,11 @@ export interface Distance {
     distance: UInt16
 }
 
-@Struct.type('good')
-export class Good extends Struct {
+export type ResourceCategory = 'metal' | 'gas' | 'mineral' | 'organic'
+export type ResourceRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary'
+
+@Struct.type('item')
+export class Item extends Struct {
     @Struct.field(UInt16)
     id!: UInt16
     @Struct.field('string')
@@ -143,14 +147,20 @@ export class Good extends Struct {
     base_price!: UInt32
     @Struct.field(UInt32)
     mass!: UInt32
+    @Struct.field('string')
+    category!: ResourceCategory
+    @Struct.field('string')
+    rarity!: ResourceRarity
+    @Struct.field('string')
+    color!: string
 }
 
-@Struct.type('GoodPrice')
-export class GoodPrice extends Struct {
+@Struct.type('ItemPrice')
+export class ItemPrice extends Struct {
     @Struct.field(UInt16)
     id!: UInt16
-    @Struct.field(Good)
-    good!: Good
+    @Struct.field(Item)
+    item!: Item
     @Struct.field(UInt32)
     price!: UInt32
     @Struct.field(UInt16)

package/src/utils/system.ts

@@ -1,8 +1,10 @@
-import {Checksum256, Checksum256Type, UInt8} from '@wharfkit/antelope'
+import {Checksum256, Checksum256Type, Checksum512, UInt8} from '@wharfkit/antelope'
 import {hash512} from './hash'
-import {Coordinates, CoordinatesType, LocationType, PRECISION} from '../types'
+import {Coordinates, CoordinatesType, LocationType} from '../types'
 import {ServerContract} from '../contracts'
 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
@@ -28,26 +30,58 @@ export function getLocationType(
 }
 
 export function isExtractableLocation(locationType: LocationType): boolean {
-    return locationType === LocationType.ASTEROID || locationType === LocationType.NEBULA
+    return locationType !== LocationType.EMPTY
 }
 
-export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string {
-    const seed = Checksum256.from(gameSeed)
-    if (!hasSystem(seed, location)) {
-        throw new Error("System doesn't exist at location")
-    }
-    const seedStr = `${location.x}${location.y}systemName`
-    const hashResult = hash512(seed, seedStr)
-    const syllableCount = 1 + (hashResult.array[0] % 3)
+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 = hashResult.array[i] % syllables.length
+        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
 }
@@ -81,7 +115,11 @@ export function deriveLocationStatic(
         loc.type = UInt8.from(LocationType.NEBULA)
     }
 
-    loc.subtype = UInt8.from(hashResult.array[2])
+    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])
 
@@ -114,42 +152,3 @@ export function deriveLocation(
         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: []})
-}

package/src/data/goods.json

@@ -1,23 +0,0 @@
-[
-    {
-        "id": 1,
-        "name": "Hydrogen",
-        "description": "A lightweight fuel source essential for interstellar travel.",
-        "base_price": 50,
-        "mass": 15000
-    },
-    {
-        "id": 26,
-        "name": "Iron",
-        "description": "A versatile metal used in construction and manufacturing.",
-        "base_price": 125,
-        "mass": 40000
-    },
-    {
-        "id": 29,
-        "name": "Copper",
-        "description": "A conductive metal vital for electronics and wiring.",
-        "base_price": 200,
-        "mass": 60000
-    }
-]

package/src/market/goods.ts

@@ -1,31 +0,0 @@
-import {UInt16, UInt16Type, UInt32} from '@wharfkit/antelope'
-import {Good} from '../types'
-import goodsData from '../data/goods.json'
-
-const goods = goodsData as Array<{
-    id: number
-    name: string
-    description: string
-    base_price: number
-    mass: number
-}>
-
-export const goodIds = goods.map((g) => g.id)
-
-export function getGood(goodId: UInt16Type): Good {
-    const good = goods.find((g) => UInt16.from(goodId).equals(g.id))
-    if (!good) {
-        throw new Error('Good does not exist')
-    }
-    return Good.from({
-        id: UInt16.from(good.id),
-        name: good.name,
-        description: good.description,
-        base_price: UInt32.from(good.base_price),
-        mass: UInt32.from(good.mass),
-    })
-}
-
-export function getGoods(): Good[] {
-    return goods.map((g) => getGood(g.id))
-}