@jgengine/core 0.1.0

package/dist/time/calendarClock.d.ts

@@ -0,0 +1,17 @@
+export interface GameTime {
+    year: number;
+    month: number;
+    monthName: string;
+    monthNameFull: string;
+    dayOfMonth: number;
+    hour: number;
+    minute: number;
+    second: number;
+    formattedDate: string;
+    formattedDateFull: string;
+    formattedTime: string;
+    formatted: string;
+}
+export declare function computeGameTime(gameTimestamp: number): GameTime;
+export declare function computeClientServerOffset(serverNow: number, clientNow: number): number;
+export declare function getGameClockTimestamp(createdAt: number, serverNow: number, clientNow: number, gameTimeScale?: number): number;

package/dist/time/calendarClock.js

@@ -0,0 +1,42 @@
+import { getCurrentGameTimestamp, sanitizeGameTimeScale } from "@jgengine/core/time/gameClock";
+const MONTH_NAMES_SHORT = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const MONTH_NAMES_FULL = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+export function computeGameTime(gameTimestamp) {
+    const d = new Date(gameTimestamp);
+    const year = d.getFullYear();
+    const month = d.getMonth() + 1;
+    const monthName = MONTH_NAMES_SHORT[d.getMonth()] ?? "Jan";
+    const monthNameFull = MONTH_NAMES_FULL[d.getMonth()] ?? "January";
+    const dayOfMonth = d.getDate();
+    const hour = d.getHours();
+    const minute = d.getMinutes();
+    const second = d.getSeconds();
+    const pad = (n) => n.toString().padStart(2, "0");
+    const hour12 = hour % 12 || 12;
+    const ampm = hour < 12 ? "AM" : "PM";
+    const formattedDate = `${monthName} ${dayOfMonth}, ${year}`;
+    const formattedDateFull = `${monthNameFull} ${dayOfMonth}, ${year}`;
+    const formattedTime = `${hour12}:${pad(minute)} ${ampm}`;
+    const formatted = `${formattedDate} ${formattedTime}`;
+    return {
+        year,
+        month,
+        monthName,
+        monthNameFull,
+        dayOfMonth,
+        hour,
+        minute,
+        second,
+        formattedDate,
+        formattedDateFull,
+        formattedTime,
+        formatted,
+    };
+}
+export function computeClientServerOffset(serverNow, clientNow) {
+    return serverNow - clientNow;
+}
+export function getGameClockTimestamp(createdAt, serverNow, clientNow, gameTimeScale) {
+    const clientOffsetMs = computeClientServerOffset(serverNow, clientNow);
+    return getCurrentGameTimestamp(createdAt, clientNow + clientOffsetMs, sanitizeGameTimeScale(gameTimeScale));
+}

package/dist/time/gameClock.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Simulation clock: real time scaled into game time, plus the derived game-day counter.
+ */
+export declare const DEFAULT_TIME_SCALE = 24;
+export declare const SECONDS_PER_GAME_DAY: number;
+export declare function sanitizeGameTimeScale(timeScale?: number | null): number;
+export declare function getScaledElapsedMs(createdAt: number, now: number, timeScale?: number | null): number;
+export declare function getCurrentGameTimestamp(createdAt: number, now: number, timeScale?: number | null): number;
+export declare function computeGameDay(createdAt: number, now?: number, timeScale?: number | null): number;

package/dist/time/gameClock.js

@@ -0,0 +1,20 @@
+/**
+ * Simulation clock: real time scaled into game time, plus the derived game-day counter.
+ */
+export const DEFAULT_TIME_SCALE = 24;
+export const SECONDS_PER_GAME_DAY = 24 * 3600;
+export function sanitizeGameTimeScale(timeScale) {
+    if (typeof timeScale !== "number" || !Number.isFinite(timeScale) || timeScale <= 0) {
+        return DEFAULT_TIME_SCALE;
+    }
+    return timeScale;
+}
+export function getScaledElapsedMs(createdAt, now, timeScale) {
+    return Math.max(0, Math.floor((now - createdAt) * sanitizeGameTimeScale(timeScale)));
+}
+export function getCurrentGameTimestamp(createdAt, now, timeScale) {
+    return createdAt + getScaledElapsedMs(createdAt, now, timeScale);
+}
+export function computeGameDay(createdAt, now = Date.now(), timeScale) {
+    return Math.floor(getScaledElapsedMs(createdAt, now, timeScale) / 1000 / SECONDS_PER_GAME_DAY);
+}

package/dist/time/serverTick.d.ts

@@ -0,0 +1,16 @@
+export interface TickSystemDefinition<TSystemId extends string = string> {
+    id: TSystemId;
+    /** Minimum real time between runs; the heartbeat fires the system on the first tick at or past it. */
+    intervalMs: number;
+}
+/** Last-run timestamp per system id. */
+export type TickAnchors = Record<string, number>;
+export interface ServerTickPlan<TSystemId extends string = string> {
+    due: TSystemId[];
+    anchors: TickAnchors;
+}
+/**
+ * Decides which systems a heartbeat should run. A system with no anchor runs immediately.
+ * Returned anchors carry only systems present in the pipeline, so removed systems clean up.
+ */
+export declare function planServerTick<TSystemId extends string>(systems: readonly TickSystemDefinition<TSystemId>[], anchors: TickAnchors, now: number): ServerTickPlan<TSystemId>;

package/dist/time/serverTick.js

@@ -0,0 +1,18 @@
+/**
+ * Decides which systems a heartbeat should run. A system with no anchor runs immediately.
+ * Returned anchors carry only systems present in the pipeline, so removed systems clean up.
+ */
+export function planServerTick(systems, anchors, now) {
+    const due = [];
+    const nextAnchors = {};
+    for (const system of systems) {
+        const lastRunAt = anchors[system.id];
+        if (lastRunAt !== undefined && now - lastRunAt < system.intervalMs) {
+            nextAnchors[system.id] = lastRunAt;
+            continue;
+        }
+        due.push(system.id);
+        nextAnchors[system.id] = now;
+    }
+    return { due, anchors: nextAnchors };
+}

package/dist/world/features.d.ts

@@ -0,0 +1,39 @@
+export interface WorldBounds {
+    w: number;
+    d: number;
+}
+export interface BiomesWorldConfig {
+    map: string;
+    zones: string;
+    bounds?: WorldBounds;
+}
+export interface VoxelWorldConfig {
+    seed: string;
+    generate?: string;
+    streaming?: {
+        radius: number;
+    };
+}
+export interface PlotsWorldConfig {
+    city?: string;
+    interiors?: string;
+}
+export interface TilemapWorldConfig {
+    map: string;
+}
+export type WorldFeature = ({
+    kind: "biomes";
+} & BiomesWorldConfig) | ({
+    kind: "voxel";
+} & VoxelWorldConfig) | ({
+    kind: "plots";
+} & PlotsWorldConfig) | ({
+    kind: "tilemap";
+} & TilemapWorldConfig) | {
+    kind: "flat";
+};
+export declare function biomes(config: BiomesWorldConfig): WorldFeature;
+export declare function voxel(config: VoxelWorldConfig): WorldFeature;
+export declare function plots(config?: PlotsWorldConfig): WorldFeature;
+export declare function tilemap(config: TilemapWorldConfig): WorldFeature;
+export declare function flat(): WorldFeature;

package/dist/world/features.js

@@ -0,0 +1,15 @@
+export function biomes(config) {
+    return { kind: "biomes", ...config };
+}
+export function voxel(config) {
+    return { kind: "voxel", ...config };
+}
+export function plots(config = {}) {
+    return { kind: "plots", ...config };
+}
+export function tilemap(config) {
+    return { kind: "tilemap", ...config };
+}
+export function flat() {
+    return { kind: "flat" };
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@jgengine/core",
+  "version": "0.1.0",
+  "description": "Genre-agnostic TypeScript game engine SDK: game runtime, state store, entity scene, combat, movement, inventory, economy, quests, multiplayer primitives.",
+  "license": "AGPL-3.0-only",
+  "type": "module",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Noisemaker111/jgengine.git",
+    "directory": "packages/core"
+  },
+  "files": ["dist"],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && bun ../../scripts/fix-extensions.ts dist",
+    "check-types": "tsc --noEmit -p tsconfig.json",
+    "test": "bun test src"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}