@shipload/sdk 2.0.0-rc1 → 2.0.0-rc3

package/src/entities/location.ts

@@ -1,7 +1,7 @@
 import {Checksum256, Checksum256Type, UInt16, UInt16Type, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {Coordinates, CoordinatesType, Distance, GoodPrice} from '../types'
-import {hasSystem} from '../utils/system'
+import {Coordinates, CoordinatesType, Distance, ItemPrice, LocationType} from '../types'
+import {getLocationType, hasSystem, isExtractableLocation} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 
 /**
@@ -10,10 +10,10 @@ import {findNearbyPlanets} from '../travel/travel'
  */
 export class Location {
     readonly coordinates: Coordinates
-    private _marketPrices?: GoodPrice[]
+    private _marketPrices?: ItemPrice[]
     private _gameSeed?: Checksum256
     private _hasSystem?: boolean
-    private _locationRows?: ServerContract.Types.location_row[]
+    private _locationRows?: ServerContract.Types.supply_row[]
     private _epoch?: UInt64
 
     constructor(coordinates: CoordinatesType) {
@@ -28,7 +28,7 @@ export class Location {
     }
 
     /**
-     * Check if this location has a system (planet)
+     * Check if this location has a system (planet, asteroid, or nebula)
      */
     hasSystemAt(gameSeed: Checksum256Type): boolean {
         const seed = Checksum256.from(gameSeed)
@@ -39,24 +39,38 @@ export class Location {
         return this._hasSystem
     }
 
+    /**
+     * Get the location type (EMPTY, PLANET, ASTEROID, or NEBULA)
+     */
+    getLocationTypeAt(gameSeed: Checksum256Type): LocationType {
+        return getLocationType(gameSeed, this.coordinates)
+    }
+
+    /**
+     * Check if this location is extractable (asteroid or nebula)
+     */
+    isExtractableAt(gameSeed: Checksum256Type): boolean {
+        return isExtractableLocation(this.getLocationTypeAt(gameSeed))
+    }
+
     /**
      * Set cached market prices for this location
      */
-    setMarketPrices(prices: GoodPrice[]): void {
+    setMarketPrices(prices: ItemPrice[]): void {
         this._marketPrices = prices
     }
 
     /**
      * Get cached market prices (returns undefined if not cached)
      */
-    get marketPrices(): GoodPrice[] | undefined {
+    get marketPrices(): ItemPrice[] | undefined {
         return this._marketPrices
     }
 
     /**
      * Get price for a specific good (from cache)
      */
-    getPrice(goodId: UInt16Type): GoodPrice | undefined {
+    getPrice(goodId: UInt16Type): ItemPrice | undefined {
         if (!this._marketPrices) return undefined
         return this._marketPrices.find((p) => p.id.equals(goodId))
     }
@@ -79,7 +93,7 @@ export class Location {
     /**
      * Set location rows (supply data) for this location
      */
-    setLocationRows(rows: ServerContract.Types.location_row[], epoch: UInt64): void {
+    setLocationRows(rows: ServerContract.Types.supply_row[], epoch: UInt64): void {
         this._locationRows = rows
         this._epoch = epoch
     }
@@ -87,7 +101,7 @@ export class Location {
     /**
      * Get cached location rows (supply data)
      */
-    get locationRows(): ServerContract.Types.location_row[] | undefined {
+    get locationRows(): ServerContract.Types.supply_row[] | undefined {
         return this._locationRows
     }
 
@@ -98,7 +112,7 @@ export class Location {
     getSupply(goodId: UInt16Type): UInt16 | undefined {
         if (!this._locationRows) return undefined
         const row = this._locationRows.find(
-            (r) => r.good_id.equals(goodId) && this._epoch && r.epoch.equals(this._epoch)
+            (r) => r.item_id.equals(goodId) && this._epoch && r.epoch.equals(this._epoch)
         )
         return row ? row.supply : undefined
     }
@@ -107,7 +121,7 @@ export class Location {
      * Get all available goods at this location (goods with supply > 0)
      * Returns undefined if location rows not cached
      */
-    get availableGoods(): ServerContract.Types.location_row[] | undefined {
+    get availableGoods(): ServerContract.Types.supply_row[] | undefined {
         if (!this._locationRows) return undefined
         return this._locationRows.filter(
             (r) => this._epoch && r.epoch.equals(this._epoch) && r.supply.gt(UInt16.from(0))
@@ -185,9 +199,9 @@ export class Location {
                                 : UInt16.from(0)
                             : currentSupply.adding(quantityDelta)
 
-                    return GoodPrice.from({
+                    return ItemPrice.from({
                         id: price.id,
-                        good: price.good,
+                        item: price.item,
                         price: price.price,
                         supply: newSupply,
                     })
@@ -199,7 +213,7 @@ export class Location {
         // Copy location rows if cached
         if (this._locationRows && this._epoch) {
             newLocation._locationRows = this._locationRows.map((row) => {
-                if (row.good_id.equals(goodId) && row.epoch.equals(this._epoch!)) {
+                if (row.item_id.equals(goodId) && row.epoch.equals(this._epoch!)) {
                     const currentSupply = UInt16.from(row.supply)
                     const delta = UInt16.from(Math.abs(quantityDelta))
                     const newSupply =
@@ -209,11 +223,11 @@ export class Location {
                                 : UInt16.from(0)
                             : currentSupply.adding(quantityDelta)
 
-                    return ServerContract.Types.location_row.from({
+                    return ServerContract.Types.supply_row.from({
                         id: row.id,
                         coordinates: row.coordinates,
                         epoch: row.epoch,
-                        good_id: row.good_id,
+                        item_id: row.item_id,
                         supply: newSupply,
                     })
                 }

package/src/entities/makers.ts

@@ -0,0 +1,69 @@
+import {Name, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {Ship, ShipStateInput} from './ship'
+import {Warehouse, WarehouseStateInput} from './warehouse'
+import {Container, ContainerStateInput} from './container'
+
+export function makeShip(state: ShipStateInput): Ship {
+    const entityInfo = ServerContract.Types.entity_info.from({
+        type: Name.from('ship'),
+        id: UInt64.from(state.id),
+        owner: Name.from(state.owner),
+        entity_name: state.name,
+        coordinates: ServerContract.Types.coordinates.from(state.coordinates),
+        hullmass: UInt32.from(state.hullmass),
+        capacity: UInt32.from(state.capacity),
+        energy: UInt16.from(state.energy),
+        cargomass: UInt32.from(0),
+        cargo: state.cargo || [],
+        is_idle: !state.schedule,
+        current_task_elapsed: UInt32.from(0),
+        current_task_remaining: UInt32.from(0),
+        pending_tasks: [],
+        engines: state.engines,
+        generator: state.generator,
+        loaders: state.loaders,
+        schedule: state.schedule,
+    })
+    return new Ship(entityInfo)
+}
+
+export function makeWarehouse(state: WarehouseStateInput): Warehouse {
+    const entityInfo = ServerContract.Types.entity_info.from({
+        type: Name.from('warehouse'),
+        id: UInt64.from(state.id),
+        owner: Name.from(state.owner),
+        entity_name: state.name,
+        coordinates: ServerContract.Types.coordinates.from(state.coordinates),
+        capacity: UInt32.from(state.capacity),
+        cargomass: UInt32.from(0),
+        cargo: state.cargo || [],
+        loaders: state.loaders,
+        is_idle: !state.schedule,
+        current_task_elapsed: UInt32.from(0),
+        current_task_remaining: UInt32.from(0),
+        pending_tasks: [],
+        schedule: state.schedule,
+    })
+    return new Warehouse(entityInfo)
+}
+
+export function makeContainer(state: ContainerStateInput): Container {
+    const entityInfo = ServerContract.Types.entity_info.from({
+        type: Name.from('container'),
+        id: UInt64.from(state.id),
+        owner: Name.from(state.owner),
+        entity_name: state.name,
+        coordinates: ServerContract.Types.coordinates.from(state.coordinates),
+        hullmass: UInt32.from(state.hullmass),
+        capacity: UInt32.from(state.capacity),
+        cargomass: UInt32.from(state.cargomass || 0),
+        cargo: [],
+        is_idle: !state.schedule,
+        current_task_elapsed: UInt32.from(0),
+        current_task_remaining: UInt32.from(0),
+        pending_tasks: [],
+        schedule: state.schedule,
+    })
+    return new Container(entityInfo)
+}

package/src/entities/player.ts

@@ -37,7 +37,8 @@ export class Player extends ServerContract.Types.player_row {
     }
     // Constants for game rules (match smart contract)
     private static readonly MAX_LOAN = 1000000
-    private static readonly BASE_SHIP_COST = 100 // pow(5, sequence) * 100
+    // Contract formula: 2500 * pow(5, sequence - 1) = 500 * pow(5, sequence)
+    private static readonly BASE_SHIP_COST = 500
     private static readonly SHIP_COST_MULTIPLIER = 5
 
     // Optional ship count for nextShipCost calculation