@shipload/sdk 0.5.1 → 0.6.0

package/src/market.ts

@@ -75,8 +75,8 @@ export function getRarity(
         // ~40.30% chance = no value change
         return {
             rarity: Rarities.trash,
-            minMultiplier: 0,
-            maxMultiplier: 0,
+            minMultiplier: 1,
+            maxMultiplier: 1.07,
         } // Product is not available
     } else if (rarityRoll < 62508) {
         // (White) ~25.33% chance = slightly lower value
@@ -161,18 +161,32 @@ export function getLocationMultiplier(
     }
 }
 
+export function getSupply(
+    gameSeed: Checksum256Type,
+    state: ServerContract.Types.state_row,
+    location: Coordinates,
+    good_id: UInt16Type
+): number {
+    const seed = `${state.seed}${location.x}${location.y}${good_id}supply`
+    const r = roll(gameSeed, seed)
+    const percent = r / 65535
+    const epoch = 1 + Number(state.epoch) / 90
+    const ship = Math.pow(Number(state.ships), 1 / 3)
+    return UInt64.from((128 / good_id) * percent * ship * epoch).toNumber()
+}
+
 export function marketprice(
     location: ServerContract.ActionParams.Type.coordinates,
     good_id: UInt16Type,
     gameSeed: Checksum256Type,
-    epochSeed: Checksum256Type
-): UInt64 {
-    const {base_price} = getGood(good_id)
-    let price = Number(base_price)
+    state: ServerContract.Types.state_row
+): GoodPrice {
+    const good = getGood(good_id)
+    let price = Number(good.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, epochSeed, location, good_id)
+    const rarityMultiplier = getRarityMultiplier(gameSeed, state.seed, location, good_id)
     price *= rarityMultiplier
 
     // Location multiplier of the deal (static, based on game seed)
@@ -180,16 +194,21 @@ export function marketprice(
     const locationMultiplier = getLocationMultiplier(gameSeed, location, good_id)
     price *= locationMultiplier
 
-    return UInt64.from(price)
+    // Determine the current supply of the good at the location
+    const supply = getSupply(gameSeed, state, location, good_id)
+
+    return GoodPrice.from({
+        id: good_id,
+        good,
+        price: UInt64.from(price),
+        supply: UInt64.from(supply),
+    })
 }
 
 export function marketprices(
     location: ServerContract.ActionParams.Type.coordinates,
     gameSeed: Checksum256Type,
-    epochSeed: Checksum256Type
+    state: ServerContract.Types.state_row
 ): GoodPrice[] {
-    return getGoods().map((good) => {
-        const price = marketprice(location, good.id, gameSeed, epochSeed)
-        return {price, good: good}
-    })
+    return getGoods().map((good) => marketprice(location, good.id, gameSeed, state))
 }

package/src/shipload.ts

@@ -1,5 +1,7 @@
 import {
     APIClient,
+    Bytes,
+    Checksum256,
     Name,
     NameType,
     Serializer,
@@ -7,7 +9,7 @@ import {
     UInt64,
     UInt64Type,
 } from '@wharfkit/antelope'
-import {Distance, GoodPrice} from './types'
+import {Coordinates, Distance, GoodPrice} from './types'
 import {marketprice, marketprices} from './market'
 import {PlatformContract, ServerContract} from './contracts'
 import {ERROR_SYSTEM_NOT_INITIALIZED} from './errors'
@@ -138,10 +140,10 @@ export class Shipload {
     async marketprice(
         location: ServerContract.ActionParams.Type.coordinates,
         good_id: number
-    ): Promise<UInt64> {
+    ): Promise<GoodPrice> {
         const game = await this.getGame()
         const state = await this.getState()
-        return marketprice(location, good_id, game.config.seed, state.seed)
+        return marketprice(location, good_id, game.config.seed, state)
     }
 
     async marketprices(
@@ -149,7 +151,7 @@ export class Shipload {
     ): Promise<GoodPrice[]> {
         const game = await this.getGame()
         const state = await this.getState()
-        return marketprices(location, game.config.seed, state.seed)
+        return marketprices(location, game.config.seed, state)
     }
 
     async hasSystem(location: ServerContract.ActionParams.Type.coordinates): Promise<boolean> {
@@ -218,4 +220,13 @@ export class Shipload {
         const game = await this.getGame()
         return getEpochInfo(game, UInt64.from(height))
     }
+
+    async getLocation(location: Coordinates) {
+        const hash = Checksum256.hash(Bytes.from(`${location.x}-${location.y}`, 'utf8'))
+        return this.server.table('location').all({
+            index_position: 'secondary',
+            from: hash,
+            to: hash,
+        })
+    }
 }

package/src/travel.ts

@@ -155,7 +155,7 @@ export function calc_mass_penalty(ship: ServerContract.Types.ship_row, mass: UIn
     const maximum = Number(ship.stats.maxmass)
     if (mass > ship.stats.maxmass) {
         const overage = (current - maximum) / PRECISION
-        const penalty = TRAVEL_MAXMASS_PENALTY * Math.exp(0.00005 * overage)
+        const penalty = TRAVEL_MAXMASS_PENALTY * Math.exp(0.000005 * overage)
         return UInt32.from(penalty)
     }
     return UInt32.from(0)

package/src/types.ts

@@ -1,4 +1,4 @@
-import {UInt16, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {Struct, UInt16, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from './contracts'
 
 export const PRECISION = 10000
@@ -19,12 +19,18 @@ export interface Distance {
     distance: UInt16
 }
 
-export interface Good {
-    id: UInt16
-    name: string
-    description: string
-    base_price: UInt64
-    mass: UInt64
+@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 interface GoodType {
@@ -35,9 +41,16 @@ export interface GoodType {
     mass: UInt64Type
 }
 
-export interface GoodPrice {
-    good: Good
-    price: UInt64
+@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 interface Coordinates extends ServerContract.ActionParams.Type.coordinates {}