@shipload/sdk 2.0.0-rc3 → 2.0.0-rc5

package/src/derivation/index.ts

@@ -6,13 +6,13 @@ export {
     getResourceWeight,
     getLocationCandidates,
     getDepthThreshold,
-    getResourceRarity,
+    getResourceTier,
     depthScaleFactor,
-    DEPTH_THRESHOLD_COMMON,
-    DEPTH_THRESHOLD_UNCOMMON,
-    DEPTH_THRESHOLD_RARE,
-    DEPTH_THRESHOLD_EPIC,
-    DEPTH_THRESHOLD_LEGENDARY,
+    DEPTH_THRESHOLD_T1,
+    DEPTH_THRESHOLD_T2,
+    DEPTH_THRESHOLD_T3,
+    DEPTH_THRESHOLD_T4,
+    DEPTH_THRESHOLD_T5,
     LOCATION_MIN_DEPTH,
     LOCATION_MAX_DEPTH,
     YIELD_THRESHOLD,
@@ -23,3 +23,5 @@ export {
     PLANET_SUBTYPE_OCEAN,
     PLANET_SUBTYPE_INDUSTRIAL,
 } from './resources'
+
+export * from './stats'

package/src/derivation/resources.ts

@@ -1,10 +1,10 @@
-import {ResourceRarity} from '../types'
+import {ResourceTier} from '../types'
 
-export const DEPTH_THRESHOLD_COMMON = 0
-export const DEPTH_THRESHOLD_UNCOMMON = 2000
-export const DEPTH_THRESHOLD_RARE = 10000
-export const DEPTH_THRESHOLD_EPIC = 30000
-export const DEPTH_THRESHOLD_LEGENDARY = 55000
+export const DEPTH_THRESHOLD_T1 = 0
+export const DEPTH_THRESHOLD_T2 = 2000
+export const DEPTH_THRESHOLD_T3 = 10000
+export const DEPTH_THRESHOLD_T4 = 30000
+export const DEPTH_THRESHOLD_T5 = 55000
 
 export const LOCATION_MIN_DEPTH = 500
 export const LOCATION_MAX_DEPTH = 65535
@@ -20,84 +20,85 @@ export const PLANET_SUBTYPE_INDUSTRIAL = 5
 
 interface ResourceEntry {
     id: number
-    rarity: ResourceRarity
+    tier: ResourceTier
 }
 
 const RESOURCE_CATALOG: ResourceEntry[] = [
-    {id: 26, rarity: 'common'},
-    {id: 1, rarity: 'common'},
-    {id: 14, rarity: 'common'},
-    {id: 6, rarity: 'common'},
-    {id: 29, rarity: 'uncommon'},
-    {id: 2, rarity: 'uncommon'},
-    {id: 1000, rarity: 'uncommon'},
-    {id: 1003, rarity: 'uncommon'},
-    {id: 22, rarity: 'rare'},
-    {id: 18, rarity: 'rare'},
-    {id: 1001, rarity: 'rare'},
-    {id: 1002, rarity: 'rare'},
-    {id: 74, rarity: 'epic'},
-    {id: 54, rarity: 'epic'},
+    {id: 26, tier: 't1'},
+    {id: 13, tier: 't2'},
+    {id: 24, tier: 't3'},
+    {id: 29, tier: 't1'},
+    {id: 47, tier: 't2'},
+    {id: 79, tier: 't3'},
+    {id: 1, tier: 't1'},
+    {id: 2, tier: 't2'},
+    {id: 18, tier: 't3'},
+    {id: 14, tier: 't1'},
+    {id: 1000, tier: 't2'},
+    {id: 1001, tier: 't3'},
+    {id: 6, tier: 't1'},
+    {id: 1003, tier: 't2'},
+    {id: 1002, tier: 't3'},
 ]
 
-export function getDepthThreshold(rarity: ResourceRarity): number {
-    switch (rarity) {
-        case 'common':
-            return DEPTH_THRESHOLD_COMMON
-        case 'uncommon':
-            return DEPTH_THRESHOLD_UNCOMMON
-        case 'rare':
-            return DEPTH_THRESHOLD_RARE
-        case 'epic':
-            return DEPTH_THRESHOLD_EPIC
-        case 'legendary':
-            return DEPTH_THRESHOLD_LEGENDARY
+export function getDepthThreshold(tier: ResourceTier): number {
+    switch (tier) {
+        case 't1':
+            return DEPTH_THRESHOLD_T1
+        case 't2':
+            return DEPTH_THRESHOLD_T2
+        case 't3':
+            return DEPTH_THRESHOLD_T3
+        case 't4':
+            return DEPTH_THRESHOLD_T4
+        case 't5':
+            return DEPTH_THRESHOLD_T5
     }
 }
 
-export function getResourceRarity(itemId: number): ResourceRarity {
+export function getResourceTier(itemId: number): ResourceTier {
     const entry = RESOURCE_CATALOG.find((r) => r.id === itemId)
-    return entry ? entry.rarity : 'legendary'
+    return entry ? entry.tier : 't5'
 }
 
 export function getResourceWeight(itemId: number, stratum: number): number {
-    const rarity = getResourceRarity(itemId)
-    const threshold = getDepthThreshold(rarity)
+    const tier = getResourceTier(itemId)
+    const threshold = getDepthThreshold(tier)
     if (stratum < threshold) return 0
 
     const depthAbove = stratum - threshold
 
-    switch (rarity) {
-        case 'common':
+    switch (tier) {
+        case 't1':
             if (stratum < 2000) return 100
             if (stratum < 10000) return 80
             if (stratum < 30000) return 50
             return 30
-        case 'uncommon':
+        case 't2':
             if (depthAbove < 3000) return 40
             if (depthAbove < 8000) return 60
             return 50
-        case 'rare':
+        case 't3':
             if (depthAbove < 5000) return 20
             if (depthAbove < 15000) return 35
             return 40
-        case 'epic':
+        case 't4':
             if (depthAbove < 10000) return 10
             if (depthAbove < 25000) return 20
             return 30
-        case 'legendary':
+        case 't5':
             return 10
     }
 }
 
-const ASTEROID_RESOURCES = [26, 29, 22, 74, 14, 1000, 1001]
-const NEBULA_RESOURCES = [1, 2, 18, 54]
-const GAS_GIANT_RESOURCES = [1, 2, 18, 54]
-const ROCKY_RESOURCES = [26, 29, 22, 74, 6, 1003, 1002]
-const TERRESTRIAL_RESOURCES = [6, 1003, 1002, 1001]
-const ICY_RESOURCES = [6, 14, 1000, 1001, 18]
-const OCEAN_RESOURCES = [1, 2, 1003, 1002]
-const INDUSTRIAL_RESOURCES = [26, 29, 22, 74, 14, 1000, 54]
+const ASTEROID_RESOURCES = [26, 13, 24, 29, 47]
+const NEBULA_RESOURCES = [47, 79, 1, 2, 18]
+const GAS_GIANT_RESOURCES = [1, 2, 18, 14, 6]
+const ROCKY_RESOURCES = [26, 13, 24, 14, 1000, 1001, 1002]
+const TERRESTRIAL_RESOURCES = [29, 47, 14, 1000, 6, 1003, 1002]
+const ICY_RESOURCES = [26, 1, 2, 14, 1001, 6, 1003]
+const OCEAN_RESOURCES = [29, 79, 1, 18, 6, 1003, 1002]
+const INDUSTRIAL_RESOURCES = [26, 13, 24, 29, 79, 1000, 1001]
 
 export function getLocationCandidates(locationType: number, subtype: number): number[] {
     if (locationType === 2) return ASTEROID_RESOURCES
@@ -128,8 +129,8 @@ export function getEligibleResources(
 ): number[] {
     const candidates = getLocationCandidates(locationType, subtype)
     return candidates.filter((itemId) => {
-        const rarity = getResourceRarity(itemId)
-        const threshold = getDepthThreshold(rarity)
+        const tier = getResourceTier(itemId)
+        const threshold = getDepthThreshold(tier)
         return stratum >= threshold
     })
 }

package/src/derivation/stats.ts

@@ -0,0 +1,70 @@
+import type {ResourceCategory} from '../types'
+
+export interface StatDefinition {
+    key: string
+    label: string
+    abbreviation: string
+    purpose: string
+    inverted?: boolean
+}
+
+const METAL_STATS: StatDefinition[] = [
+    {key: 'strength', label: 'Strength', abbreviation: 'STR', purpose: 'Raw structural/mechanical force'},
+    {key: 'tolerance', label: 'Tolerance', abbreviation: 'TOL', purpose: 'Ability to withstand heat, pressure, and stress extremes'},
+    {key: 'density', label: 'Density', abbreviation: 'DEN', purpose: 'Mass per unit', inverted: true},
+]
+
+const PRECIOUS_STATS: StatDefinition[] = [
+    {key: 'conductivity', label: 'Conductivity', abbreviation: 'CON', purpose: 'Efficiency of energy/signal transfer'},
+    {key: 'ductility', label: 'Ductility', abbreviation: 'DUC', purpose: 'Ability to be worked into fine, precise shapes'},
+    {key: 'reflectivity', label: 'Reflectivity', abbreviation: 'REF', purpose: 'Surface quality for heat management and precision optics'},
+]
+
+const GAS_STATS: StatDefinition[] = [
+    {key: 'volatility', label: 'Volatility', abbreviation: 'VOL', purpose: 'Energy release potential for propulsion and force'},
+    {key: 'reactivity', label: 'Reactivity', abbreviation: 'REA', purpose: 'Chemical interaction speed for processing and penetration'},
+    {key: 'thermal', label: 'Thermal', abbreviation: 'THM', purpose: 'Heat capacity for thermal management'},
+]
+
+const MINERAL_STATS: StatDefinition[] = [
+    {key: 'resonance', label: 'Resonance', abbreviation: 'RES', purpose: 'Energy field interaction — storage, focusing, projection'},
+    {key: 'hardness', label: 'Hardness', abbreviation: 'HRD', purpose: 'Resistance to wear — cutting surfaces, penetration'},
+    {key: 'clarity', label: 'Clarity', abbreviation: 'CLR', purpose: 'Crystalline perfection — precision optics'},
+]
+
+const ORGANIC_STATS: StatDefinition[] = [
+    {key: 'plasticity', label: 'Plasticity', abbreviation: 'PLA', purpose: 'Ease of reshaping — speeds processing'},
+    {key: 'insulation', label: 'Insulation', abbreviation: 'INS', purpose: 'Energy containment — reduces energy loss'},
+    {key: 'purity', label: 'Purity', abbreviation: 'PUR', purpose: 'Biological cleanliness — better composites and lubricants'},
+]
+
+const STAT_MAP: Record<ResourceCategory, StatDefinition[]> = {
+    metal: METAL_STATS,
+    precious: PRECIOUS_STATS,
+    gas: GAS_STATS,
+    mineral: MINERAL_STATS,
+    organic: ORGANIC_STATS,
+}
+
+export function getStatDefinitions(category: ResourceCategory): StatDefinition[] {
+    return STAT_MAP[category]
+}
+
+export function getStatName(category: ResourceCategory, index: 0 | 1 | 2): StatDefinition {
+    return STAT_MAP[category][index]
+}
+
+export interface NamedStats {
+    definitions: StatDefinition[]
+    values: [number, number, number]
+}
+
+export function resolveStats(
+    category: ResourceCategory,
+    stats: {stat1: number; stat2: number; stat3: number}
+): NamedStats {
+    return {
+        definitions: STAT_MAP[category],
+        values: [stats.stat1, stats.stat2, stats.stat3],
+    }
+}

package/src/derivation/stratum.ts

@@ -16,10 +16,9 @@ export interface StratumInfo {
 }
 
 export interface ResourceStats {
-    purity: number
-    density: number
-    reactivity: number
-    resonance: number
+    stat1: number
+    stat2: number
+    stat3: number
 }
 
 export function deriveStratum(
@@ -94,23 +93,26 @@ export function deriveStratum(
 }
 
 export function deriveResourceStats(seed: bigint): ResourceStats {
-    const seedStr = seed.toString()
-    const encoder = new TextEncoder()
-    const data = encoder.encode(seedStr)
-    const hashResult = Checksum256.hash(Bytes.from(data))
+    const seedBytes = new Uint8Array(8)
+    for (let i = 7; i >= 0; i--) {
+        seedBytes[i] = Number(seed & 0xFFn)
+        seed >>= 8n
+    }
+    const hashResult = Checksum256.hash(Bytes.from(seedBytes))
     const hashBytes = hashResult.array
 
-    const extractU32 = (offset: number): number =>
-        ((hashBytes[offset] << 24) |
-            (hashBytes[offset + 1] << 16) |
-            (hashBytes[offset + 2] << 8) |
-            hashBytes[offset + 3]) >>>
-        0
+    const extractU16 = (offset: number): number => (hashBytes[offset] << 8) | hashBytes[offset + 1]
+
+    const weibull = (raw: number): number => {
+        const u = raw / 65536
+        let x = 0.27 * Math.sqrt(-Math.log(1 - u))
+        if (x > 1) x = 1
+        return Math.floor(x * 999) + 1
+    }
 
     return {
-        purity: (extractU32(0) % 1000) + 1,
-        density: (extractU32(4) % 1000) + 1,
-        reactivity: (extractU32(8) % 1000) + 1,
-        resonance: (extractU32(12) % 1000) + 1,
+        stat1: weibull(extractU16(0)),
+        stat2: weibull(extractU16(2)),
+        stat3: weibull(extractU16(4)),
     }
 }

package/src/index-module.ts

@@ -47,7 +47,7 @@ export type {EntityRefInput} from './managers/actions'
 export {getItem, getItems, itemIds} from './market/items'
 export {getCurrentEpoch, getEpochInfo} from './scheduling/epoch'
 export type {EpochInfo} from './scheduling/epoch'
-export {marketPrice, marketPrices, getRarity, Rarities} from './market/market'
+export {marketPrice, marketPrices, getRarity, getRarityMultiplier, Rarities} from './market/market'
 export type {Rarity} from './market/market'
 export {
     getSystemName,
@@ -67,13 +67,13 @@ export {
     getResourceWeight,
     getLocationCandidates,
     getDepthThreshold,
-    getResourceRarity,
+    getResourceTier,
     depthScaleFactor,
-    DEPTH_THRESHOLD_COMMON,
-    DEPTH_THRESHOLD_UNCOMMON,
-    DEPTH_THRESHOLD_RARE,
-    DEPTH_THRESHOLD_EPIC,
-    DEPTH_THRESHOLD_LEGENDARY,
+    DEPTH_THRESHOLD_T1,
+    DEPTH_THRESHOLD_T2,
+    DEPTH_THRESHOLD_T3,
+    DEPTH_THRESHOLD_T4,
+    DEPTH_THRESHOLD_T5,
     LOCATION_MIN_DEPTH,
     LOCATION_MAX_DEPTH,
     PLANET_SUBTYPE_GAS_GIANT,
@@ -86,6 +86,9 @@ export {
 
 export type {StratumInfo, ResourceStats} from './derivation'
 
+export {getStatDefinitions, getStatName, resolveStats} from './derivation'
+export type {StatDefinition, NamedStats} from './derivation'
+
 export {hash, hash512} from './utils/hash'
 
 export type {Deal, FindDealsOptions} from './trading/deal'

package/src/market/items.ts

@@ -10,7 +10,7 @@ const items: Item[] = itemsData.map((g) =>
         base_price: g.base_price,
         mass: g.mass,
         category: g.category,
-        rarity: g.rarity,
+        tier: g.tier,
         color: g.color,
     })
 )

package/src/market/market.ts

@@ -14,9 +14,9 @@ export enum Rarities {
 }
 
 export interface Rarity {
-    rarity: Rarities // The rarity description of this price
-    minMultiplier: number // The minimum multiplier for this rarity
-    maxMultiplier: number // The maximum multiplier for this rarity
+    rarity: Rarities
+    minMultiplier: number
+    maxMultiplier: number
 }
 
 export function getRarity(
@@ -29,77 +29,66 @@ export function getRarity(
     const rarityRoll = roll(gameSeed, seed)
 
     if (rarityRoll < 13) {
-        // (Orange) ~0.02% chance = incredibly high value
         return {
             rarity: Rarities.legendary,
             minMultiplier: 2.25,
             maxMultiplier: 3.0,
         }
     } else if (rarityRoll < 176) {
-        // (Purple) ~0.25% chance = super high value
         return {
             rarity: Rarities.epic,
             minMultiplier: 1.75,
             maxMultiplier: 2.25,
         }
     } else if (rarityRoll < 996) {
-        // (Blue) ~1.25% chance = very high value
         return {
             rarity: Rarities.rare,
             minMultiplier: 1.4,
             maxMultiplier: 1.75,
         }
     } else if (rarityRoll < 2966) {
-        // (Green) ~3.00% chance = high value
         return {
             rarity: Rarities.uncommon,
             minMultiplier: 1.225,
             maxMultiplier: 1.4,
         }
     } else if (rarityRoll < 19568) {
-        // (White) ~25.33% chance = slightly higher value
         return {
             rarity: Rarities.common,
             minMultiplier: 1.07,
             maxMultiplier: 1.225,
         }
     } else if (rarityRoll < 45988) {
-        // ~40.30% chance = no value change
         return {
             rarity: Rarities.trash,
             minMultiplier: 1,
             maxMultiplier: 1.07,
-        } // Product is not available
+        }
     } else if (rarityRoll < 62508) {
-        // (White) ~25.33% chance = slightly lower value
         return {
             rarity: Rarities.common,
             minMultiplier: 0.925,
             maxMultiplier: 1,
         }
     } else if (rarityRoll < 64518) {
-        // (Green) ~3.00% chance = low value
         return {
             rarity: Rarities.uncommon,
             minMultiplier: 0.77,
             maxMultiplier: 0.925,
         }
     } else if (rarityRoll < 65437) {
-        // (Blue) ~1.25% chance = very low value
         return {
             rarity: Rarities.rare,
             minMultiplier: 0.595,
             maxMultiplier: 0.77,
         }
     } else if (rarityRoll < 65523) {
-        // (Purple) ~0.25% chance = super low value
         return {
             rarity: Rarities.epic,
             minMultiplier: 0.41,
             maxMultiplier: 0.595,
         }
     } else {
-        // (Orange) ~0.02% chance = incredibly low value
         return {
             rarity: Rarities.legendary,
             minMultiplier: 0.285,
@@ -178,8 +167,6 @@ export function marketPrice(
     const item = getItem(goodId)
     let price = Number(item.base_price)
 
-    // Rarity multiplier of the deal (changes with epoch)
-    // Large impact range on price, from 0.285x to 3.0x
     const rarityMultiplier = getRarityMultiplier(gameSeed, state.seed, location, goodId)
     price *= rarityMultiplier
 

package/src/types.ts

@@ -132,8 +132,8 @@ export interface Distance {
     distance: UInt16
 }
 
-export type ResourceCategory = 'metal' | 'gas' | 'mineral' | 'organic'
-export type ResourceRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary'
+export type ResourceCategory = 'metal' | 'precious' | 'gas' | 'mineral' | 'organic'
+export type ResourceTier = 't1' | 't2' | 't3' | 't4' | 't5'
 
 @Struct.type('item')
 export class Item extends Struct {
@@ -150,7 +150,7 @@ export class Item extends Struct {
     @Struct.field('string')
     category!: ResourceCategory
     @Struct.field('string')
-    rarity!: ResourceRarity
+    tier!: ResourceTier
     @Struct.field('string')
     color!: string
 }

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} 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
@@ -31,23 +33,55 @@ export function isExtractableLocation(locationType: LocationType): boolean {
     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
 }