@shipload/sdk 0.2.0 → 0.3.0

package/src/contracts/server.ts

@@ -1,4 +1,11 @@
-import type {Action, Checksum256Type, Int64Type, NameType, UInt64Type} from '@wharfkit/antelope'
+import type {
+    Action,
+    Checksum256Type,
+    Int64Type,
+    NameType,
+    UInt16Type,
+    UInt64Type,
+} from '@wharfkit/antelope'
 import {
     ABI,
     Blob,
@@ -17,7 +24,7 @@ import {
 import type {ActionOptions, ContractArgs, PartialBy, Table} from '@wharfkit/contract'
 import {Contract as BaseContract} from '@wharfkit/contract'
 export const abiBlob = Blob.from(
-    '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'
+    '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'
 )
 export const abi = ABI.from(abiBlob)
 export namespace Types {
@@ -32,8 +39,6 @@ export namespace Types {
     }
     @Struct.type('buygoods')
     export class buygoods extends Struct {
-        @Struct.field(Name)
-        buyer!: Name
         @Struct.field(UInt64)
         ship_id!: UInt64
         @Struct.field(UInt64)
@@ -51,6 +56,8 @@ export namespace Types {
         good_id!: UInt64
         @Struct.field(UInt64)
         quantity!: UInt64
+        @Struct.field(UInt64)
+        loaded!: UInt64
     }
     @Struct.type('cleartable')
     export class cleartable extends Struct {
@@ -80,6 +87,13 @@ export namespace Types {
         @Struct.field(coordinates)
         destination!: coordinates
     }
+    @Struct.type('good_price')
+    export class good_price extends Struct {
+        @Struct.field(UInt16)
+        id!: UInt16
+        @Struct.field(UInt64)
+        price!: UInt64
+    }
     @Struct.type('hash')
     export class hash extends Struct {
         @Struct.field('string')
@@ -108,6 +122,18 @@ export namespace Types {
         @Struct.field(UInt32)
         thrust!: UInt32
     }
+    @Struct.type('marketprice')
+    export class marketprice extends Struct {
+        @Struct.field(coordinates)
+        location!: coordinates
+        @Struct.field(UInt16)
+        good_id!: UInt16
+    }
+    @Struct.type('marketprices')
+    export class marketprices extends Struct {
+        @Struct.field(coordinates)
+        location!: coordinates
+    }
     @Struct.type('player_row')
     export class player_row extends Struct {
         @Struct.field(Name)
@@ -119,8 +145,6 @@ export namespace Types {
     }
     @Struct.type('sellgoods')
     export class sellgoods extends Struct {
-        @Struct.field(Name)
-        seller!: Name
         @Struct.field(UInt64)
         ship_id!: UInt64
         @Struct.field(UInt64)
@@ -135,14 +159,17 @@ export namespace Types {
         @Struct.field(UInt64)
         value!: UInt64
     }
+    @Struct.type('ship_state')
+    export class ship_state extends Struct {
+        @Struct.field(UInt32)
+        energy!: UInt32
+    }
     @Struct.type('ship_stats')
     export class ship_stats extends Struct {
         @Struct.field(UInt32)
         capacity!: UInt32
         @Struct.field(UInt32)
         drain!: UInt32
-        @Struct.field(UInt32)
-        energy!: UInt32
         @Struct.field(UInt64)
         mass!: UInt64
         @Struct.field(UInt16)
@@ -175,6 +202,8 @@ export namespace Types {
         skin!: UInt8
         @Struct.field(UInt8)
         tier!: UInt8
+        @Struct.field(ship_state)
+        state!: ship_state
         @Struct.field(ship_stats)
         stats!: ship_stats
         @Struct.field(loader_stats)
@@ -279,7 +308,6 @@ export namespace ActionParams {
         id: UInt64Type
     }
     export interface buygoods {
-        buyer: NameType
         ship_id: UInt64Type
         good_id: UInt64Type
         quantity: UInt64Type
@@ -306,8 +334,14 @@ export namespace ActionParams {
     export interface join {
         account: NameType
     }
+    export interface marketprice {
+        location: Type.coordinates
+        good_id: UInt16Type
+    }
+    export interface marketprices {
+        location: Type.coordinates
+    }
     export interface sellgoods {
-        seller: NameType
         ship_id: UInt64Type
         good_id: UInt64Type
         quantity: UInt64Type
@@ -333,6 +367,8 @@ export interface ActionNameParams {
     hash: ActionParams.hash
     init: ActionParams.init
     join: ActionParams.join
+    marketprice: ActionParams.marketprice
+    marketprices: ActionParams.marketprices
     sellgoods: ActionParams.sellgoods
     test: ActionParams.test
     travel: ActionParams.travel
@@ -342,6 +378,8 @@ export type ActionNames = keyof ActionNameParams
 export interface ActionReturnValues {
     esttravel: Types.travel_summary
     hash: Checksum512
+    marketprice: Types.good_price
+    marketprices: Types.good_price[]
 }
 export type ActionReturnNames = keyof ActionReturnValues
 export class Contract extends BaseContract {

package/src/contracts.ts

@@ -0,0 +1,2 @@
+export * as PlatformContract from './contracts/platform'
+export * as ServerContract from './contracts/server'

package/src/errors.ts

@@ -0,0 +1,9 @@
+export const ERROR_SYSTEM_NOT_INITIALIZED = 'System not initialized'
+export const GOOD_DOES_NOT_EXIST = 'Good does not exist'
+export const GOOD_NOT_AVAILABLE_AT_LOCATION = 'Good not available at location'
+export const PLAYER_NOT_FOUND = 'Player not found'
+export const SHIP_NOT_FOUND = 'Ship not found'
+export const SHIP_CANNOT_BUY_TRAVELING = 'Ship cannot buy while traveling'
+export const INSUFFICIENT_BALANCE = 'Insufficient balance'
+export const INSUFFICIENT_GOOD_QUANTITY = 'Insufficient good quantity'
+export const REQUIRES_MORE_THAN_ONE = 'Requires more than one'

package/src/goods.ts

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

package/src/hash.ts

@@ -1,6 +1,10 @@
 import {Bytes, Checksum256Type, Checksum512} from '@wharfkit/antelope'
 
-export function hash(seed: Checksum256Type, string: string): string {
+export function hash(seed: Checksum256Type, string: string): Checksum512 {
     const bytes = Bytes.from(`${seed}${string}`, 'utf8')
-    return String(Checksum512.hash(bytes))
+    return Checksum512.hash(bytes)
+}
+
+export function hashBytes(seed: Checksum256Type, string: string): Uint8Array {
+    return hash(seed, string).array
 }

package/src/index-module.ts

@@ -1,5 +1,7 @@
+export * from './contracts'
 export * from './hash'
 export * from './travel'
 export * from './types'
-export * as PlatformContract from './contracts/platform'
-export * as ServerContract from './contracts/server'
+export * from './goods'
+export * from './market'
+export * from './errors'

package/src/market.ts

@@ -0,0 +1,58 @@
+import {Coordinates, GoodPrice} from './types'
+import {getGood, goods} from './goods'
+import {Checksum256Type, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {roll} from './rolls'
+
+export async function marketprice(
+    location: Coordinates,
+    good_id: UInt16Type,
+    gameSeed: Checksum256Type,
+    epochSeed: Checksum256Type
+): Promise<UInt64> {
+    const good = getGood(good_id)
+    const rollSeed = `${location.x}${epochSeed}${location.y}${good_id}`
+    const rollValue = roll(gameSeed, rollSeed)
+    return priceFromRoll(good.base_price, rollValue)
+}
+
+export async function marketprices(
+    location: Coordinates,
+    gameSeed: Checksum256Type,
+    epochSeed: Checksum256Type
+): Promise<GoodPrice[]> {
+    return Promise.all(
+        goods.map(async (good) => {
+            const price = await marketprice(location, good.id, gameSeed, epochSeed)
+            return {price, id: good.id}
+        })
+    )
+}
+
+export function priceFromRoll(basePrice: UInt64Type, roll: number): UInt64 {
+    basePrice = Number(basePrice)
+    let price: number
+    if (roll < 13) {
+        price = basePrice * 2.25 // ~0.02% chance
+    } else if (roll < 176) {
+        price = basePrice * 1.75 // ~0.25% chance
+    } else if (roll < 996) {
+        price = basePrice * 1.4 // ~1.25% chance
+    } else if (roll < 2966) {
+        price = basePrice * 1.225 // ~3.00% chance
+    } else if (roll < 19568) {
+        price = basePrice * 1.07 // ~25.33% chance
+    } else if (roll < 45988) {
+        price = 0 // ~40.30% chance
+    } else if (roll < 62508) {
+        price = basePrice * 0.925 // ~25.33% chance
+    } else if (roll < 64518) {
+        price = basePrice * 0.77 // ~3.00% chance
+    } else if (roll < 65437) {
+        price = basePrice * 0.595 // ~1.25% chance
+    } else if (roll < 65523) {
+        price = basePrice * 0.41 // ~0.25% chance
+    } else {
+        price = basePrice * 0.285 // ~0.02% chance
+    }
+    return UInt64.from(price)
+}

package/src/rolls.ts

@@ -0,0 +1,8 @@
+import {Checksum256Type} from '@wharfkit/antelope'
+import {hashBytes} from './hash'
+
+export function roll(game_seed: Checksum256Type, roll_seed: string): number {
+    const byteArray = hashBytes(game_seed, roll_seed)
+    // Combine the first two bytes to form a uint16_t value
+    return (byteArray[0] << 8) | byteArray[1]
+}

package/src/shipload.ts

@@ -1 +1,59 @@
-export class Shipload {}
+import {APIClient, UInt64} from '@wharfkit/antelope'
+import {Coordinates, GoodPrice} from './types'
+import {marketprice, marketprices} from './market'
+import {ServerContract} from './contracts'
+import {ERROR_SYSTEM_NOT_INITIALIZED} from './errors'
+import {ChainDefinition} from '@wharfkit/session'
+import ContractKit, {Contract} from '@wharfkit/contract'
+
+interface ShiploadOptions {
+    contractName?: string
+    client?: APIClient
+}
+
+interface ShiploadConstructorOptions extends ShiploadOptions {
+    serverContract: Contract
+}
+
+export class Shipload {
+    private client: APIClient
+    private server: Contract
+
+    constructor(chain: ChainDefinition, {client, serverContract}: ShiploadConstructorOptions) {
+        this.client = client || new APIClient({url: chain.url})
+
+        this.server = serverContract
+            ? serverContract
+            : new ServerContract.Contract({client: this.client})
+    }
+
+    static async load(chain: ChainDefinition, shiploadOptions: ShiploadOptions): Promise<Shipload> {
+        let server: Contract = new ServerContract.Contract({
+            client: new APIClient({url: chain.url}),
+        })
+        if (shiploadOptions.contractName) {
+            const client = shiploadOptions.client || new APIClient({url: chain.url})
+            const contractKit = new ContractKit({client})
+            server = await contractKit.load(shiploadOptions.contractName)
+        }
+        return new Shipload(chain, {...shiploadOptions, serverContract: server})
+    }
+
+    async getState(): Promise<ServerContract.Types.state_row> {
+        const state = await this.server.table('state').get()
+        if (!state) {
+            throw new Error(ERROR_SYSTEM_NOT_INITIALIZED)
+        }
+        return state
+    }
+
+    async marketprice(location: Coordinates, good_id: number): Promise<UInt64> {
+        const {seed, epochseed} = await this.getState()
+        return marketprice(location, good_id, seed, epochseed)
+    }
+
+    async marketprices(location: Coordinates): Promise<GoodPrice[]> {
+        const {seed, epochseed} = await this.getState()
+        return marketprices(location, seed, epochseed)
+    }
+}

package/src/travel.ts

@@ -1,6 +1,10 @@
-import {Coordinates, ServerContract} from './index-module'
+import {Checksum256} from '@wharfkit/antelope'
 
-export function distance(ship: ServerContract.Types.ship_row): number {
+import {ServerContract} from './contracts'
+import {hash} from './hash'
+import {Coordinates, Distance} from './types'
+
+export function distanceTraveled(ship: ServerContract.Types.ship_row): number {
     if (ship.travelplan) {
         const {departure, duration} = ship.travelplan
         return (+new Date() - +departure.toDate()) / (Number(duration) * 1000)
@@ -8,6 +12,12 @@ export function distance(ship: ServerContract.Types.ship_row): number {
     return 0
 }
 
+export function distanceBetweenPoints(x1: number, y1: number, x2: number, y2: number) {
+    const x = Math.pow(x1 - x2, 2)
+    const y = Math.pow(y1 - y2, 2)
+    return Math.sqrt(x + y)
+}
+
 export function lerp(origin: Coordinates, destination: Coordinates, time: number) {
     return {
         x: (1 - time) * origin.x + time * destination.x,
@@ -18,3 +28,38 @@ export function lerp(origin: Coordinates, destination: Coordinates, time: number
 export function rotation(origin: Coordinates, destination: Coordinates) {
     return Math.atan2(destination.y - origin.y, destination.x - origin.x) * (180 / Math.PI) + 90
 }
+
+export function hasPlanet(seed: Checksum256, coords: Coordinates): boolean {
+    const str = ['system', coords.x, coords.y].join('-')
+    return String(hash(seed, str)).slice(0, 2) === '00'
+}
+
+export function findNearbyPlanets(
+    seed: Checksum256,
+    origin: Coordinates,
+    maxDistance = 20
+): Distance[] {
+    const nearbySystems: Distance[] = []
+
+    const xMin = origin.x - maxDistance
+    const xMax = origin.x + maxDistance
+    const yMin = origin.y - maxDistance
+    const yMax = origin.y + maxDistance
+
+    for (let x = xMin; x <= xMax; x++) {
+        for (let y = yMin; y <= yMax; y++) {
+            const samePlace = x === origin.x && y === origin.y
+            if (!samePlace) {
+                const distance = distanceBetweenPoints(origin.x, origin.y, x, y)
+                if (distance <= maxDistance) {
+                    const system = hasPlanet(seed, {x, y})
+                    if (system) {
+                        nearbySystems.push({origin, destination: {x, y}, distance})
+                    }
+                }
+            }
+        }
+    }
+
+    return nearbySystems
+}

package/src/types.ts

@@ -1,3 +1,5 @@
+import {UInt16, UInt64} from '@wharfkit/antelope'
+
 export interface Coordinates {
     x: number
     y: number
@@ -17,3 +19,16 @@ export interface Distance {
     destination: Coordinates
     distance: number
 }
+
+export interface Good {
+    id: UInt16
+    name: string
+    description: string
+    base_price: UInt64
+    mass: UInt64
+}
+
+export interface GoodPrice {
+    id: UInt16
+    price: UInt64
+}