create-gametau 0.2.1 → 0.3.0

package/README.md

@@ -38,6 +38,19 @@ bunx create-gametau my-game --template vanilla
 - `src-tauri/app` - Tauri desktop shell
 - `src-tauri/wasm` - WASM entry crate
 - `src` - frontend app wired to `webtau` and `webtau-vite`
+- `src/services` - production-ready service seams for backend invoke calls, persistence/settings, mission session snapshots, and event-driven comms
+
+## Service Layer Contract
+
+The scaffolded base template now ships a small service architecture instead of a single command wrapper:
+
+- `src/services/backend.ts` - typed `invoke()` wrappers for gameplay commands
+- `src/services/settings.ts` - runtime settings persistence via `webtau/path` + `webtau/fs`
+- `src/services/session.ts` - mission/session snapshot persistence via `webtau/path` + `webtau/fs`
+- `src/services/comms.ts` - typed alert/comms channel over `webtau/event`
+- `src/services/contracts.ts` - interfaces/types for settings, session snapshots, and alerts
+
+This keeps the generated project lightweight while giving contributors clear extension points for production features.
 
 For full docs and package details, see the main repository:
 <https://github.com/devallibus/gametau>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-gametau",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Scaffold a Tauri game that deploys to web + desktop",
   "license": "Apache-2.0",
   "repository": {

package/templates/base/index.html

@@ -25,6 +25,10 @@
     <div id="hud">
       <div>Score: <span id="score">0</span></div>
       <div>Tick: <span id="tick">0</span></div>
+      <div>Tick Rate: <span id="tick-rate">0</span> Hz</div>
+      <div>Autosave: every <span id="autosave">0</span> ticks</div>
+      <div>Session: <span id="session">fresh</span></div>
+      <div>Alert: <span id="alert">ready</span></div>
     </div>
     <div id="app"></div>
     <script type="module" src="/src/index.ts"></script>

package/templates/base/package.json

@@ -11,12 +11,12 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "webtau": "^0.2.0"
+    "webtau": "^0.3.0"
   },
   "devDependencies": {
     "typescript": "^5.8.0",
     "vite": "^6.0.0",
-    "webtau-vite": "^0.2.0",
+    "webtau-vite": "^0.3.0",
     "@tauri-apps/cli": "^2.0.0",
     "@tauri-apps/api": "^2.0.0"
   }

package/templates/base/src/index.ts

@@ -1,7 +1,27 @@
 import { configure, isTauri } from "webtau";
-import { getWorldView, tickWorld } from "./services/backend";
 import { startGameLoop } from "./game/loop";
 import { initScene, updateScene } from "./game/scene";
+import {
+  createServiceLayer,
+  getWorldView,
+  tickWorld,
+  type AlertLevel,
+  type RuntimeSettings,
+  type WorldView,
+} from "./services";
+
+function resolveAlertLevel(scoreDelta: number): AlertLevel {
+  if (scoreDelta >= 2) return "critical";
+  if (scoreDelta > 0) return "info";
+  return "warning";
+}
+
+function updateHud(view: WorldView, settings: RuntimeSettings): void {
+  document.getElementById("score")!.textContent = String(view.score);
+  document.getElementById("tick")!.textContent = String(view.tick_count);
+  document.getElementById("tick-rate")!.textContent = String(settings.tickRateHz);
+  document.getElementById("autosave")!.textContent = String(settings.autoSaveEveryTicks);
+}
 
 async function main() {
   // Configure webtau for web mode (no-op in Tauri)
@@ -20,27 +40,56 @@ async function main() {
   const app = document.getElementById("app")!;
   await initScene(app);
 
-  // Get initial state
+  // Build service seams up front: backend invoke wrappers + fs/path + event orchestration.
+  const services = await createServiceLayer();
+  const settings = await services.settings.load();
+  const previousSession = await services.session.loadLastSnapshot();
+  document.getElementById("session")!.textContent = previousSession
+    ? `restored (${previousSession.savedAt})`
+    : "fresh";
+  document.getElementById("alert")!.textContent = "ready";
+
+  const unlistenAlerts = await services.comms.subscribe((message) => {
+    document.getElementById("alert")!.textContent = `[${message.level}] ${message.message}`;
+  });
+  window.addEventListener("beforeunload", () => {
+    unlistenAlerts();
+  });
+
+  // Persist settings on first run so users have an explicit config seam to extend.
+  await services.settings.save(settings);
+
+  // Get and display initial state.
   const view = await getWorldView();
-  document.getElementById("score")!.textContent = String(view.score);
-  document.getElementById("tick")!.textContent = String(view.tick_count);
+  updateHud(view, settings);
+  await services.session.saveSnapshot(view);
 
   // Start game loop
   let tickAccumulator = 0;
   let tickInFlight = false;
-  const TICK_RATE = 1 / 10; // 10 ticks per second
+  const tickRate = 1 / settings.tickRateHz;
 
   startGameLoop(
     (dt) => {
       tickAccumulator += dt;
-      if (!tickInFlight && tickAccumulator >= TICK_RATE) {
-        tickAccumulator -= TICK_RATE;
+      if (!tickInFlight && tickAccumulator >= tickRate) {
+        tickAccumulator -= tickRate;
         tickInFlight = true;
         tickWorld()
-          .then(() => getWorldView())
-          .then((view) => {
-            document.getElementById("score")!.textContent = String(view.score);
-            document.getElementById("tick")!.textContent = String(view.tick_count);
+          .then(async (tickResult) => {
+            const nextView = await getWorldView();
+            updateHud(nextView, settings);
+
+            if (nextView.tick_count % settings.autoSaveEveryTicks === 0) {
+              await services.session.saveSnapshot(nextView);
+              document.getElementById("session")!.textContent = `saved at tick ${nextView.tick_count}`;
+            }
+
+            await services.comms.publish({
+              level: resolveAlertLevel(tickResult.score_delta),
+              source: "engine",
+              message: `score delta ${tickResult.score_delta}`,
+            });
           })
           .catch(console.error)
           .finally(() => { tickInFlight = false; });

package/templates/base/src/services/comms.ts

@@ -0,0 +1,32 @@
+import { emit, listen } from "webtau/event";
+import type { AlertMessage, CommsService } from "./contracts";
+
+const COMMS_NAMESPACE = "gametau:comms";
+
+function eventNameFor(channel: string): string {
+  return `${COMMS_NAMESPACE}:${channel}`;
+}
+
+export function createCommsService(channel: string): CommsService {
+  const eventName = eventNameFor(channel);
+
+  return {
+    channel,
+
+    async publish(input): Promise<void> {
+      const payload: AlertMessage = {
+        level: input.level,
+        source: input.source,
+        message: input.message,
+        timestamp: input.timestamp ?? new Date().toISOString(),
+      };
+      await emit(eventName, payload);
+    },
+
+    async subscribe(handler): Promise<() => void> {
+      return listen<AlertMessage>(eventName, ({ payload }) => {
+        handler(payload);
+      });
+    },
+  };
+}

package/templates/base/src/services/contracts.ts

@@ -0,0 +1,48 @@
+import type { WorldView } from "./backend";
+
+export type AlertLevel = "info" | "warning" | "critical";
+
+export interface AlertMessage {
+  level: AlertLevel;
+  source: string;
+  message: string;
+  timestamp: string;
+}
+
+export interface RuntimeSettings {
+  tickRateHz: number;
+  autoSaveEveryTicks: number;
+  commsChannel: string;
+}
+
+export const DEFAULT_RUNTIME_SETTINGS: RuntimeSettings = {
+  tickRateHz: 10,
+  autoSaveEveryTicks: 10,
+  commsChannel: "ops",
+};
+
+export interface SessionSnapshot extends WorldView {
+  savedAt: string;
+}
+
+export interface SettingsService {
+  load(): Promise<RuntimeSettings>;
+  save(next: Partial<RuntimeSettings>): Promise<RuntimeSettings>;
+}
+
+export interface SessionService {
+  loadLastSnapshot(): Promise<SessionSnapshot | null>;
+  saveSnapshot(view: WorldView): Promise<void>;
+}
+
+export interface CommsService {
+  readonly channel: string;
+  publish(input: Omit<AlertMessage, "timestamp"> & { timestamp?: string }): Promise<void>;
+  subscribe(handler: (message: AlertMessage) => void): Promise<() => void>;
+}
+
+export interface ServiceLayer {
+  settings: SettingsService;
+  session: SessionService;
+  comms: CommsService;
+}

package/templates/base/src/services/index.ts

@@ -0,0 +1,28 @@
+import { createCommsService } from "./comms";
+import {
+  DEFAULT_RUNTIME_SETTINGS,
+  type AlertLevel,
+  type AlertMessage,
+  type RuntimeSettings,
+  type SessionSnapshot,
+  type ServiceLayer,
+} from "./contracts";
+import { createSessionService } from "./session";
+import { createSettingsService } from "./settings";
+
+export * from "./backend";
+export {
+  DEFAULT_RUNTIME_SETTINGS,
+  type RuntimeSettings,
+  type AlertLevel,
+  type AlertMessage,
+  type SessionSnapshot,
+};
+
+export async function createServiceLayer(): Promise<ServiceLayer> {
+  const settings = createSettingsService();
+  const resolvedSettings = await settings.load();
+  const comms = createCommsService(resolvedSettings.commsChannel);
+  const session = createSessionService();
+  return { settings, comms, session };
+}

package/templates/base/src/services/session.ts

@@ -0,0 +1,59 @@
+import { createDir, exists, readTextFile, writeTextFile } from "webtau/fs";
+import { appDataDir, join } from "webtau/path";
+import type { SessionService, SessionSnapshot } from "./contracts";
+import type { WorldView } from "./backend";
+
+const SESSION_FILENAME = "mission-session.json";
+
+function toSnapshot(view: WorldView): SessionSnapshot {
+  return {
+    ...view,
+    savedAt: new Date().toISOString(),
+  };
+}
+
+function parseSnapshot(raw: unknown): SessionSnapshot | null {
+  if (!raw || typeof raw !== "object") return null;
+  const candidate = raw as Partial<SessionSnapshot>;
+  if (
+    typeof candidate.score !== "number" ||
+    typeof candidate.tick_count !== "number" ||
+    typeof candidate.savedAt !== "string"
+  ) {
+    return null;
+  }
+  return {
+    score: candidate.score,
+    tick_count: candidate.tick_count,
+    savedAt: candidate.savedAt,
+  };
+}
+
+async function getSessionPath(): Promise<string> {
+  const dataDir = await appDataDir();
+  await createDir(dataDir, { recursive: true });
+  return join(dataDir, SESSION_FILENAME);
+}
+
+export function createSessionService(): SessionService {
+  return {
+    async loadLastSnapshot(): Promise<SessionSnapshot | null> {
+      const sessionPath = await getSessionPath();
+      if (!(await exists(sessionPath))) {
+        return null;
+      }
+      try {
+        const raw = await readTextFile(sessionPath);
+        return parseSnapshot(JSON.parse(raw) as unknown);
+      } catch {
+        return null;
+      }
+    },
+
+    async saveSnapshot(view: WorldView): Promise<void> {
+      const sessionPath = await getSessionPath();
+      const snapshot = toSnapshot(view);
+      await writeTextFile(sessionPath, JSON.stringify(snapshot, null, 2));
+    },
+  };
+}

package/templates/base/src/services/settings.ts

@@ -0,0 +1,69 @@
+import { createDir, exists, readTextFile, writeTextFile } from "webtau/fs";
+import { appConfigDir, join } from "webtau/path";
+import {
+  DEFAULT_RUNTIME_SETTINGS,
+  type RuntimeSettings,
+  type SettingsService,
+} from "./contracts";
+
+const SETTINGS_FILENAME = "runtime-settings.json";
+
+function normalizeSettings(raw: unknown): RuntimeSettings {
+  if (!raw || typeof raw !== "object") {
+    return DEFAULT_RUNTIME_SETTINGS;
+  }
+  const candidate = raw as Partial<RuntimeSettings>;
+  const tickRateHz =
+    typeof candidate.tickRateHz === "number" && Number.isFinite(candidate.tickRateHz)
+      ? Math.max(1, Math.floor(candidate.tickRateHz))
+      : DEFAULT_RUNTIME_SETTINGS.tickRateHz;
+  const autoSaveEveryTicks =
+    typeof candidate.autoSaveEveryTicks === "number" && Number.isFinite(candidate.autoSaveEveryTicks)
+      ? Math.max(1, Math.floor(candidate.autoSaveEveryTicks))
+      : DEFAULT_RUNTIME_SETTINGS.autoSaveEveryTicks;
+  const commsChannel =
+    typeof candidate.commsChannel === "string" && candidate.commsChannel.trim().length > 0
+      ? candidate.commsChannel.trim()
+      : DEFAULT_RUNTIME_SETTINGS.commsChannel;
+
+  return { tickRateHz, autoSaveEveryTicks, commsChannel };
+}
+
+async function getSettingsPath(): Promise<string> {
+  const configDir = await appConfigDir();
+  await createDir(configDir, { recursive: true });
+  return join(configDir, SETTINGS_FILENAME);
+}
+
+export function createSettingsService(): SettingsService {
+  let cache: RuntimeSettings | null = null;
+
+  return {
+    async load(): Promise<RuntimeSettings> {
+      if (cache) return cache;
+
+      const settingsPath = await getSettingsPath();
+      if (!(await exists(settingsPath))) {
+        cache = DEFAULT_RUNTIME_SETTINGS;
+        return cache;
+      }
+
+      try {
+        const raw = await readTextFile(settingsPath);
+        cache = normalizeSettings(JSON.parse(raw) as unknown);
+      } catch {
+        cache = DEFAULT_RUNTIME_SETTINGS;
+      }
+      return cache;
+    },
+
+    async save(next: Partial<RuntimeSettings>): Promise<RuntimeSettings> {
+      const current = await this.load();
+      const merged = normalizeSettings({ ...current, ...next });
+      const settingsPath = await getSettingsPath();
+      await writeTextFile(settingsPath, JSON.stringify(merged, null, 2));
+      cache = merged;
+      return merged;
+    },
+  };
+}

package/templates/base/src-tauri/commands/Cargo.toml

@@ -5,7 +5,7 @@ edition.workspace = true
 
 [dependencies]
 {{PROJECT_NAME}}-core = { path = "../core" }
-webtau = "0.2"
+webtau = "0.3.0"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 tauri = { version = "2", features = [] }

package/templates/base/src-tauri/wasm/Cargo.toml

@@ -11,7 +11,7 @@ wasm-bindgen = "0.2"
 serde = { version = "1", features = ["derive"] }
 serde-wasm-bindgen = "0.6"
 getrandom = { version = "0.2", features = ["js"] }
-webtau = "0.2"
+webtau = "0.3.0"
 {{PROJECT_NAME}}-core = { path = "../core" }
 {{PROJECT_NAME}}-commands = { path = "../commands" }
 

package/templates/pixi/package.json

@@ -12,12 +12,12 @@
   },
   "dependencies": {
     "pixi.js": "^8.0.0",
-    "webtau": "^0.2.0"
+    "webtau": "^0.3.0"
   },
   "devDependencies": {
     "typescript": "^5.8.0",
     "vite": "^6.0.0",
-    "webtau-vite": "^0.2.0",
+    "webtau-vite": "^0.3.0",
     "@tauri-apps/cli": "^2.0.0",
     "@tauri-apps/api": "^2.0.0"
   }

package/templates/three/package.json

@@ -12,13 +12,13 @@
   },
   "dependencies": {
     "three": "^0.172.0",
-    "webtau": "^0.2.0"
+    "webtau": "^0.3.0"
   },
   "devDependencies": {
     "@types/three": "^0.172.0",
     "typescript": "^5.8.0",
     "vite": "^6.0.0",
-    "webtau-vite": "^0.2.0",
+    "webtau-vite": "^0.3.0",
     "@tauri-apps/cli": "^2.0.0",
     "@tauri-apps/api": "^2.0.0"
   }