create-pixi-vn 2.0.15 → 2.1.1

package/template-nqtr-react-vite-muijoy-ink-tauri/src-tauri/src/steam.rs

@@ -0,0 +1,238 @@
+use std::sync::Mutex;
+use steamworks::{AppId, Client, OverlayToStoreFlag};
+use tauri::State;
+
+pub struct SteamClient {
+    pub client: Mutex<Option<Client>>,
+}
+
+/// Try to initialise Steam. Returns `None` when Steam is not running or the
+/// game is launched outside Steam (e.g. during CI builds).
+///
+/// A background thread is spawned to pump Steam callbacks every 100 ms so
+/// that overlay notifications, stat uploads, and other async operations work.
+pub fn try_init() -> Option<Client> {
+    match Client::init() {
+        Ok(client) => {
+            // Client is Clone + Send + Sync in steamworks 0.13 — safe to move into a thread.
+            let ticker = client.clone();
+            std::thread::spawn(move || loop {
+                ticker.run_callbacks();
+                std::thread::sleep(std::time::Duration::from_millis(100));
+            });
+
+            eprintln!("[Steam] Initialised — App ID {}", client.utils().app_id().0);
+            Some(client)
+        }
+        Err(e) => {
+            eprintln!("[Steam] Not available: {e}");
+            None
+        }
+    }
+}
+
+// ── Commands ──────────────────────────────────────────────────────────────────
+
+/// Returns `true` when Steam was initialised successfully.
+#[tauri::command]
+pub fn steam_is_available(state: State<'_, SteamClient>) -> bool {
+    state.client.lock().map_or(false, |g| g.is_some())
+}
+
+/// Steam display name of the current user (`null` when Steam unavailable).
+#[tauri::command]
+pub fn steam_get_player_name(state: State<'_, SteamClient>) -> Option<String> {
+    state
+        .client
+        .lock()
+        .ok()
+        .and_then(|g| g.as_ref().map(|c| c.friends().name()))
+}
+
+/// Numeric Steam App ID of the running application.
+#[tauri::command]
+pub fn steam_get_app_id(state: State<'_, SteamClient>) -> Option<u32> {
+    state
+        .client
+        .lock()
+        .ok()
+        .and_then(|g| g.as_ref().map(|c| c.utils().app_id().0))
+}
+
+// ── Achievements ──────────────────────────────────────────────────────────────
+
+/// Unlock an achievement and persist it to Steam immediately.
+///
+/// `achievement_id` must match the API Name defined in Steamworks Partner.
+#[tauri::command]
+pub fn steam_unlock_achievement(
+    state: State<'_, SteamClient>,
+    achievement_id: String,
+) -> Result<(), String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    let stats = client.user_stats();
+    stats
+        .achievement(&achievement_id)
+        .set()
+        .map_err(|_| format!("Achievement '{}' not found or stats not ready", achievement_id))?;
+    stats
+        .store_stats()
+        .map_err(|_| "Failed to store stats".to_string())
+}
+
+/// Returns `true` if the current user has already unlocked the achievement.
+///
+/// Stats are fetched automatically when Steam initialises. Allow a few seconds
+/// after launch before calling this for the most reliable result.
+#[tauri::command]
+pub fn steam_is_achievement_unlocked(
+    state: State<'_, SteamClient>,
+    achievement_id: String,
+) -> Result<bool, String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    client
+        .user_stats()
+        .achievement(&achievement_id)
+        .get()
+        .map_err(|_| format!("Achievement '{}' not found or stats not ready", achievement_id))
+}
+
+/// Reset an achievement (useful during development / QA).
+#[tauri::command]
+pub fn steam_clear_achievement(
+    state: State<'_, SteamClient>,
+    achievement_id: String,
+) -> Result<(), String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    let stats = client.user_stats();
+    stats
+        .achievement(&achievement_id)
+        .clear()
+        .map_err(|_| format!("Achievement '{}' not found or stats not ready", achievement_id))?;
+    stats
+        .store_stats()
+        .map_err(|_| "Failed to store stats".to_string())
+}
+
+// ── Stats ─────────────────────────────────────────────────────────────────────
+
+/// Set an integer stat. Call `steam_store_stats` to persist.
+#[tauri::command]
+pub fn steam_set_stat_int(
+    state: State<'_, SteamClient>,
+    name: String,
+    value: i32,
+) -> Result<(), String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    client
+        .user_stats()
+        .set_stat_i32(&name, value)
+        .map_err(|_| format!("Failed to set stat '{}'", name))
+}
+
+/// Read an integer stat.
+#[tauri::command]
+pub fn steam_get_stat_int(
+    state: State<'_, SteamClient>,
+    name: String,
+) -> Result<i32, String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    client
+        .user_stats()
+        .get_stat_i32(&name)
+        .map_err(|_| format!("Failed to get stat '{}'", name))
+}
+
+/// Set a float stat. Call `steam_store_stats` to persist.
+#[tauri::command]
+pub fn steam_set_stat_float(
+    state: State<'_, SteamClient>,
+    name: String,
+    value: f32,
+) -> Result<(), String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    client
+        .user_stats()
+        .set_stat_f32(&name, value)
+        .map_err(|_| format!("Failed to set stat '{}'", name))
+}
+
+/// Read a float stat.
+#[tauri::command]
+pub fn steam_get_stat_float(
+    state: State<'_, SteamClient>,
+    name: String,
+) -> Result<f32, String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    client
+        .user_stats()
+        .get_stat_f32(&name)
+        .map_err(|_| format!("Failed to get stat '{}'", name))
+}
+
+/// Commit all pending stat changes to Steam servers.
+/// Achievement commands already call this automatically.
+#[tauri::command]
+pub fn steam_store_stats(state: State<'_, SteamClient>) -> Result<(), String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    client
+        .user_stats()
+        .store_stats()
+        .map_err(|_| "Failed to store stats".to_string())
+}
+
+// ── DLC ───────────────────────────────────────────────────────────────────────
+
+/// Returns `true` if the user owns and has the specified DLC installed.
+#[tauri::command]
+pub fn steam_is_dlc_installed(state: State<'_, SteamClient>, app_id: u32) -> bool {
+    state.client.lock().map_or(false, |g| {
+        g.as_ref()
+            .map_or(false, |c| c.apps().is_dlc_installed(AppId(app_id)))
+    })
+}
+
+// ── Overlay ───────────────────────────────────────────────────────────────────
+
+/// Open the Steam overlay to a specific dialog.
+///
+/// Valid `dialog` values:
+///   "achievements", "community", "friends", "players",
+///   "settings", "officialgamegroup", "stats"
+#[tauri::command]
+pub fn steam_open_overlay(state: State<'_, SteamClient>, dialog: String) -> bool {
+    let Ok(guard) = state.client.lock() else {
+        return false;
+    };
+    let Some(client) = guard.as_ref() else {
+        return false;
+    };
+    client.friends().activate_game_overlay(&dialog);
+    true
+}
+
+/// Open the Steam store page for this game (or a specific `app_id`).
+#[tauri::command]
+pub fn steam_open_store(state: State<'_, SteamClient>, app_id: Option<u32>) -> bool {
+    let Ok(guard) = state.client.lock() else {
+        return false;
+    };
+    let Some(client) = guard.as_ref() else {
+        return false;
+    };
+    let target = app_id
+        .map(AppId)
+        .unwrap_or_else(|| client.utils().app_id());
+    client
+        .friends()
+        .activate_game_overlay_to_store(target, OverlayToStoreFlag::None);
+    true
+}

package/template-nqtr-react-vite-muijoy-ink-tauri/src-tauri/tauri.conf.json

@@ -5,7 +5,7 @@
   "identifier": "com.my-app-identifier.app",
   "build": {
     "beforeDevCommand": "npm run dev",
-    "devUrl": "http://localhost:1420",
+    "devUrl": "http://localhost:5173",
     "beforeBuildCommand": "npm run build",
     "frontendDist": "../dist"
   },
@@ -13,10 +13,18 @@
     "withGlobalTauri": true,
     "windows": [
       {
-        "fullscreen": true,
         "title": "my-app-project-name",
-        "width": 800,
-        "height": 600
+        "backgroundColor": "#303030",
+        "theme": "Dark",
+        "width": 1280,
+        "height": 720,
+        "minWidth": 640,
+        "minHeight": 360,
+        "center": true,
+        "fullscreen": false,
+        "resizable": true,
+        "dragDropEnabled": false,
+        "zoomHotkeysEnabled": false
       }
     ],
     "security": {
@@ -32,6 +40,11 @@
       "icons/128x128@2x.png",
       "icons/icon.icns",
       "icons/icon.ico"
-    ]
+    ],
+    "windows": {
+      "nsis": {
+        "installerIcon": "icons/icon.ico"
+      }
+    }
   }
 }

package/template-nqtr-react-vite-muijoy-ink-tauri/tsconfig.app.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2023",
+    "experimentalDecorators": true,
+    "useDefineForClassFields": true,
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "allowSyntheticDefaultImports": true,
+    "module": "ESNext",
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "moduleDetection": "force",
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}

package/template-nqtr-react-vite-muijoy-ink-tauri/tsconfig.json

@@ -1,27 +1,12 @@
 {
   "compilerOptions": {
-    "target": "ESNext",
-    "experimentalDecorators": true,
-    "useDefineForClassFields": true,
-    "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "allowSyntheticDefaultImports": true,
-    "module": "ESNext",
-    "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-    "jsx": "react-jsx",
-
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true
+    "paths": {
+      "@/*": ["./src/*"]
+    }
   },
-  "include": ["src"],
-  "references": [{ "path": "./tsconfig.node.json" }]
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
 }

package/template-nqtr-react-vite-muijoy-ink-tauri/tsconfig.node.json

@@ -1,11 +1,28 @@
 {
   "compilerOptions": {
-    "composite": true,
-    "skipLibCheck": true,
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
     "module": "ESNext",
+    "types": ["node"],
+    "skipLibCheck": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+
+    /* Bundler mode */
     "moduleResolution": "bundler",
     "allowSyntheticDefaultImports": true,
-    "strict": true
+    "allowImportingTsExtensions": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
   },
   "include": ["vite.config.ts"]
 }

package/template-nqtr-react-vite-muijoy-ink-tauri/vite.config.ts

@@ -1,25 +1,72 @@
+import { AssetPack } from "@assetpack/core";
+import { vitePluginNqtr } from "@drincs/nqtr/vite";
 import { vitePluginInk } from "@drincs/pixi-vn-ink/vite";
+import type { AssetsManifest } from "@drincs/pixi-vn/pixi.js";
 import { vitePluginPixivn } from "@drincs/pixi-vn/vite";
 import tailwindcss from "@tailwindcss/vite";
+import { devtools } from "@tanstack/devtools-vite";
+import { tanstackRouter } from "@tanstack/router-plugin/vite";
 import react from "@vitejs/plugin-react";
-import { defineConfig } from "vite";
-import checker from "vite-plugin-checker";
+import { defineConfig, type Plugin, type ResolvedConfig } from "vite";
+import { checker } from "vite-plugin-checker";
 import { VitePWA } from "vite-plugin-pwa";
+import assetPackConfig from "./.assetpack.ts";
+
+/**
+ * List of external hostnames whose responses should be cached by the service worker.
+ * Add any CDN or remote asset host here to enable offline caching for it.
+ * Examples:
+ *   "cdn.jsdelivr.net"
+ *   "your.cdn.domain.com"
+ */
+const CACHED_EXTERNAL_HOSTNAMES: string[] = ["raw.githubusercontent.com"];
 
 const host = process.env.TAURI_DEV_HOST;
 
 // https://vite.dev/config/
-export default defineConfig({
+export default defineConfig(({ mode }) => ({
     plugins: [
-        react(),
+        assetpackPlugin(),
         checker({
-            typescript: true,
+            typescript: {
+                tsconfigPath: "tsconfig.app.json",
+            },
         }),
+        mode !== "production" && devtools(),
+        tanstackRouter({ target: "react", autoCodeSplitting: true }),
+        react(),
         tailwindcss(),
+        vitePluginPixivn({
+            content: "./src/content/index.ts",
+            characters: "./src/content/characters.ts",
+            labels: "./src/content/labels/*.label.ts",
+            typeFilePath: "./src/pixi-vn.keys.gen.ts",
+            assetsManifest: async (ssrLoadModule) => {
+                const mod = (await ssrLoadModule("/src/assets/index.ts")) as {
+                    manifest: AssetsManifest;
+                };
+                if (!mod.manifest)
+                    throw new Error("Assets manifest not found in /src/assets/index.ts");
+                return mod.manifest;
+            },
+        }),
+        vitePluginNqtr({
+            activities: "./src/content/activities.tsx",
+            commitments: "./src/content/routine.tsx",
+            rooms: "./src/content/rooms.tsx",
+            locations: "./src/content/locations.tsx",
+            maps: "./src/content/maps.tsx",
+            quests: "./src/content/quests/*.quest.tsx",
+            typeFilePath: "./src/nqtr.keys.gen.ts",
+        }),
+        vitePluginInk({
+            inkGlob: "./ink/**/*.ink",
+            inkJsonOutputPattern: "./public/ink-json/[path][name].gen.json",
+            inkJsonManifestPath: "./src/assets/ink-manifest.gen.json",
+        }),
         VitePWA({
-            // you can generate the icons using: https://favicon.io/favicon-converter/
-            // and the maskable icon using: https://progressier.com/maskable-icons-editor
-            includeAssets: ["favicon.ico", "apple-touch-icon.png", "mask-icon.svg"],
+            // generate icons with: npm run icon
+            includeAssets: ["favicon.ico", "apple-touch-icon-180x180.png"],
             manifest: {
                 name: "my-app-project-name",
                 short_name: "my-app-package-name",
@@ -27,7 +74,7 @@ export default defineConfig({
                 theme_color: "#ffffff",
                 start_url: "/",
                 display: "fullscreen",
-                orientation: "portrait",
+                orientation: "landscape",
                 icons: [
                     {
                         src: "pwa-192x192.png",
@@ -39,13 +86,37 @@ export default defineConfig({
                         sizes: "512x512",
                         type: "image/png",
                     },
+                    {
+                        src: "maskable-icon-512x512.png",
+                        sizes: "512x512",
+                        type: "image/png",
+                        purpose: "maskable",
+                    },
+                ],
+            },
+            workbox: {
+                runtimeCaching: [
+                    {
+                        urlPattern: ({ url }) => CACHED_EXTERNAL_HOSTNAMES.includes(url.hostname),
+                        handler: "CacheFirst",
+                        options: {
+                            cacheName: "external-assets-v1",
+                            cacheableResponse: {
+                                statuses: [0, 200],
+                            },
+                            expiration: {
+                                maxAgeSeconds: 7 * 24 * 60 * 60,
+                            },
+                        },
+                    },
                 ],
             },
         }),
-        vitePluginPixivn(),
-        vitePluginInk(),
     ],
-    assetsInclude: ["**/ink/*.ink"],
+    resolve: {
+        tsconfigPaths: true,
+        preserveSymlinks: true,
+    },
     define: {
         __APP_VERSION__: JSON.stringify(process.env.npm_package_version),
         __APP_NAME__: JSON.stringify(process.env.npm_package_name),
@@ -54,11 +125,16 @@ export default defineConfig({
         rollupOptions: {
             output: {
                 manualChunks(id) {
-                    if (id.includes("react-markdown") || id.includes("rehype-raw") || id.includes("remark-gfm"))
-                        return "react-markdown";
-                    if (id.includes("@pixi/sound")) return "sound";
+                    if (
+                        id.includes("react-markdown") ||
+                        id.includes("rehype-raw") ||
+                        id.includes("remark-gfm")
+                    )
+                        return "markdown";
+                    if (id.includes("tone")) return "tone";
                     if (id.includes("@drincs/pixi-vn-spine")) return "spine";
                     if (id.includes("pixi.js")) return "pixi.js";
+                    if (id.includes("motion")) return "motion";
                     if (id.includes("@drincs/pixi-vn")) return "pixi-vn";
                 },
             },
@@ -71,7 +147,7 @@ export default defineConfig({
     clearScreen: false,
     // 2. tauri expects a fixed port, fail if that port is not available
     server: {
-        port: 1420,
+        port: 5173,
         strictPort: true,
         host: host || false,
         hmr: host
@@ -86,4 +162,35 @@ export default defineConfig({
             ignored: ["**/src-tauri/**"],
         },
     },
-});
+}));
+
+function assetpackPlugin(): Plugin {
+    let mode: ResolvedConfig["command"];
+    let ap: AssetPack | undefined;
+
+    return {
+        name: "vite-plugin-assetpack",
+        configResolved(resolvedConfig) {
+            mode = resolvedConfig.command;
+            if (!resolvedConfig.publicDir) return;
+            if (assetPackConfig.output) return;
+            const publicDir = resolvedConfig.publicDir.replace(process.cwd(), "");
+            assetPackConfig.output = `.${publicDir}/assets/`;
+        },
+        buildStart: async () => {
+            if (mode === "serve") {
+                if (ap) return;
+                ap = new AssetPack(assetPackConfig);
+                void ap.watch();
+            } else {
+                await new AssetPack(assetPackConfig).run();
+            }
+        },
+        buildEnd: async () => {
+            if (ap) {
+                await ap.stop();
+                ap = undefined;
+            }
+        },
+    };
+}

package/template-nqtr-react-vite-muijoy-tauri/.assetpack.ts

@@ -0,0 +1,27 @@
+import type { AssetPackConfig } from "@assetpack/core";
+import { pixiPipes } from "@assetpack/core/pixi";
+
+// TAURI_ENV_TARGET_TRIPLE is set by `tauri build` before running beforeBuildCommand
+const isTauri = !!process.env.TAURI_ENV_TARGET_TRIPLE;
+
+const config: AssetPackConfig = {
+    entry: "./src/assets",
+    output: "./public/assets",
+    ignore: ["**/*.ts", "**/*.js", "**/*.gen.*"],
+    pipes: [
+        ...pixiPipes({
+            manifest: {
+                output: "src/assets/manifest.gen.json",
+                createShortcuts: true,
+            },
+            // For Tauri: skip @0.5x mipmaps (unused on desktop, WebView handles DPR)
+            resolutions: isTauri ? { default: 1 } : undefined,
+            // For Tauri: raise WebP quality — files are local so bandwidth is not a concern
+            compression: isTauri
+                ? { png: true, jpg: true, webp: { quality: 88, alphaQuality: 88 } }
+                : undefined,
+        }),
+    ],
+};
+
+export default config;

package/template-nqtr-react-vite-muijoy-tauri/.vscode/extensions.json

@@ -1,12 +1,11 @@
-{
-    "recommendations": [
-        "ms-vscode.vscode-typescript-next",
-        "dbaeumer.vscode-eslint",
-        "anseki.vscode-color",
-        "pflannery.vscode-versionlens",
-        "esbenp.prettier-vscode",
-        "tauri-apps.tauri-vscode",
-        "rust-lang.rust-analyzer",
-        "vadimcn.vscode-lldb"
-    ]
-}
+{
+  "recommendations": [
+    "ms-vscode.vscode-typescript-next",
+    "anseki.vscode-color",
+    "pflannery.vscode-versionlens",
+    "biomejs.biome",
+    "tauri-apps.tauri-vscode",
+    "rust-lang.rust-analyzer",
+    "vadimcn.vscode-lldb"
+  ]
+}