create-pixi-vn 2.0.12 → 2.0.13

package/template-react-vite-muijoy-tauri/src-tauri/build.rs

@@ -0,0 +1,46 @@
+use std::{env, fs, path::PathBuf};
+
+fn main() {
+    if env::var("CARGO_FEATURE_STEAM").is_ok() {
+        copy_steam_lib();
+    }
+    tauri_build::build()
+}
+
+// Copies the Steamworks redistributable library from steamworks-sys's OUT_DIR
+// into src-tauri/ so that Tauri's bundler can pick it up as a resource.
+fn copy_steam_lib() {
+    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+
+    let lib_name = match env::var("CARGO_CFG_TARGET_OS").as_deref() {
+        Ok("windows") => "steam_api64.dll",
+        Ok("macos") => "libsteam_api.dylib",
+        _ => "libsteam_api.so",
+    };
+
+    // OUT_DIR layout: .../target/[profile]/build/[pkg-hash]/out
+    // nth(2) walks up to .../target/[profile]/build/
+    let build_dir = out_dir
+        .ancestors()
+        .nth(2)
+        .expect("unexpected OUT_DIR layout");
+
+    if let Ok(entries) = fs::read_dir(build_dir) {
+        for entry in entries.flatten() {
+            let candidate = entry.path().join("out").join(lib_name);
+            if candidate.exists() {
+                let dest = manifest_dir.join(lib_name);
+                fs::copy(&candidate, &dest)
+                    .unwrap_or_else(|e| panic!("failed to copy {lib_name}: {e}"));
+                println!("cargo:warning=Steam: copied {lib_name} → src-tauri/");
+                return;
+            }
+        }
+    }
+
+    panic!(
+        "Steam: could not find `{lib_name}` in build artifacts. \
+         Ensure `--features steam` is active and the crate compiled successfully."
+    );
+}

package/template-react-vite-muijoy-tauri/src-tauri/capabilities/default.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "default",
+  "description": "Capability for the main window",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "core:window:allow-close",
+    "core:window:allow-is-fullscreen",
+    "core:window:allow-set-fullscreen",
+    "core:window:allow-minimize",
+    "core:window:allow-maximize",
+    "core:window:allow-unminimize",
+    "core:window:allow-set-title",
+    "opener:default",
+    "process:default",
+    "window-state:allow-filename",
+    "window-state:allow-restore-state",
+    "window-state:allow-save-window-state"
+  ]
+}

package/template-react-vite-muijoy-tauri/src-tauri/src/lib.rs

@@ -0,0 +1,64 @@
+use tauri::Manager;
+#[cfg(not(mobile))]
+use tauri_plugin_window_state::{AppHandleExt, StateFlags};
+
+// Steam is only compiled on desktop targets when the "steam" feature is on.
+#[cfg(all(feature = "steam", not(target_os = "ios"), not(target_os = "android")))]
+mod steam;
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    #[allow(unused_mut)]
+    let mut builder = tauri::Builder::default()
+        .plugin(tauri_plugin_process::init())
+        .plugin(tauri_plugin_opener::init())
+        .on_page_load(on_page_load);
+
+    #[cfg(not(mobile))]
+    let mut builder = builder
+        .plugin(tauri_plugin_window_state::Builder::new().build())
+        .on_window_event(on_window_event);
+
+    // ── Steam ─────────────────────────────────────────────────────────────────
+    // Enabled only when `--features steam` is passed (or `default = ["steam"]`
+    // is set in Cargo.toml). Steam is not supported on iOS / Android.
+    #[cfg(all(feature = "steam", not(target_os = "ios"), not(target_os = "android")))]
+    {
+        builder = builder
+            .manage(steam::SteamClient {
+                client: std::sync::Mutex::new(steam::try_init()),
+            })
+            .invoke_handler(tauri::generate_handler![
+                steam::steam_is_available,
+                steam::steam_get_player_name,
+                steam::steam_get_app_id,
+                steam::steam_unlock_achievement,
+                steam::steam_is_achievement_unlocked,
+                steam::steam_clear_achievement,
+                steam::steam_set_stat_int,
+                steam::steam_get_stat_int,
+                steam::steam_set_stat_float,
+                steam::steam_get_stat_float,
+                steam::steam_store_stats,
+                steam::steam_is_dlc_installed,
+                steam::steam_open_overlay,
+                steam::steam_open_store,
+            ]);
+    }
+
+    builder
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
+
+fn on_page_load(window: &tauri::Webview, _: &tauri::webview::PageLoadPayload<'_>) {
+    #[cfg(not(debug_assertions))]
+    let _ = window.eval("document.addEventListener('contextmenu', e => e.preventDefault())");
+}
+
+#[cfg(not(mobile))]
+fn on_window_event(window: &tauri::Window, event: &tauri::WindowEvent) {
+    if let tauri::WindowEvent::CloseRequested { .. } = event {
+        let _ = window.app_handle().save_window_state(StateFlags::all());
+    }
+}

package/template-react-vite-muijoy-tauri/src-tauri/src/main.rs

@@ -0,0 +1,6 @@
+// Prevents additional console window on Windows in release, DO NOT REMOVE!!
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+    my_app_lib::run()
+}

package/template-react-vite-muijoy-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-react-vite-muijoy-tauri/src-tauri/tauri.conf.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "productName": "my-app-package-name",
+  "version": "0.1.0",
+  "identifier": "com.my-app-identifier.app",
+  "build": {
+    "beforeDevCommand": "npm run dev",
+    "devUrl": "http://localhost:5173",
+    "beforeBuildCommand": "npm run build",
+    "frontendDist": "../dist"
+  },
+  "app": {
+    "withGlobalTauri": true,
+    "windows": [
+      {
+        "title": "my-app-project-name",
+        "backgroundColor": "#303030",
+        "theme": "Dark",
+        "width": 1280,
+        "height": 720,
+        "minWidth": 640,
+        "minHeight": 360,
+        "center": true,
+        "fullscreen": false,
+        "resizable": true,
+        "dragDropEnabled": false,
+        "zoomHotkeysEnabled": false
+      }
+    ],
+    "security": {
+      "csp": null
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": "all",
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
+    "windows": {
+      "nsis": {
+        "installerIcon": "icons/icon.ico"
+      }
+    }
+  }
+}

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

@@ -18,6 +18,8 @@ import assetPackConfig from "./.assetpack.ts";
  */
 const CACHED_EXTERNAL_HOSTNAMES: string[] = ["raw.githubusercontent.com"];
 
+const host = process.env.TAURI_DEV_HOST;
+
 // https://vite.dev/config/
 export default defineConfig(({ mode }) => ({
     plugins: [
@@ -112,6 +114,28 @@ export default defineConfig(({ mode }) => ({
             },
         },
     },
+
+    // Vite options tailored for Tauri development and only applied in `tauri dev` or `tauri build`
+    //
+    // 1. prevent vite from obscuring rust errors
+    clearScreen: false,
+    // 2. tauri expects a fixed port, fail if that port is not available
+    server: {
+        port: 5173,
+        strictPort: true,
+        host: host || false,
+        hmr: host
+            ? {
+                  protocol: "ws",
+                  host,
+                  port: 1421,
+              }
+            : undefined,
+        watch: {
+            // 3. tell vite to ignore watching `src-tauri`
+            ignored: ["**/src-tauri/**"],
+        },
+    },
 }));
 
 function assetpackPlugin(): Plugin {