@shipload/sdk 1.0.0-next.3 → 1.0.0-next.31

package/src/derivation/index.ts

@@ -7,6 +7,7 @@ export {
     getEligibleResources,
     getResourceWeight,
     getLocationCandidates,
+    getLocationProfile,
     getDepthThreshold,
     getResourceTier,
     DEPTH_THRESHOLD_T1,
@@ -16,7 +17,9 @@ export {
     DEPTH_THRESHOLD_T5,
     LOCATION_MIN_DEPTH,
     LOCATION_MAX_DEPTH,
-    YIELD_THRESHOLD,
+    yieldThresholdAt,
+    YIELD_FRACTION_SHALLOW,
+    YIELD_FRACTION_DEEP,
     PLANET_SUBTYPE_GAS_GIANT,
     PLANET_SUBTYPE_ROCKY,
     PLANET_SUBTYPE_TERRESTRIAL,
@@ -25,8 +28,20 @@ export {
     PLANET_SUBTYPE_INDUSTRIAL,
 } from './resources'
 
-export {RESERVE_TIERS, TIER_ROLL_MAX, rollTier, rollWithinTier} from './tiers'
+export {RESERVE_TIERS, TIER_ROLL_MAX, tierOfReserve, rollTier, rollWithinTier} from './tiers'
 export type {ReserveTier, TierRange} from './tiers'
 
+export {getEffectiveReserve} from './reserve-regen'
+export type {EffectiveReserveInput} from './reserve-regen'
+
 export * from './stats'
 export * from './crafting'
+
+export {
+    STAR_STEP,
+    MAX_STARS_PER_STAT,
+    MAX_STAR_RATING,
+    starsForStat,
+    starRating,
+    statMagnitude,
+} from './stars'

package/src/derivation/reserve-regen.ts

@@ -0,0 +1,34 @@
+import type {BlockTimestamp, UInt32} from '@wharfkit/antelope'
+
+export interface EffectiveReserveInput {
+    remaining: UInt32 | number
+    max_reserve: UInt32 | number
+    last_block: BlockTimestamp
+}
+
+function toNumber(value: UInt32 | number): number {
+    return typeof value === 'number' ? value : Number(value)
+}
+
+function slotsBetween(now: BlockTimestamp, last: BlockTimestamp): number {
+    const nowMs = now.toMilliseconds()
+    const lastMs = last.toMilliseconds()
+    if (nowMs <= lastMs) return 0
+    return Math.floor((nowMs - lastMs) / 500)
+}
+
+export function getEffectiveReserve(
+    row: EffectiveReserveInput,
+    now: BlockTimestamp,
+    epochSeconds: number
+): number {
+    const remaining = toNumber(row.remaining)
+    const max = toNumber(row.max_reserve)
+    if (remaining >= max) return max
+    const epochSlots = epochSeconds * 2
+    if (epochSlots === 0) return remaining
+    const elapsed = slotsBetween(now, row.last_block)
+    const regen = Math.floor((max * elapsed) / epochSlots)
+    const effective = remaining + regen
+    return effective >= max ? max : effective
+}

package/src/derivation/resources.ts

@@ -1,15 +1,29 @@
 import {getItem} from '../data/catalog'
+import {LocationType} from '../types'
 
 export const DEPTH_THRESHOLD_T1 = 0
-export const DEPTH_THRESHOLD_T2 = 2000
-export const DEPTH_THRESHOLD_T3 = 10000
-export const DEPTH_THRESHOLD_T4 = 30000
-export const DEPTH_THRESHOLD_T5 = 55000
+export const DEPTH_THRESHOLD_T2 = 1500
+export const DEPTH_THRESHOLD_T3 = 5000
+export const DEPTH_THRESHOLD_T4 = 12000
+export const DEPTH_THRESHOLD_T5 = 22000
+export const DEPTH_THRESHOLD_T6 = 32000
+export const DEPTH_THRESHOLD_T7 = 42000
+export const DEPTH_THRESHOLD_T8 = 50000
+export const DEPTH_THRESHOLD_T9 = 57000
+export const DEPTH_THRESHOLD_T10 = 63000
 
 export const LOCATION_MIN_DEPTH = 500
 export const LOCATION_MAX_DEPTH = 65535
 
-export const YIELD_THRESHOLD = Math.floor(0.001 * 0xffffffff)
+export const YIELD_FRACTION_SHALLOW = 0.0025
+export const YIELD_FRACTION_DEEP = 0.0005
+
+export function yieldThresholdAt(stratum: number): number {
+    const clamped = stratum > 65535 ? 65535 : stratum
+    const t = clamped / 65535
+    const fraction = YIELD_FRACTION_SHALLOW + (YIELD_FRACTION_DEEP - YIELD_FRACTION_SHALLOW) * t
+    return Math.floor(fraction * 0xffffffff)
+}
 
 export const PLANET_SUBTYPE_GAS_GIANT = 0
 export const PLANET_SUBTYPE_ROCKY = 1
@@ -18,19 +32,22 @@ export const PLANET_SUBTYPE_ICY = 3
 export const PLANET_SUBTYPE_OCEAN = 4
 export const PLANET_SUBTYPE_INDUSTRIAL = 5
 
+const DEPTH_THRESHOLD_TABLE = [
+    DEPTH_THRESHOLD_T1,
+    DEPTH_THRESHOLD_T2,
+    DEPTH_THRESHOLD_T3,
+    DEPTH_THRESHOLD_T4,
+    DEPTH_THRESHOLD_T5,
+    DEPTH_THRESHOLD_T6,
+    DEPTH_THRESHOLD_T7,
+    DEPTH_THRESHOLD_T8,
+    DEPTH_THRESHOLD_T9,
+    DEPTH_THRESHOLD_T10,
+]
+
 export function getDepthThreshold(tier: number): number {
-    switch (tier) {
-        case 1:
-            return DEPTH_THRESHOLD_T1
-        case 2:
-            return DEPTH_THRESHOLD_T2
-        case 3:
-            return DEPTH_THRESHOLD_T3
-        case 4:
-            return DEPTH_THRESHOLD_T4
-        default:
-            return DEPTH_THRESHOLD_T5
-    }
+    if (tier < 1 || tier > 10) return 65535
+    return DEPTH_THRESHOLD_TABLE[tier - 1]
 }
 
 export function getResourceTier(itemId: number): number {
@@ -46,9 +63,9 @@ export function getResourceWeight(itemId: number, stratum: number): number {
 
     switch (tier) {
         case 1:
-            if (stratum < 2000) return 100
-            if (stratum < 10000) return 80
-            if (stratum < 30000) return 50
+            if (stratum < DEPTH_THRESHOLD_T2) return 100
+            if (stratum < DEPTH_THRESHOLD_T3) return 80
+            if (stratum < DEPTH_THRESHOLD_T4) return 50
             return 30
         case 2:
             if (depthAbove < 3000) return 40
@@ -67,37 +84,107 @@ export function getResourceWeight(itemId: number, stratum: number): number {
     }
 }
 
-const ASTEROID_RESOURCES = [101, 102, 103, 201, 202]
-const NEBULA_RESOURCES = [202, 203, 301, 302, 303]
-const GAS_GIANT_RESOURCES = [301, 302, 303, 401, 501]
-const ROCKY_RESOURCES = [101, 102, 103, 401, 402, 403, 503]
-const TERRESTRIAL_RESOURCES = [201, 202, 401, 402, 501, 502, 503]
-const ICY_RESOURCES = [101, 301, 302, 401, 403, 501, 502]
-const OCEAN_RESOURCES = [201, 203, 301, 303, 501, 502, 503]
-const INDUSTRIAL_RESOURCES = [101, 102, 103, 201, 203, 402, 403]
+const RESOURCE_ORE = 0
+const RESOURCE_GAS = 1
+const RESOURCE_REGOLITH = 2
+const RESOURCE_BIOMASS = 3
+const RESOURCE_CRYSTAL = 4
 
-export function getLocationCandidates(locationType: number, subtype: number): number[] {
-    if (locationType === 2) return ASTEROID_RESOURCES
-    if (locationType === 3) return NEBULA_RESOURCES
-    if (locationType === 1) {
+interface LocationProfileEntry {
+    category: number
+    maxTier: number
+}
+
+function categoryBaseId(category: number): number {
+    switch (category) {
+        case RESOURCE_ORE:
+            return 100
+        case RESOURCE_CRYSTAL:
+            return 200
+        case RESOURCE_GAS:
+            return 300
+        case RESOURCE_REGOLITH:
+            return 400
+        case RESOURCE_BIOMASS:
+            return 500
+        default:
+            return 0
+    }
+}
+
+function resourceId(category: number, tier: number): number {
+    return categoryBaseId(category) + tier
+}
+
+export function getLocationProfile(locationType: number, subtype: number): LocationProfileEntry[] {
+    if (locationType === LocationType.ASTEROID) {
+        return [
+            {category: RESOURCE_ORE, maxTier: 5},
+            {category: RESOURCE_CRYSTAL, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.NEBULA) {
+        return [
+            {category: RESOURCE_GAS, maxTier: 5},
+            {category: RESOURCE_REGOLITH, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.ICE_FIELD) {
+        return [
+            {category: RESOURCE_GAS, maxTier: 5},
+            {category: RESOURCE_BIOMASS, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.PLANET) {
         switch (subtype) {
             case PLANET_SUBTYPE_GAS_GIANT:
-                return GAS_GIANT_RESOURCES
+                return [
+                    {category: RESOURCE_GAS, maxTier: 10},
+                    {category: RESOURCE_CRYSTAL, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_ROCKY:
-                return ROCKY_RESOURCES
+                return [
+                    {category: RESOURCE_REGOLITH, maxTier: 10},
+                    {category: RESOURCE_ORE, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_TERRESTRIAL:
-                return TERRESTRIAL_RESOURCES
+                return [
+                    {category: RESOURCE_ORE, maxTier: 10},
+                    {category: RESOURCE_BIOMASS, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_ICY:
-                return ICY_RESOURCES
+                return [
+                    {category: RESOURCE_CRYSTAL, maxTier: 10},
+                    {category: RESOURCE_REGOLITH, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_OCEAN:
-                return OCEAN_RESOURCES
+                return [
+                    {category: RESOURCE_BIOMASS, maxTier: 10},
+                    {category: RESOURCE_GAS, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_INDUSTRIAL:
-                return INDUSTRIAL_RESOURCES
+                return [
+                    {category: RESOURCE_ORE, maxTier: 3},
+                    {category: RESOURCE_CRYSTAL, maxTier: 3},
+                    {category: RESOURCE_REGOLITH, maxTier: 3},
+                    {category: RESOURCE_BIOMASS, maxTier: 3},
+                ]
         }
     }
     return []
 }
 
+export function getLocationCandidates(locationType: number, subtype: number): number[] {
+    const profile = getLocationProfile(locationType, subtype)
+    const ids: number[] = []
+    for (const {category, maxTier} of profile) {
+        for (let tier = 1; tier <= maxTier; tier++) {
+            ids.push(resourceId(category, tier))
+        }
+    }
+    return ids
+}
+
 export function getEligibleResources(
     locationType: number,
     subtype: number,

package/src/derivation/stars.test.ts

@@ -0,0 +1,51 @@
+import {expect, test} from 'bun:test'
+import {
+    MAX_STARS_PER_STAT,
+    MAX_STAR_RATING,
+    starRating,
+    starsForStat,
+    statMagnitude,
+    STAR_STEP,
+} from './stars'
+
+test('starsForStat bands at the 250 boundaries', () => {
+    expect(starsForStat(0)).toBe(0)
+    expect(starsForStat(1)).toBe(0)
+    expect(starsForStat(249)).toBe(0)
+    expect(starsForStat(250)).toBe(1)
+    expect(starsForStat(499)).toBe(1)
+    expect(starsForStat(500)).toBe(2)
+    expect(starsForStat(749)).toBe(2)
+    expect(starsForStat(750)).toBe(3)
+})
+
+test('starsForStat clamps to MAX_STARS_PER_STAT', () => {
+    expect(starsForStat(999)).toBe(MAX_STARS_PER_STAT)
+    expect(starsForStat(1000)).toBe(MAX_STARS_PER_STAT)
+    expect(starsForStat(10_000)).toBe(MAX_STARS_PER_STAT)
+})
+
+test('starsForStat never goes negative', () => {
+    expect(starsForStat(-50)).toBe(0)
+})
+
+test('starRating sums per-stat stars to a 0-9 grade', () => {
+    expect(starRating(0, 0, 0)).toBe(0)
+    expect(starRating(250, 0, 0)).toBe(1)
+    expect(starRating(750, 750, 750)).toBe(MAX_STAR_RATING)
+    expect(starRating(999, 999, 999)).toBe(MAX_STAR_RATING)
+    expect(starRating(599, 599, 599)).toBe(6)
+    expect(starRating(251, 251, 251)).toBe(3)
+})
+
+test('statMagnitude sums raw values for tiebreaking', () => {
+    expect(statMagnitude(599, 599, 599)).toBe(1797)
+    expect(statMagnitude(251, 251, 251)).toBe(753)
+    expect(statMagnitude(599, 599, 599)).toBeGreaterThan(statMagnitude(251, 251, 251))
+})
+
+test('constants hold their documented values', () => {
+    expect(STAR_STEP).toBe(250)
+    expect(MAX_STARS_PER_STAT).toBe(3)
+    expect(MAX_STAR_RATING).toBe(9)
+})

package/src/derivation/stars.ts

@@ -0,0 +1,15 @@
+export const STAR_STEP = 250
+export const MAX_STARS_PER_STAT = 3
+export const MAX_STAR_RATING = MAX_STARS_PER_STAT * 3
+
+export function starsForStat(value: number): number {
+    return Math.max(0, Math.min(MAX_STARS_PER_STAT, Math.floor(value / STAR_STEP)))
+}
+
+export function starRating(stat1: number, stat2: number, stat3: number): number {
+    return starsForStat(stat1) + starsForStat(stat2) + starsForStat(stat3)
+}
+
+export function statMagnitude(stat1: number, stat2: number, stat3: number): number {
+    return stat1 + stat2 + stat3
+}

package/src/derivation/stats.ts

@@ -25,8 +25,7 @@ const ORE_STATS: StatDefinition[] = [
         key: 'density',
         label: 'Density',
         abbreviation: 'DEN',
-        purpose: 'Mass per unit',
-        inverted: true,
+        purpose: 'Structural integrity — higher rolls produce lighter hulls',
     },
 ]
 
@@ -74,10 +73,11 @@ const GAS_STATS: StatDefinition[] = [
 
 const REGOLITH_STATS: StatDefinition[] = [
     {
-        key: 'composition',
-        label: 'Composition',
-        abbreviation: 'COM',
-        purpose: 'Mineral/metal mix — drives sensor, chip, and optic crafting quality',
+        key: 'cohesion',
+        label: 'Cohesion',
+        abbreviation: 'COH',
+        purpose:
+            'Binding strength of the loose aggregate; higher cohesion yields more rigid frames and hulls',
     },
     {
         key: 'hardness',

package/src/derivation/stratum.ts

@@ -1,7 +1,8 @@
 import {Bytes, Checksum256, type Checksum256Type} from '@wharfkit/antelope'
 import {hash512} from '../utils/hash'
 import {Coordinates, type CoordinatesType} from '../types'
-import {getEligibleResources, getResourceWeight, YIELD_THRESHOLD} from './resources'
+import {getItem} from '../data/catalog'
+import {getEligibleResources, getResourceWeight, yieldThresholdAt} from './resources'
 import {RESERVE_TIERS, rollTier, rollWithinTier} from './tiers'
 
 export interface StratumInfo {
@@ -33,15 +34,8 @@ export function deriveStratum(
 
     const rawReserve = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0
 
-    let reserve = 0
-    if (rawReserve <= YIELD_THRESHOLD) {
-        const tierRoll = ((bytes[18] << 8) | bytes[19]) >>> 0
-        const withinRoll = ((bytes[20] << 8) | bytes[21]) >>> 0
-        const tier = rollTier(tierRoll, stratum)
-        reserve = rollWithinTier(withinRoll, RESERVE_TIERS[tier])
-    }
-
-    if (reserve === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
+    if (rawReserve > yieldThresholdAt(stratum))
+        return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
 
     const eligible = getEligibleResources(locationType, subtype, stratum)
     if (eligible.length === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
@@ -66,6 +60,12 @@ export function deriveStratum(
         }
     }
 
+    const tierRoll = ((bytes[18] << 8) | bytes[19]) >>> 0
+    const withinRoll = ((bytes[20] << 8) | bytes[21]) >>> 0
+    const tier = rollTier(tierRoll, stratum)
+    const unitMass = getItem(selectedItemId).mass
+    const reserve = rollWithinTier(withinRoll, RESERVE_TIERS[tier], unitMass)
+
     const seedBigInt =
         (BigInt(bytes[8]) << 56n) |
         (BigInt(bytes[9]) << 48n) |
@@ -76,15 +76,11 @@ export function deriveStratum(
         (BigInt(bytes[14]) << 8n) |
         BigInt(bytes[15])
 
-    const rawRichness = (bytes[16] << 8) | bytes[17]
-    const normalized = rawRichness / 65535
-    const baseRichness = Math.floor(normalized * normalized * 999) + 1
-
-    let depthBonus = 0
-    if (stratum > 1) {
-        depthBonus = (50 * Math.log(stratum)) / Math.log(65535)
-    }
-    const richness = Math.min(Math.floor(baseRichness + depthBonus), 1000)
+    let byteSum = 0
+    for (let i = 22; i <= 33; i++) byteSum += bytes[i]
+    const z = (byteSum - 1530) / 256
+    const roll = 500 + 100 * z
+    const richness = Math.max(1, Math.min(999, Math.round(roll)))
 
     return {itemId: selectedItemId, seed: seedBigInt, richness, reserve}
 }

package/src/derivation/tiers.ts

@@ -1,3 +1,5 @@
+import {getItem} from '../data/catalog'
+
 export type ReserveTier = 'small' | 'medium' | 'large' | 'massive' | 'motherlode'
 
 export interface TierRange {
@@ -6,11 +8,11 @@ export interface TierRange {
 }
 
 export const RESERVE_TIERS: Record<ReserveTier, TierRange> = {
-    small: {min: 15, max: 60},
-    medium: {min: 100, max: 200},
-    large: {min: 400, max: 700},
-    massive: {min: 1000, max: 2500},
-    motherlode: {min: 4000, max: 10000},
+    small: {min: 3_600_000, max: 14_400_000},
+    medium: {min: 24_000_000, max: 48_000_000},
+    large: {min: 96_000_000, max: 168_000_000},
+    massive: {min: 240_000_000, max: 600_000_000},
+    motherlode: {min: 960_000_000, max: 2_400_000_000},
 }
 
 const SHALLOW_THRESHOLDS = {
@@ -47,8 +49,27 @@ export function rollTier(tierRoll: number, stratum: number): ReserveTier {
     return 'motherlode'
 }
 
-export function rollWithinTier(withinRoll: number, range: TierRange): number {
+export function rollWithinTier(
+    withinRoll: number,
+    range: TierRange,
+    resourceUnitMass: number
+): number {
     const u = withinRoll / 65535
     const skewed = u * u
-    return Math.floor(range.min + skewed * (range.max - range.min))
+    const depositMass = range.min + skewed * (range.max - range.min)
+    return Math.max(1, Math.floor(depositMass / resourceUnitMass))
+}
+
+const RESERVE_TIER_ENTRIES = Object.entries(RESERVE_TIERS) as Array<[ReserveTier, TierRange]>
+
+export function tierOfReserve(reserve: number, itemId: number): ReserveTier | null {
+    if (reserve <= 0) return null
+    const unitMass = getItem(itemId).mass
+    if (unitMass <= 0) return null
+    const impliedMassLow = reserve * unitMass
+    const impliedMassHigh = impliedMassLow + unitMass
+    for (const [tier, range] of RESERVE_TIER_ENTRIES) {
+        if (impliedMassHigh > range.min && impliedMassLow <= range.max) return tier
+    }
+    return null
 }

package/src/entities/entity.ts

@@ -0,0 +1,98 @@
+import {UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {
+    CAP_DEMOLISH,
+    CAP_MODULES,
+    CAP_UNDEPLOY,
+    CAP_WRAP,
+    type EntityClass,
+    getEntityClass,
+    kindCan,
+} from '../data/kind-registry'
+import {InventoryAccessor} from './inventory-accessor'
+import {Location} from './location'
+import {ScheduleAccessor} from '../scheduling/accessor'
+import * as schedule from '../scheduling/schedule'
+import type {EntityInventory} from './entity-inventory'
+
+export class Entity extends ServerContract.Types.entity_info {
+    private _sched?: ScheduleAccessor
+    private _inv?: InventoryAccessor
+
+    get name(): string {
+        return this.entity_name
+    }
+
+    get location(): Location {
+        return Location.from(this.coordinates)
+    }
+
+    get isIdle(): boolean {
+        return schedule.isIdle(this)
+    }
+
+    get sched(): ScheduleAccessor {
+        this._sched ??= new ScheduleAccessor(this)
+        return this._sched
+    }
+
+    get inv(): InventoryAccessor {
+        this._inv ??= new InventoryAccessor(this)
+        return this._inv
+    }
+
+    get inventory(): EntityInventory[] {
+        return this.inv.items
+    }
+
+    get totalCargoMass(): UInt64 {
+        return this.inv.totalMass
+    }
+
+    get maxCapacity(): UInt64 {
+        return UInt64.from(this.capacity ?? 0)
+    }
+
+    get availableCapacity(): UInt64 {
+        const cargo = this.totalCargoMass
+        const max = this.maxCapacity
+        return cargo.gte(max) ? UInt64.from(0) : max.subtracting(cargo)
+    }
+
+    get isFull(): boolean {
+        return this.totalCargoMass.gte(this.maxCapacity)
+    }
+
+    get totalMass(): UInt64 {
+        const hull = this.hullmass ? UInt64.from(this.hullmass) : UInt64.from(0)
+        return hull.adding(this.totalCargoMass)
+    }
+
+    get entityClass(): EntityClass {
+        return getEntityClass(this.type)
+    }
+
+    get canWrap(): boolean {
+        return kindCan(this.type, CAP_WRAP)
+    }
+
+    get canUndeploy(): boolean {
+        return kindCan(this.type, CAP_UNDEPLOY)
+    }
+
+    get canDemolish(): boolean {
+        return kindCan(this.type, CAP_DEMOLISH)
+    }
+
+    get canUseModules(): boolean {
+        return kindCan(this.type, CAP_MODULES)
+    }
+
+    isLoading(now: Date): boolean {
+        return schedule.isLoading(this, now)
+    }
+
+    isUnloading(now: Date): boolean {
+        return schedule.isUnloading(this, now)
+    }
+}

package/src/entities/gamestate.ts

@@ -1,4 +1,4 @@
-import {Checksum256, Int64, type UInt64} from '@wharfkit/antelope'
+import {Checksum256, Int64, UInt64} from '@wharfkit/antelope'
 import {type PlatformContract, ServerContract} from '../contracts'
 import {type EpochInfo, getCurrentEpoch, getEpochInfo} from '../scheduling/epoch'
 import {hasSystem} from '../utils/system'
@@ -34,7 +34,7 @@ export class GameState extends ServerContract.Types.state_row {
      * Get the current epoch number from the state
      */
     get currentEpoch(): UInt64 {
-        return this.epoch
+        return UInt64.from(this.epoch.toString())
     }
 
     /**
@@ -58,27 +58,6 @@ export class GameState extends ServerContract.Types.state_row {
         return this.enabled
     }
 
-    /**
-     * Get the total number of ships in the game
-     */
-    get shipCount(): number {
-        return Number(this.ships)
-    }
-
-    /**
-     * Get the current salt value (used for random number generation)
-     */
-    get currentSalt(): UInt64 {
-        return this.salt
-    }
-
-    /**
-     * Get the commit hash for the next epoch
-     */
-    get nextEpochCommit(): Checksum256 {
-        return this.commit
-    }
-
     /**
      * Calculate the current epoch from game config (if game is set)
      * This might differ from state.epoch if the blockchain hasn't advanced yet
@@ -97,7 +76,7 @@ export class GameState extends ServerContract.Types.state_row {
         if (!this._game) {
             return undefined
         }
-        return getEpochInfo(this._game, this.epoch)
+        return getEpochInfo(this._game, this.currentEpoch)
     }
 
     /**
@@ -137,16 +116,12 @@ export class GameState extends ServerContract.Types.state_row {
     get summary(): {
         enabled: boolean
         epoch: string
-        ships: number
         hasSeed: boolean
-        hasCommit: boolean
     } {
         return {
             enabled: this.enabled,
             epoch: this.epoch.toString(),
-            ships: this.shipCount,
             hasSeed: !this.seed.equals(Checksum256.from('0'.repeat(64))),
-            hasCommit: !this.commit.equals(Checksum256.from('0'.repeat(64))),
         }
     }
 }