@shipload/sdk 1.0.0-next.66 → 1.0.0-next.68

package/src/influence/civic-shuttle.test.ts

@@ -0,0 +1,202 @@
+import {UInt8, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {expect, test} from 'bun:test'
+import type {ServerContract} from '../contracts'
+import {encodeStats} from '../derivation/crafting'
+import {ITEM_DEPOT_T1_PACKED, ITEM_LOADER_T1, ITEM_STORAGE_T1} from '../data/item-ids'
+import {JOB_QUEUE_CAP} from '../scheduling/jobs'
+import {HoldKind, TaskType} from '../types'
+import {
+    civicShuttleBays,
+    civicTransfersAtCap,
+    civicTransfersFrom,
+    pendingCivicTransfers,
+    selectCivicShuttleBay,
+    CIVIC_TRANSFER_PER_PLAYER_CAP,
+} from './civic-shuttle'
+
+type Lane = ServerContract.Types.lane
+type ModuleEntry = ServerContract.Types.module_entry
+type Task = ServerContract.Types.task
+
+const T0 = new Date('2026-01-01T00:00:00.000Z')
+const loaderStats = encodeStats([300, 500])
+const storageStats = encodeStats([300, 300])
+
+function makeModuleEntry(itemId: number, stats: bigint): ModuleEntry {
+    return {
+        type: UInt8.from(0),
+        installed: {item_id: UInt16.from(itemId), stats: UInt64.from(stats)},
+    } as unknown as ModuleEntry
+}
+
+// The live Depot layout: two loader bays then four storage.
+function depotModules(): ModuleEntry[] {
+    return [
+        makeModuleEntry(ITEM_LOADER_T1, loaderStats),
+        makeModuleEntry(ITEM_LOADER_T1, loaderStats),
+        makeModuleEntry(ITEM_STORAGE_T1, storageStats),
+        makeModuleEntry(ITEM_STORAGE_T1, storageStats),
+        makeModuleEntry(ITEM_STORAGE_T1, storageStats),
+        makeModuleEntry(ITEM_STORAGE_T1, storageStats),
+    ]
+}
+
+function shuttleTask(senderId: number, receiverId: number, group?: number): Task {
+    return {
+        type: UInt8.from(TaskType.SHUTTLE),
+        duration: UInt32.from(60),
+        cancelable: UInt8.from(2),
+        cargo: [],
+        couplings: [
+            {
+                counterpart: {entity_id: UInt64.from(senderId), entity_type: UInt8.from(1)},
+                hold: UInt64.from(1),
+                kind: UInt8.from(HoldKind.PULL),
+            },
+            {
+                counterpart: {entity_id: UInt64.from(receiverId), entity_type: UInt8.from(1)},
+                hold: UInt64.from(1),
+                kind: UInt8.from(HoldKind.PUSH),
+            },
+        ],
+        entitygroup: group === undefined ? undefined : UInt64.from(group),
+    } as unknown as Task
+}
+
+function makeLane(laneKey: number, tasks: Task[]): Lane {
+    return {
+        lane_key: UInt8.from(laneKey),
+        schedule: {started: {toDate: () => T0}, tasks},
+    } as unknown as Lane
+}
+
+test('civicShuttleBays lists both Depot bays with their queue depth', () => {
+    const lanes = [makeLane(1, [shuttleTask(20, 21)])]
+    const bays = civicShuttleBays(depotModules(), ITEM_DEPOT_T1_PACKED, lanes, T0)
+    expect(bays.map((b) => b.laneKey)).toEqual([1, 2])
+    expect(bays.map((b) => b.slotIndex)).toEqual([0, 1])
+    expect(bays[0].queued).toBe(1)
+    expect(bays[1].queued).toBe(0)
+    expect(bays.every((b) => !b.full)).toBe(true)
+    expect(bays.every((b) => b.thrust > 0 && b.mass > 0)).toBe(true)
+})
+
+test('a bay is full at the job queue cap', () => {
+    const filled = Array.from({length: JOB_QUEUE_CAP}, () => shuttleTask(20, 21))
+    const bays = civicShuttleBays(depotModules(), ITEM_DEPOT_T1_PACKED, [makeLane(1, filled)], T0)
+    expect(bays[0].full).toBe(true)
+    expect(bays[1].full).toBe(false)
+})
+
+const AFTER = new Date(T0.getTime() + 3_600_000)
+
+test('a landed booking leaves the bay free, since booking clears it', () => {
+    const filled = Array.from({length: JOB_QUEUE_CAP}, () => shuttleTask(20, 21))
+    const lanes = [makeLane(1, filled)]
+    const bays = civicShuttleBays(depotModules(), ITEM_DEPOT_T1_PACKED, lanes, AFTER)
+    expect(bays[0].queued).toBe(0)
+    expect(bays[0].full).toBe(false)
+    expect(selectCivicShuttleBay(depotModules(), ITEM_DEPOT_T1_PACKED, lanes, AFTER)?.laneKey).toBe(
+        1
+    )
+})
+
+test('a bay part-way through its queue counts only what is still unfinished', () => {
+    const lanes = [makeLane(1, [shuttleTask(20, 21), shuttleTask(22, 23), shuttleTask(24, 25)])]
+    const bays = civicShuttleBays(
+        depotModules(),
+        ITEM_DEPOT_T1_PACKED,
+        lanes,
+        new Date(T0.getTime() + 90_000)
+    )
+    expect(bays[0].queued).toBe(2)
+})
+
+test('a landed transfer is listed for settling but is not callable', () => {
+    const lanes = [makeLane(1, [shuttleTask(20, 21)])]
+    const [transfer] = pendingCivicTransfers({lanes} as never, AFTER)
+    expect(transfer.isTail).toBe(true)
+    expect(transfer.complete).toBe(true)
+    expect(transfer.callable).toBe(false)
+})
+
+test('landed transfers do not count against the per-player cap', () => {
+    const mine = Array.from({length: CIVIC_TRANSFER_PER_PLAYER_CAP}, (_, i) =>
+        shuttleTask(20 + i, 50)
+    )
+    const senderIds = mine.map((_, i) => 20 + i)
+    const at = {lanes: [makeLane(1, mine)]} as never
+    expect(civicTransfersAtCap(at, senderIds, T0)).toBe(true)
+    expect(civicTransfersAtCap(at, senderIds, AFTER)).toBe(false)
+    expect(civicTransfersFrom(at, senderIds, AFTER).length).toBe(CIVIC_TRANSFER_PER_PLAYER_CAP)
+})
+
+test('selectCivicShuttleBay takes the first free bay, then the lowest occupied one', () => {
+    const modules = depotModules()
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, [], T0)?.laneKey).toBe(1)
+
+    const firstBusy = [makeLane(1, [shuttleTask(20, 21)])]
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, firstBusy, T0)?.laneKey).toBe(2)
+
+    const bothBusy = [makeLane(1, [shuttleTask(20, 21)]), makeLane(2, [shuttleTask(22, 23)])]
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, bothBusy, T0)?.laneKey).toBe(1)
+})
+
+test('selectCivicShuttleBay returns nothing when the building has no loaders', () => {
+    const modules = [makeModuleEntry(ITEM_STORAGE_T1, storageStats)]
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, [], T0)).toBeUndefined()
+})
+
+test('pendingCivicTransfers reports the bay, both counterparties, and the tail', () => {
+    const lanes = [
+        makeLane(1, [shuttleTask(20, 21), shuttleTask(22, 23)]),
+        makeLane(2, [shuttleTask(24, 25)]),
+    ]
+    const transfers = pendingCivicTransfers({lanes} as never, T0)
+    expect(transfers.length).toBe(3)
+
+    const first = transfers.find((t) => String(t.senderId) === '20')!
+    expect(first.laneKey).toBe(1)
+    expect(String(first.receiverId)).toBe('21')
+    expect(first.isTail).toBe(false)
+    expect(first.callable).toBe(false)
+    expect(first.startsAt).toEqual(T0)
+    expect(first.completesAt).toEqual(new Date(T0.getTime() + 60_000))
+
+    const second = transfers.find((t) => String(t.senderId) === '22')!
+    expect(second.isTail).toBe(true)
+    expect(second.callable).toBe(true)
+
+    const onBayTwo = transfers.find((t) => String(t.senderId) === '24')!
+    expect(onBayTwo.laneKey).toBe(2)
+    expect(onBayTwo.callable).toBe(true)
+})
+
+test('a grouped tail transfer is not callable', () => {
+    const lanes = [makeLane(1, [shuttleTask(20, 21, 7)])]
+    const [transfer] = pendingCivicTransfers({lanes} as never, T0)
+    expect(transfer.isTail).toBe(true)
+    expect(transfer.callable).toBe(false)
+})
+
+test('civicTransfersFrom counts only the ships a player sends from', () => {
+    const lanes = [
+        makeLane(1, [shuttleTask(20, 21), shuttleTask(30, 31)]),
+        makeLane(2, [shuttleTask(22, 23)]),
+    ]
+    const entity = {lanes} as never
+    expect(civicTransfersFrom(entity, [20, 22], T0).length).toBe(2)
+    expect(civicTransfersFrom(entity, [30], T0).length).toBe(1)
+    expect(civicTransfersFrom(entity, [99], T0).length).toBe(0)
+})
+
+test('civicTransfersAtCap trips at the per-player cap', () => {
+    const mine = Array.from({length: CIVIC_TRANSFER_PER_PLAYER_CAP}, (_, i) =>
+        shuttleTask(20 + i, 50)
+    )
+    const senderIds = mine.map((_, i) => 20 + i)
+    const under = {lanes: [makeLane(1, mine.slice(0, -1))]} as never
+    const at = {lanes: [makeLane(1, mine)]} as never
+    expect(civicTransfersAtCap(under, senderIds, T0)).toBe(false)
+    expect(civicTransfersAtCap(at, senderIds, T0)).toBe(true)
+})

package/src/influence/civic-shuttle.ts

@@ -0,0 +1,142 @@
+import type {UInt64} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+import {getItem} from '../data/catalog'
+import {JOB_QUEUE_CAP} from '../scheduling/jobs'
+import {laneKeyForModule, resolveLaneLoader} from '../scheduling/lanes'
+import {orderedTasks, type ScheduleData} from '../scheduling/schedule'
+import {HoldKind, TaskType} from '../types'
+
+type CargoItem = ServerContract.Types.cargo_item
+type Lane = ServerContract.Types.lane
+type ModuleEntry = ServerContract.Types.module_entry
+
+export const CIVIC_TRANSFER_PER_PLAYER_CAP = 4
+
+export interface CivicShuttleBay {
+    laneKey: number
+    slotIndex: number
+    thrust: number
+    mass: number
+    outputPct: number
+    queued: number
+    full: boolean
+}
+
+// a landed booking clears during the next civicshuttle, so only unfinished tasks occupy a bay
+function unfinishedTasks(lane: Lane | undefined, now: Date): number {
+    if (!lane) return 0
+    const startedMs = lane.schedule.started.toDate().getTime()
+    const nowMs = now.getTime()
+    let endSec = 0
+    let count = 0
+    for (const task of lane.schedule.tasks) {
+        endSec += task.duration.toNumber()
+        if (startedMs + endSec * 1000 > nowMs) count++
+    }
+    return count
+}
+
+export function civicShuttleBays(
+    modules: ModuleEntry[],
+    entityItemId: number,
+    lanes: Lane[],
+    now: Date = new Date()
+): CivicShuttleBay[] {
+    const bays: CivicShuttleBay[] = []
+    for (let slotIndex = 0; slotIndex < modules.length; slotIndex++) {
+        const installed = modules[slotIndex].installed
+        if (!installed) continue
+        if (getItem(installed.item_id).moduleType !== 'loader') continue
+        const laneKey = laneKeyForModule(slotIndex)
+        const loader = resolveLaneLoader(modules, entityItemId, laneKey)
+        const lane = lanes.find((l) => l.lane_key.toNumber() === laneKey)
+        const queued = unfinishedTasks(lane, now)
+        bays.push({
+            laneKey,
+            slotIndex,
+            thrust: loader.thrust,
+            mass: loader.mass,
+            outputPct: loader.outputPct,
+            queued,
+            full: queued >= JOB_QUEUE_CAP,
+        })
+    }
+    return bays
+}
+
+// Mirrors worker_lane_key_or_mobility for loaders: first free bay, else the lowest bay.
+export function selectCivicShuttleBay(
+    modules: ModuleEntry[],
+    entityItemId: number,
+    lanes: Lane[],
+    now: Date = new Date()
+): CivicShuttleBay | undefined {
+    const bays = civicShuttleBays(modules, entityItemId, lanes, now)
+    return bays.find((bay) => bay.queued === 0) ?? bays[0]
+}
+
+export interface PendingCivicTransfer {
+    laneKey: number
+    taskIndex: number
+    senderId: UInt64
+    receiverId: UInt64
+    cargo: CargoItem[]
+    startsAt: Date
+    completesAt: Date
+    isTail: boolean
+    complete: boolean
+    callable: boolean
+}
+
+export function pendingCivicTransfers(
+    entity: ScheduleData,
+    now: Date = new Date()
+): PendingCivicTransfer[] {
+    const tailIndex = new Map<number, number>()
+    for (const l of entity.lanes ?? []) {
+        tailIndex.set(l.lane_key.toNumber(), l.schedule.tasks.length - 1)
+    }
+    const out: PendingCivicTransfer[] = []
+    for (const entry of orderedTasks(entity)) {
+        if (entry.task.type.toNumber() !== TaskType.SHUTTLE) continue
+        const pull = entry.task.couplings.find((c) => c.kind.toNumber() === HoldKind.PULL)
+        const push = entry.task.couplings.find((c) => c.kind.toNumber() === HoldKind.PUSH)
+        if (!pull || !push) continue
+        const isTail = tailIndex.get(entry.laneKey) === entry.taskIndex
+        const complete = entry.completesAt.getTime() <= now.getTime()
+        out.push({
+            laneKey: entry.laneKey,
+            taskIndex: entry.taskIndex,
+            senderId: pull.counterpart.entity_id,
+            receiverId: push.counterpart.entity_id,
+            cargo: entry.task.cargo,
+            startsAt: entry.startsAt,
+            completesAt: entry.completesAt,
+            isTail,
+            complete,
+            callable: isTail && !complete && !entry.task.entitygroup,
+        })
+    }
+    return out
+}
+
+// Mirrors civic_transfers_for: the sender side of every shuttle the building holds, by owner.
+export function civicTransfersFrom(
+    entity: ScheduleData,
+    senderIds: Array<UInt64 | string | number>,
+    now: Date = new Date()
+): PendingCivicTransfer[] {
+    const owned = new Set(senderIds.map((id) => String(id)))
+    return pendingCivicTransfers(entity, now).filter((t) => owned.has(String(t.senderId)))
+}
+
+export function civicTransfersAtCap(
+    entity: ScheduleData,
+    senderIds: Array<UInt64 | string | number>,
+    now: Date = new Date()
+): boolean {
+    return (
+        civicTransfersFrom(entity, senderIds, now).filter((t) => !t.complete).length >=
+        CIVIC_TRANSFER_PER_PLAYER_CAP
+    )
+}

package/src/influence/civic.test.ts

@@ -54,6 +54,8 @@ const NODE_DOCK_TUNEUPS = [30100301, 30100302, 30100303, 30100304]
 const NODE_DEPOT = 40100001
 const NODE_DEPOT_BAYS = [40100101, 40100102, 40100103, 40100104]
 const NODE_DEPOT_LOADERS = [40100401, 40100402, 40100403, 40100404]
+const DEPOT_LOADER_SLOTS = [0, 1]
+const DEPOT_BAY_SLOTS = [2, 3, 4, 5]
 
 function node(nodeId: number): CharterNode {
     const found = charterNode(nodeId)
@@ -168,14 +170,16 @@ describe('the fourteen nodes reproduce the chain-fitted buildings', () => {
         expect(raised).toBe(400)
     })
 
-    test('the Depot node fits a baseline loader and leaves the bays empty', () => {
+    test('the Depot node fits two baseline loaders and leaves the bays empty', () => {
         const standing = complete(complete({}, NODE_WORKSHOP), NODE_DEPOT)
         const depot = {modules: standing[CIVIC_DEPOT]!}
-        expect(stats(depot, 0)).toEqual({
-            itemId: ITEM_LOADER_T1,
-            stats: [CHARTER_BASELINE_STAT, CHARTER_BASELINE_STAT],
-        })
-        for (let slot = 1; slot <= 4; slot++) expect(depot.modules[slot].installed).toBeUndefined()
+        for (const slot of DEPOT_LOADER_SLOTS) {
+            expect(stats(depot, slot)).toEqual({
+                itemId: ITEM_LOADER_T1,
+                stats: [CHARTER_BASELINE_STAT, CHARTER_BASELINE_STAT],
+            })
+        }
+        for (const slot of DEPOT_BAY_SLOTS) expect(depot.modules[slot].installed).toBeUndefined()
     })
 
     test('the four bays fill the storage slots in order at the baseline stat', () => {
@@ -183,8 +187,9 @@ describe('the fourteen nodes reproduce the chain-fitted buildings', () => {
         for (let i = 0; i < NODE_DEPOT_BAYS.length; i++) {
             standing = complete(standing, NODE_DEPOT_BAYS[i])
             const depot = {modules: standing[CIVIC_DEPOT]!}
-            for (let slot = 1; slot <= 4; slot++) {
-                if (slot <= i + 1) {
+            for (let bay = 0; bay < DEPOT_BAY_SLOTS.length; bay++) {
+                const slot = DEPOT_BAY_SLOTS[bay]
+                if (bay <= i) {
                     expect(stats(depot, slot)).toEqual({
                         itemId: ITEM_STORAGE_T1,
                         stats: [
@@ -201,14 +206,16 @@ describe('the fourteen nodes reproduce the chain-fitted buildings', () => {
         }
     })
 
-    test('the four loader rungs step the slot-0 loader by one rung each, reaching 400', () => {
+    test('the four loader rungs step both loaders by one rung each, reaching 400', () => {
         let standing = complete(complete({}, NODE_WORKSHOP), NODE_DEPOT)
         for (let i = 0; i < NODE_DEPOT_LOADERS.length; i++) {
             standing = complete(standing, NODE_DEPOT_LOADERS[i])
             const depot = {modules: standing[CIVIC_DEPOT]!}
             const stat = CHARTER_BASELINE_STAT + CHARTER_RUNG_STEP * (i + 1)
-            expect(stats(depot, 0)).toEqual({itemId: ITEM_LOADER_T1, stats: [stat, stat]})
-            for (let slot = 1; slot <= 4; slot++)
+            for (const slot of DEPOT_LOADER_SLOTS) {
+                expect(stats(depot, slot)).toEqual({itemId: ITEM_LOADER_T1, stats: [stat, stat]})
+            }
+            for (const slot of DEPOT_BAY_SLOTS)
                 expect(depot.modules[slot].installed).toBeUndefined()
         }
     })
@@ -223,8 +230,10 @@ describe('grant mechanics', () => {
             stat: CIVIC_STAT_TRANSFER_SPEED,
             value: 50,
         })
-        const withBay = fitCivicModules(raised, 1)
-        expect(stats({modules: withBay}, 1).stats).toEqual([0, 0, 0, 0])
+        const withSecondLoader = fitCivicModules(raised, 1)
+        expect(stats({modules: withSecondLoader}, 1).stats).toEqual([50, 50])
+        const withBay = fitCivicModules(withSecondLoader, 1)
+        expect(stats({modules: withBay}, 2).stats).toEqual([0, 0, 0, 0])
         const withSecondBay = fitCivicModules(
             raiseCivicStat(withBay, {
                 kind: CIVIC_GRANT_RUNG,
@@ -234,7 +243,7 @@ describe('grant mechanics', () => {
             }),
             1
         )
-        expect(stats({modules: withSecondBay}, 2).stats).toEqual([7, 7, 7, 7])
+        expect(stats({modules: withSecondBay}, 3).stats).toEqual([7, 7, 7, 7])
     })
 
     test('a rung caps at the civic speed cap', () => {

package/src/influence/index.ts

@@ -43,6 +43,16 @@ export {
     type CivicLoaderStats,
     type DepotTransferParams,
 } from './duration'
+export {
+    civicShuttleBays,
+    civicTransfersAtCap,
+    civicTransfersFrom,
+    pendingCivicTransfers,
+    selectCivicShuttleBay,
+    CIVIC_TRANSFER_PER_PLAYER_CAP,
+    type CivicShuttleBay,
+    type PendingCivicTransfer,
+} from './civic-shuttle'
 export {citizenryName, citizenryPatternCount} from './citizenry'
 export {
     charterBuildingEntity,

package/src/managers/actions.ts

@@ -366,6 +366,28 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    civicshuttle(
+        buildingId: UInt64Type,
+        fromId: UInt64Type,
+        toId: UInt64Type,
+        items: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        return this.server.action('civicshuttle', {
+            building: UInt64.from(buildingId),
+            from_id: UInt64.from(fromId),
+            to_id: UInt64.from(toId),
+            items,
+        })
+    }
+
+    cancelcivic(buildingId: UInt64Type, laneKey: UInt8Type, fromId: UInt64Type): Action {
+        return this.server.action('cancelcivic', {
+            building: UInt64.from(buildingId),
+            lane_key: UInt8.from(laneKey),
+            from_id: UInt64.from(fromId),
+        })
+    }
+
     launch(
         launcherId: UInt64Type,
         catcherId: UInt64Type,
@@ -982,6 +1004,18 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    setdeadline(deadline: UInt32Type): Action {
+        return this.server.action('setdeadline', {
+            deadline: UInt32.from(deadline),
+        })
+    }
+
+    closeepoch(epoch: UInt64Type): Action {
+        return this.server.action('closeepoch', {
+            epoch: UInt64.from(epoch),
+        })
+    }
+
     cleanrsvp(epoch: UInt64Type, maxRows: UInt64Type): Action {
         return this.server.action('cleanrsvp', {
             epoch: UInt64.from(epoch),

package/src/managers/epochs.ts

@@ -1,8 +1,17 @@
-import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {Checksum256, UInt64, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {type EpochInfo, getCurrentEpoch, getEpochInfo} from '../scheduling/epoch'
 import type {ServerContract} from '../contracts'
 
+export const DEFAULT_EPOCH_DEADLINE = 10800
+
+const EMPTY_SEED = Checksum256.from('0'.repeat(64))
+
+export interface EpochQuorumState {
+    threshold: number
+    finalized: boolean
+}
+
 export class EpochsManager extends BaseManager {
     async getCurrentHeight(): Promise<UInt64> {
         const game = await this.getGame()
@@ -56,6 +65,12 @@ export class EpochsManager extends BaseManager {
         return this.server.table('epoch').get(target)
     }
 
+    async getEpochState(epoch: UInt64Type): Promise<EpochQuorumState> {
+        const row = await this.getEpochRow(epoch)
+        if (!row) return {threshold: 0, finalized: false}
+        return {threshold: Number(row.threshold), finalized: !row.seed.equals(EMPTY_SEED)}
+    }
+
     async getActiveEpochInfo(): Promise<ServerContract.Types.epoch_row | undefined> {
         const rows = await this.server.table('epoch').all()
         if (rows.length === 0) {
@@ -73,6 +88,22 @@ export class EpochsManager extends BaseManager {
         return cfg ? Number(cfg.threshold) : 0
     }
 
+    async getDeadline(): Promise<number> {
+        const cfg = await this.server.table('oraclecfg').get()
+        return cfg ? Number(cfg.deadline) : DEFAULT_EPOCH_DEADLINE
+    }
+
+    async getCloseDueAt(epoch: UInt64Type): Promise<Date> {
+        const info = await this.getByHeight(epoch)
+        const deadline = await this.getDeadline()
+        return new Date(info.start.getTime() + deadline * 1000)
+    }
+
+    async getSecondsUntilClose(epoch: UInt64Type): Promise<number> {
+        const dueAt = await this.getCloseDueAt(epoch)
+        return Math.ceil((dueAt.getTime() - Date.now()) / 1000)
+    }
+
     async getCommitsFor(epoch: UInt64Type): Promise<ServerContract.Types.commit_row[]> {
         const target = UInt64.from(epoch)
         const rows = await this.server.table('commit').all()

package/src/scheduling/epoch.ts

@@ -10,6 +10,7 @@ export interface EpochInfo {
 export function getCurrentEpoch(game: PlatformContract.Types.game_row): UInt64 {
     const current = new Date().getTime()
     const difference = (current - game.config.start.toMilliseconds()) / 1000
+    if (difference < 0) return UInt64.from(0)
     const epoch = Math.floor(difference / Number(game.config.epochtime)) + 1
     return UInt64.from(epoch)
 }

package/src/utils/system.ts

@@ -161,7 +161,12 @@ export function isLocationBuildable(
     gameSeed: Checksum256Type,
     coordinates: CoordinatesType
 ): boolean {
-    return getLocationType(gameSeed, coordinates) === LocationType.PLANET
+    const type = getLocationType(gameSeed, coordinates)
+    return (
+        type === LocationType.ASTEROID ||
+        type === LocationType.NEBULA ||
+        type === LocationType.ICE_FIELD
+    )
 }
 
 export function deriveLocation(