@shipload/sdk 0.3.3 → 0.3.5

package/src/shipload.ts

@@ -1,10 +1,11 @@
-import {APIClient, UInt64} from '@wharfkit/antelope'
-import {Coordinates, GoodPrice} from './types'
+import {APIClient, UInt16Type, UInt64} from '@wharfkit/antelope'
+import {Distance, GoodPrice} from './types'
 import {marketprice, marketprices} from './market'
 import {PlatformContract, ServerContract} from './contracts'
 import {ERROR_SYSTEM_NOT_INITIALIZED} from './errors'
 import {ChainDefinition} from '@wharfkit/session'
 import ContractKit, {Contract} from '@wharfkit/contract'
+import {findNearbyPlanets, hasSystem, travelplan} from './travel'
 
 interface ShiploadOptions {
     platformContractName?: string
@@ -13,8 +14,8 @@ interface ShiploadOptions {
 }
 
 interface ShiploadConstructorOptions extends ShiploadOptions {
-    platformContract: Contract
-    serverContract: Contract
+    platformContract?: Contract
+    serverContract?: Contract
 }
 
 export class Shipload {
@@ -22,10 +23,8 @@ export class Shipload {
     public server: Contract
     public platform: Contract
 
-    constructor(
-        chain: ChainDefinition,
-        {client, platformContract, serverContract}: ShiploadConstructorOptions
-    ) {
+    constructor(chain: ChainDefinition, constructorOptions?: ShiploadConstructorOptions) {
+        const {client, platformContract, serverContract} = constructorOptions || {}
         this.client = client || new APIClient({url: chain.url})
 
         this.platform = platformContract
@@ -37,11 +36,14 @@ export class Shipload {
             : new ServerContract.Contract({client: this.client})
     }
 
-    static async load(chain: ChainDefinition, shiploadOptions: ShiploadOptions): Promise<Shipload> {
+    static async load(
+        chain: ChainDefinition,
+        shiploadOptions?: ShiploadOptions
+    ): Promise<Shipload> {
         let platform: Contract = new PlatformContract.Contract({
             client: new APIClient({url: chain.url}),
         })
-        if (shiploadOptions.platformContractName) {
+        if (shiploadOptions?.platformContractName) {
             const client = shiploadOptions.client || new APIClient({url: chain.url})
             const contractKit = new ContractKit({client})
             platform = await contractKit.load(shiploadOptions.platformContractName)
@@ -50,7 +52,7 @@ export class Shipload {
         let server: Contract = new ServerContract.Contract({
             client: new APIClient({url: chain.url}),
         })
-        if (shiploadOptions.serverContractName) {
+        if (shiploadOptions?.serverContractName) {
             const client = shiploadOptions.client || new APIClient({url: chain.url})
             const contractKit = new ContractKit({client})
             server = await contractKit.load(shiploadOptions.serverContractName)
@@ -79,15 +81,48 @@ export class Shipload {
         return state
     }
 
-    async marketprice(location: Coordinates, good_id: number): Promise<UInt64> {
+    async marketprice(
+        location: ServerContract.ActionParams.Type.coordinates,
+        good_id: number
+    ): Promise<UInt64> {
         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[]> {
+    async marketprices(
+        location: ServerContract.ActionParams.Type.coordinates
+    ): Promise<GoodPrice[]> {
         const game = await this.getGame()
         const state = await this.getState()
         return marketprices(location, game.config.seed, state.seed)
     }
+
+    async hasSystem(location: ServerContract.ActionParams.Type.coordinates): Promise<boolean> {
+        const game = await this.getGame()
+        return hasSystem(game.config.seed, location)
+    }
+
+    async findNearbyPlanets(
+        origin: ServerContract.ActionParams.Type.coordinates,
+        maxDistance: UInt16Type = 20
+    ): Promise<Distance[]> {
+        const game = await this.getGame()
+        return findNearbyPlanets(game.config.seed, origin, maxDistance)
+    }
+
+    async travelplan(
+        ship: ServerContract.Types.ship_row,
+        origin: ServerContract.ActionParams.Type.coordinates,
+        destination: ServerContract.ActionParams.Type.coordinates,
+        recharge = false
+    ): Promise<ServerContract.Types.travel_plan> {
+        const game = await this.getGame()
+        const cargos = await this.server.table('cargo').all({
+            from: ship.id,
+            to: ship.id,
+            index_position: 'secondary',
+        })
+        return travelplan(game, ship, cargos, origin, destination, recharge)
+    }
 }

package/src/travel.ts

@@ -1,13 +1,33 @@
-import {Checksum256, Int64, UInt16, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {
+    BlockTimestamp,
+    Checksum256,
+    Int64,
+    Int64Type,
+    UInt32,
+    UInt32Type,
+    UInt64,
+    UInt64Type,
+} from '@wharfkit/antelope'
 
-import {ServerContract} from './contracts'
+import {PlatformContract, ServerContract} from './contracts'
 import {hash512} from './hash'
-import {Distance} from './types'
+import {Distance, PRECISION} from './types'
+import {getGood} from './goods'
 
-export function distanceTraveled(ship: ServerContract.Types.ship_row): number {
+export function travelplanDuration(travelplan: ServerContract.Types.travel_plan) {
+    return UInt32.from(travelplan.flighttime)
+        .adding(travelplan.rechargetime)
+        .adding(travelplan.loadtime)
+}
+
+export function distanceTraveled(
+    ship: ServerContract.Types.ship_row,
+    current: Date = new Date()
+): number {
     if (ship.travelplan) {
-        const {departure, duration} = ship.travelplan
-        return (+new Date() - +departure.toDate()) / (Number(duration) * 1000)
+        const {departure} = ship.travelplan
+        const duration = travelplanDuration(ship.travelplan)
+        return (+current - +departure.toDate()) / (Number(duration) * 1000)
     }
     return 0
 }
@@ -15,19 +35,19 @@ export function distanceTraveled(ship: ServerContract.Types.ship_row): number {
 export function distanceBetweenCoordinates(
     origin: ServerContract.ActionParams.Type.coordinates,
     destination: ServerContract.ActionParams.Type.coordinates
-): UInt16 {
+): UInt64 {
     return distanceBetweenPoints(origin.x, origin.y, destination.x, destination.y)
 }
 
 export function distanceBetweenPoints(
-    x1: UInt64Type,
-    y1: UInt64Type,
-    x2: UInt64Type,
-    y2: UInt64Type
-): UInt16 {
+    x1: Int64Type,
+    y1: Int64Type,
+    x2: Int64Type,
+    y2: Int64Type
+): UInt64 {
     const x = Math.pow(x1 - x2, 2)
     const y = Math.pow(y1 - y2, 2)
-    return UInt16.from(Math.sqrt(x + y))
+    return UInt64.from(Math.sqrt(x + y) * PRECISION)
 }
 
 export function lerp(
@@ -48,7 +68,7 @@ export function rotation(
     return Math.atan2(destination.y - origin.y, destination.x - origin.x) * (180 / Math.PI) + 90
 }
 
-export function hasPlanet(
+export function hasSystem(
     seed: Checksum256,
     coordinates: ServerContract.ActionParams.Type.coordinates
 ): boolean {
@@ -59,23 +79,29 @@ export function hasPlanet(
 export function findNearbyPlanets(
     seed: Checksum256,
     origin: ServerContract.ActionParams.Type.coordinates,
-    maxDistance: UInt16Type = 20
+    maxDistance: UInt64Type = 20 * PRECISION
 ): Distance[] {
+    // console.log(String(seed), String(maxDistance), JSON.stringify(origin))
     const nearbySystems: Distance[] = []
 
-    const max = UInt16.from(maxDistance)
+    const max = UInt64.from(maxDistance / PRECISION)
     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)
 
+    // console.log('xMin', Number(xMin))
+    // console.log('xMax', Number(xMax))
+    // console.log('yMin', Number(yMin))
+    // console.log('yMax', Number(yMax))
+
     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 (Number(distance) <= Number(max)) {
-                    const system = hasPlanet(seed, {x, y})
+                if (Number(distance) <= Number(maxDistance)) {
+                    const system = hasSystem(seed, {x, y})
                     if (system) {
                         nearbySystems.push({origin, destination: {x, y}, distance})
                     }
@@ -86,3 +112,137 @@ export function findNearbyPlanets(
 
     return nearbySystems
 }
+export function travelplan(
+    game: PlatformContract.Types.game_row,
+    ship: ServerContract.Types.ship_row,
+    cargos: ServerContract.Types.cargo_row[],
+    origin: ServerContract.ActionParams.Type.coordinates,
+    destination: ServerContract.ActionParams.Type.coordinates,
+    recharge: boolean
+): ServerContract.Types.travel_plan {
+    const valid = hasSystem(game.config.seed, destination)
+    if (!valid) {
+        throw new Error('Invalid destination')
+    }
+    const distance = distanceBetweenCoordinates(origin, destination)
+    const mass = calc_ship_mass(ship, cargos) // Total mass of ship_id
+    const loadtime = calc_ship_loadtime(ship, cargos)
+    const flighttime = calc_ship_flighttime(ship, mass, distance)
+    const rechargetime = recharge ? calc_ship_rechargetime(ship) : 0
+    const energyusage = calc_energyusage(ship.stats.drain, flighttime) // Energy usage from ship and flighttime
+
+    return ServerContract.Types.travel_plan.from({
+        departure: BlockTimestamp.fromDate(new Date()),
+        destination,
+        loadtime,
+        flighttime,
+        rechargetime,
+        // TODO: Remove below, used for debugging
+        distance,
+        energyusage,
+        mass,
+    })
+}
+
+export function calc_rechargetime(
+    capacity: UInt32Type,
+    energy: UInt32Type,
+    recharge: UInt32Type
+): UInt32 {
+    return UInt32.from(capacity).subtracting(energy).dividing(recharge)
+}
+
+export function calc_ship_rechargetime(ship: ServerContract.Types.ship_row): UInt32 {
+    return calc_rechargetime(ship.stats.capacity, ship.state.energy, ship.stats.recharge)
+}
+
+// uint32_t server::calc_ship_rechargetime(const ship_row ship)
+// {
+//    return calc_rechargetime(ship.stats.capacity, ship.state.energy, ship.stats.recharge);
+// }
+
+export function calc_ship_loadtime(
+    ship: ServerContract.Types.ship_row,
+    cargos: ServerContract.Types.cargo_row[]
+): UInt32 {
+    const loadtime = UInt32.from(0)
+
+    const mass_load = UInt64.from(0)
+    const mass_unload = UInt64.from(0)
+    for (const cargo of cargos) {
+        const cargo_delta = Number(cargo.quantity) - Number(cargo.loaded)
+        if (cargo_delta !== 0) {
+            const good_mass = getGood(cargo.good_id).mass
+            const cargo_mass = good_mass.multiplying(Math.abs(cargo_delta))
+
+            if (cargo_delta > 0) {
+                mass_load.add(cargo_mass)
+            } else {
+                mass_unload.add(cargo_mass)
+            }
+        }
+    }
+
+    if (Number(mass_load) > 0 || Number(mass_unload) > 0) {
+        mass_load.add(ship.loaders.mass)
+        loadtime.add(calc_loader_flighttime(ship, mass_load))
+
+        mass_unload.add(ship.loaders.mass)
+        loadtime.add(calc_loader_flighttime(ship, mass_unload))
+    }
+
+    return loadtime.dividing(ship.loaders.quantity)
+}
+
+export function calc_flighttime(distance: UInt64Type, acceleration: number): UInt32 {
+    return UInt32.from(2 * Math.sqrt(Number(distance) / acceleration))
+}
+
+export function calc_loader_flighttime(ship: ServerContract.Types.ship_row, mass: UInt64): UInt32 {
+    return calc_flighttime(ship.stats.orbit, calc_loader_acceleration(ship, mass))
+}
+
+export function calc_loader_acceleration(
+    ship: ServerContract.Types.ship_row,
+    mass: UInt64
+): number {
+    return calc_acceleration(Number(ship.loaders.thrust), Number(mass) + Number(ship.loaders.mass))
+}
+
+export function calc_ship_flighttime(
+    ship: ServerContract.Types.ship_row,
+    mass: UInt64,
+    distance: UInt64
+): UInt32 {
+    const acceleration = calc_ship_acceleration(ship, mass)
+    return calc_flighttime(distance, acceleration)
+}
+
+export function calc_ship_acceleration(ship: ServerContract.Types.ship_row, mass: UInt64): number {
+    return calc_acceleration(Number(ship.stats.thrust), Number(mass))
+}
+
+export function calc_acceleration(thrust: number, mass: number): number {
+    return (thrust / mass) * PRECISION
+}
+
+export function calc_ship_mass(
+    ship: ServerContract.Types.ship_row,
+    cargos: ServerContract.Types.cargo_row[]
+): UInt64 {
+    const mass = UInt64.from(ship.stats.mass)
+
+    if (Number(ship.loaders.quantity) > 0) {
+        mass.add(ship.loaders.mass.multiplying(ship.loaders.quantity))
+    }
+
+    for (const cargo of cargos) {
+        mass.add(getGood(cargo.good_id).mass.multiplying(cargo.quantity))
+    }
+
+    return mass
+}
+
+export function calc_energyusage(drain: UInt32Type, flighttime: UInt32Type): UInt32 {
+    return UInt32.from(drain).multiplying(flighttime)
+}

package/src/types.ts

@@ -1,12 +1,9 @@
-import {UInt16, UInt64} from '@wharfkit/antelope'
+import {UInt16, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from './contracts'
 
-export interface Coordinates {
-    x: number
-    y: number
-}
+export const PRECISION = 10000
 
-export interface CameraPosition extends Coordinates {
+export interface CameraPosition extends ServerContract.ActionParams.Type.coordinates {
     z: number
 }
 
@@ -29,7 +26,15 @@ export interface Good {
     mass: UInt64
 }
 
+export interface GoodType {
+    id: UInt16Type
+    name: string
+    description: string
+    base_price: UInt64Type
+    mass: UInt64Type
+}
+
 export interface GoodPrice {
-    id: UInt16
+    good: Good
     price: UInt64
 }