@shipload/sdk 2.0.0-rc3 → 2.0.0-rc4

package/src/derivation/stratum.ts

@@ -100,17 +100,19 @@ export function deriveResourceStats(seed: bigint): ResourceStats {
     const hashResult = Checksum256.hash(Bytes.from(data))
     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 weibullStat = (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,
+        purity: weibullStat(extractU16(0)),
+        density: weibullStat(extractU16(2)),
+        reactivity: weibullStat(extractU16(4)),
+        resonance: weibullStat(extractU16(6)),
     }
 }

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
 }