Merge Main to Release: v0.1.1 (#3)

* change auto build to release branch

* Add checks to create config if it doesnt exist

* Added sorting by last played

* fix extra console opening on windows

* move instance reading to js file

* unify sites to use Topbar

* make instance loading not guess when its finished

* Add instance id generating + saving + reading

* enhance instance page

* Java Version Controll, mostly

* Minor touch-ups

* Java MC version selection

* Add Notification System

* Polish Notification System

* Some Fixes for building

* Increment version to 0.1.1

Author: DerCommander323

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "rust-analyzer.linkedProjects": [
+        "./src-tauri/Cargo.toml"
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,13 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Tauri Dev",
+            "type": "shell",
+            "command": "cargo tauri dev",
+            "presentation": {"echo": true, "reveal": "always", "focus": false, "panel": "shared", "showReuseMessage": false, "clear": true},
+        }
+    ]
+}

src-tauri/Cargo.lock

@@ -17,8 +17,9 @@ tauri-build = { version = "1.4.0", features = [] }
 [dependencies]
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
-tauri = { version = "1.4.0", features = ["dialog-all", "fs-all", "path-all", "protocol-asset"] }
+tauri = { version = "1.4.0", features = [ "fs-create-dir", "fs-read-file", "fs-exists", "fs-write-file", "fs-read-dir", "shell-open", "dialog-all", "path-all", "protocol-asset"] }
 configparser = "3.0.2"
+fastrand = "2.0.0"
 
 [features]
 # by default Tauri runs in production mode

src-tauri/Cargo.toml

@@ -1,5 +1,6 @@
 use std::fs::DirEntry;
 use std::fs::read_to_string;
+use std::fs::write;
 
 use configparser::ini::Ini;
 use serde_json::Value;
@@ -10,14 +11,15 @@ struct InstanceData {
   name: String,
   icon: String,
   path: String,
+  id: u32,
   last_played_string: String,
   last_played_epoch: u64
 }
 
 
 pub fn handle_instance_cf(dir: DirEntry, app_handle: AppHandle) {
-    let data = read_to_string(dir.path().join("minecraftinstance.json")).unwrap();
-    let json: Value = serde_json::from_str(&data).unwrap();
+    let file = read_to_string(dir.path().join("minecraftinstance.json")).unwrap_or(String::from(""));
+    let json: Value = serde_json::from_str(&file).unwrap();
     let name = json["name"].as_str().unwrap_or("Name not found!").to_string();
     let mut icon = json["installedModpack"]["thumbnailUrl"].as_str().unwrap_or("").to_string();
     if icon.is_empty() {
@@ -26,27 +28,53 @@ pub fn handle_instance_cf(dir: DirEntry, app_handle: AppHandle) {
     let path = dir.path().to_str().unwrap_or("invalid_path").to_string();
     let last_played_string = json["lastPlayed"].as_str().unwrap_or("invalid").to_string();
 
-    println!("Curseforge: {}, Last Played: {}", &name, &last_played_string);
-    emit_instance_create(InstanceData { name, icon, path, last_played_string, last_played_epoch: 0 }.into(), app_handle)
+    let id = get_or_create_instance_id(dir);
+
+    println!("Curseforge: {}, instanceID: {}", &name, &id);
+    emit_instance_create(InstanceData { name, icon, path, id, last_played_string, last_played_epoch: 0 }.into(), app_handle)
 }
 
 pub fn handle_instance_mmc(dir: DirEntry, app_handle: AppHandle) {
-    let mut data = read_to_string(dir.path().join("instance.cfg")).unwrap();
-    data = data.replace("[General]", "");
+    let mut file = read_to_string(dir.path().join("instance.cfg")).unwrap_or(String::from(""));
+    file = file.replace("[General]", "");
 
     let mut config = Ini::new();
-    config.read(data).unwrap();
+    config.read(file).unwrap();
 
     let name = config.get("default","name").unwrap_or(String::from("Name not found!"));
     let icon = config.get("default","iconKey").unwrap_or(String::from("default"));
-    let path = dir.path().join(".minecraft").to_str().unwrap_or("invalid_path").to_string();
+    let path = dir.path().to_str().unwrap_or("invalid_path").to_string();
     let last_played_epoch: u64 = config.get("default","lastLaunchTime").unwrap_or(String::from("1")).parse::<u64>().unwrap_or(0);
-    
 
-    println!("MultiMC: {}, Last Played: {}", &name, &last_played_epoch);
-    emit_instance_create(InstanceData { name, icon, path, last_played_string: "".to_string(), last_played_epoch }.into(), app_handle)
+    let id = get_or_create_instance_id(dir);
+
+    println!("MultiMC: {}, instanceID: {}", &name, &id);
+    emit_instance_create(InstanceData { name, icon, path, id, last_played_string: "".to_string(), last_played_epoch }.into(), app_handle)
+}
+
+fn get_or_create_instance_id(dir: DirEntry) -> u32 {
+    let file = read_to_string(dir.path().join("yamcl-data.json")).unwrap_or(String::from(""));
+    let rand = fastrand::u32(..);
+
+    if file.is_empty() || !serde_json::from_str::<Value>(&file).unwrap().is_object() {
+        let mut json = serde_json::json!({});
+        json["instanceID"] = Value::from(rand);
+        write(dir.path().join("yamcl-data.json"), serde_json::to_string(&json).unwrap()).unwrap();
+        rand    
+    } else {
+        let mut json: Value = serde_json::from_str(&file).unwrap();
+        let id: u32 = json["instanceID"].as_u64().unwrap_or(0).try_into().unwrap_or(0);
+        if id==0 {
+            json["instanceID"] = Value::from(rand);
+            write(dir.path().join("yamcl-data.json"), serde_json::to_string(&json).unwrap()).unwrap();
+            rand
+        } else {
+            id
+        }
+    }
 }
 
+
 fn emit_instance_create(data: InstanceData, app_handle: AppHandle) {
     app_handle.emit_all("instance_create", data).unwrap()
 }

src-tauri/src/instances.rs

@@ -1,13 +1,22 @@
+//Prevents console window on windows
+#![cfg_attr(
+    all(not(debug_assertions), target_os = "windows"),
+    windows_subsystem = "windows"
+)]
+
 use std::{fs::{self}, path::Path};
 
 use tauri::{AppHandle, Manager};
 mod instances;
+mod minecraft;
 
 fn main() {
     tauri::Builder::default()
         .invoke_handler(tauri::generate_handler![
             get_instances,
-            unlock_icons
+            unlock_icons,
+            minecraft::launch_instance,
+            minecraft::get_java_version
         ])
         .run(tauri::generate_context!())
         .expect("failed to run app");
@@ -22,6 +31,7 @@ fn unlock_icons(path: String, app_handle: AppHandle) {
 #[tauri::command(async)]
 fn get_instances(path: String, app_handle: AppHandle) {
     let paths = fs::read_dir(path).unwrap();
+    let mut instance_count: u16 = 0;
 
     for path in paths {
         if path.as_ref().unwrap().file_type().unwrap().is_dir() {
@@ -31,11 +41,12 @@ fn get_instances(path: String, app_handle: AppHandle) {
 
             for file in instance_contents {
                 match file.unwrap().file_name().into_string().unwrap().as_ref() {
-                    "minecraftinstance.json" => {instances::handle_instance_cf(instance_folder, app_handle.clone()); break;},
-                    "instance.cfg" => {instances::handle_instance_mmc(instance_folder, app_handle.clone()); break;},
+                    "minecraftinstance.json" => {instances::handle_instance_cf(instance_folder, app_handle.clone()); instance_count += 1; break;},
+                    "instance.cfg" => {instances::handle_instance_mmc(instance_folder, app_handle.clone()); instance_count += 1; break;},
                     _ => continue
                 }   
             }
         }
     }
+    app_handle.emit_all("instance_finish", instance_count).unwrap();
 }