@shipload/sdk 0.3.0 → 0.3.2

package/src/epoch.ts

@@ -0,0 +1,11 @@
+import {PlatformContract, ServerContract} from './contracts'
+
+export async function getCurrentEpoch(
+    game: PlatformContract.Types.game_row,
+    state: ServerContract.Types.state_row
+): Promise<number> {
+    const current = new Date().getTime()
+    const difference = (current - state.genesis.toDate().getTime()) / 1000
+    const epoch = Math.floor(difference / Number(game.config.epochtime)) + 1
+    return epoch
+}

package/src/hash.ts

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

package/src/index-module.ts

@@ -1,4 +1,5 @@
 export * from './contracts'
+export * from './epoch'
 export * from './hash'
 export * from './travel'
 export * from './types'

package/src/rolls.ts

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

package/src/shipload.ts

@@ -1,42 +1,74 @@
 import {APIClient, UInt64} from '@wharfkit/antelope'
 import {Coordinates, GoodPrice} from './types'
 import {marketprice, marketprices} from './market'
-import {ServerContract} from './contracts'
+import {PlatformContract, 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
+    platformContractName?: string
+    serverContractName?: string
     client?: APIClient
 }
 
 interface ShiploadConstructorOptions extends ShiploadOptions {
+    platformContract: Contract
     serverContract: Contract
 }
 
 export class Shipload {
-    private client: APIClient
-    private server: Contract
+    public client: APIClient
+    public server: Contract
+    public platform: Contract
 
-    constructor(chain: ChainDefinition, {client, serverContract}: ShiploadConstructorOptions) {
+    constructor(
+        chain: ChainDefinition,
+        {client, platformContract, serverContract}: ShiploadConstructorOptions
+    ) {
         this.client = client || new APIClient({url: chain.url})
 
+        this.platform = platformContract
+            ? platformContract
+            : new PlatformContract.Contract({client: this.client})
+
         this.server = serverContract
             ? serverContract
             : new ServerContract.Contract({client: this.client})
     }
 
     static async load(chain: ChainDefinition, shiploadOptions: ShiploadOptions): Promise<Shipload> {
+        let platform: Contract = new PlatformContract.Contract({
+            client: new APIClient({url: chain.url}),
+        })
+        if (shiploadOptions.platformContractName) {
+            const client = shiploadOptions.client || new APIClient({url: chain.url})
+            const contractKit = new ContractKit({client})
+            platform = await contractKit.load(shiploadOptions.platformContractName)
+        }
+
         let server: Contract = new ServerContract.Contract({
             client: new APIClient({url: chain.url}),
         })
-        if (shiploadOptions.contractName) {
+        if (shiploadOptions.serverContractName) {
             const client = shiploadOptions.client || new APIClient({url: chain.url})
             const contractKit = new ContractKit({client})
-            server = await contractKit.load(shiploadOptions.contractName)
+            server = await contractKit.load(shiploadOptions.serverContractName)
+        }
+
+        return new Shipload(chain, {
+            ...shiploadOptions,
+            platformContract: platform,
+            serverContract: server,
+        })
+    }
+
+    async getGame(): Promise<PlatformContract.Types.game_row> {
+        const game = await this.platform.table('games').get()
+        if (!game) {
+            throw new Error(ERROR_SYSTEM_NOT_INITIALIZED)
         }
-        return new Shipload(chain, {...shiploadOptions, serverContract: server})
+        return game
     }
 
     async getState(): Promise<ServerContract.Types.state_row> {
@@ -48,12 +80,14 @@ export class Shipload {
     }
 
     async marketprice(location: Coordinates, good_id: number): Promise<UInt64> {
-        const {seed, epochseed} = await this.getState()
-        return marketprice(location, good_id, seed, epochseed)
+        const game = await this.getGame()
+        const state = await this.getState()
+        return marketprice(location, good_id, game.config.seed, state.seed)
     }
 
     async marketprices(location: Coordinates): Promise<GoodPrice[]> {
-        const {seed, epochseed} = await this.getState()
-        return marketprices(location, seed, epochseed)
+        const game = await this.getGame()
+        const state = await this.getState()
+        return marketprices(location, game.config.seed, state.seed)
     }
 }

package/src/travel.ts

@@ -1,8 +1,8 @@
-import {Checksum256} from '@wharfkit/antelope'
+import {Checksum256, Int64, UInt16, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
 
 import {ServerContract} from './contracts'
-import {hash} from './hash'
-import {Coordinates, Distance} from './types'
+import {hash512} from './hash'
+import {Distance} from './types'
 
 export function distanceTraveled(ship: ServerContract.Types.ship_row): number {
     if (ship.travelplan) {
@@ -12,46 +12,69 @@ export function distanceTraveled(ship: ServerContract.Types.ship_row): number {
     return 0
 }
 
-export function distanceBetweenPoints(x1: number, y1: number, x2: number, y2: number) {
+export function distanceBetweenCoordinates(
+    origin: ServerContract.ActionParams.Type.coordinates,
+    destination: ServerContract.ActionParams.Type.coordinates
+): UInt16 {
+    return distanceBetweenPoints(origin.x, origin.y, destination.x, destination.y)
+}
+
+export function distanceBetweenPoints(
+    x1: UInt64Type,
+    y1: UInt64Type,
+    x2: UInt64Type,
+    y2: UInt64Type
+): UInt16 {
     const x = Math.pow(x1 - x2, 2)
     const y = Math.pow(y1 - y2, 2)
-    return Math.sqrt(x + y)
+    return UInt16.from(Math.sqrt(x + y))
 }
 
-export function lerp(origin: Coordinates, destination: Coordinates, time: number) {
+export function lerp(
+    origin: ServerContract.ActionParams.Type.coordinates,
+    destination: ServerContract.ActionParams.Type.coordinates,
+    time: number
+): ServerContract.ActionParams.Type.coordinates {
     return {
-        x: (1 - time) * origin.x + time * destination.x,
-        y: (1 - time) * origin.y + time * destination.y,
+        x: (1 - time) * Number(origin.x) + time * Number(destination.x),
+        y: (1 - time) * Number(origin.y) + time * Number(destination.y),
     }
 }
 
-export function rotation(origin: Coordinates, destination: Coordinates) {
+export function rotation(
+    origin: ServerContract.ActionParams.Type.coordinates,
+    destination: ServerContract.ActionParams.Type.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 hasPlanet(
+    seed: Checksum256,
+    coordinates: ServerContract.ActionParams.Type.coordinates
+): boolean {
+    const str = ['system', coordinates.x, coordinates.y].join('-')
+    return String(hash512(seed, str)).slice(0, 2) === '00'
 }
 
 export function findNearbyPlanets(
     seed: Checksum256,
-    origin: Coordinates,
-    maxDistance = 20
+    origin: ServerContract.ActionParams.Type.coordinates,
+    maxDistance: UInt16Type = 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
+    const max = UInt16.from(maxDistance)
+    const xMin = Int64.from(origin.x).subtracting(max)
+    const xMax = Int64.from(origin.x).adding(max)
+    const yMin = Int64.from(origin.y).subtracting(max)
+    const yMax = Int64.from(origin.y).adding(max)
 
-    for (let x = xMin; x <= xMax; x++) {
-        for (let y = yMin; y <= yMax; y++) {
+    for (let x = Number(xMin); x <= Number(xMax); x++) {
+        for (let y = Number(yMin); y <= Number(yMax); y++) {
             const samePlace = x === origin.x && y === origin.y
             if (!samePlace) {
                 const distance = distanceBetweenPoints(origin.x, origin.y, x, y)
-                if (distance <= maxDistance) {
+                if (Number(distance) <= Number(max)) {
                     const system = hasPlanet(seed, {x, y})
                     if (system) {
                         nearbySystems.push({origin, destination: {x, y}, distance})

package/src/types.ts

@@ -1,4 +1,5 @@
 import {UInt16, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from './contracts'
 
 export interface Coordinates {
     x: number
@@ -15,9 +16,9 @@ export interface Dimensions {
 }
 
 export interface Distance {
-    origin: Coordinates
-    destination: Coordinates
-    distance: number
+    origin: ServerContract.ActionParams.Type.coordinates
+    destination: ServerContract.ActionParams.Type.coordinates
+    distance: UInt16
 }
 
 export interface Good {