Direct World Joining (#3457)

* Begin work on worlds backend

* Finish implementing get_profile_worlds and get_server_status (except pinning)

* Create TS types and manually copy unparsed chat components

* Clippy fix

* Update types.d.ts

* Initial worlds UI work

* Fix api::get_profile_worlds to take in a relative path

* sanitize & security update

* Fix sanitizePotentialFileUrl

* Fix sanitizePotentialFileUrl (for real)

* Fix empty motd causing error

* Finally actually fix world icons

* Fix world icon not being visible on non-Windows

* Use the correct generics to take in AppHandle

* Implement start_join_singleplayer_world and start_join_server for modern versions

* Don't error if server has no cached icon

* Migrate to own server pinging

* Ignore missing server hidden field and missing saves dir

* Update world list frontend

* More frontend work

* Server status player sample can be absent

* Fix refresh state

* Add get_profile_protocol_version

* Add protocol_version column to database

* SQL INTEGER is i64 in sqlx

* sqlx prepare

* Cache protocol version in database

* Continue worlds UI work

* Fix motds being bold

* Remove legacy pinging and add a 30-second timeout

* Remove pinned for now and match world (and server) parsing closer to spec

* Move type ServerStatus to worlds.ts

* Implement add_server_to_profile

* Fix pack_status being ignored when joining from launcher

* Make World path field be relative

* Implement rename_world and reset_world_icon

* Clippy fix

* Fix rename_world

* UI enhancements

* Implement backup_world, which returns the backup size in bytes

* Clippy fix

* Return index when adding servers to profile

* Fix backup

* Implement delete_world

* Implement edit_server_in_profile and remove_server_from_profile

* Clippy fix

* Log server joins

* Add edit and delete support

* Fix ts errors

* Fix minecraft font

* Switch font out for non-monospaced.

* Fix font proper

* Some more world cleanup, handle play state, check quickplay compatibility

* Clear the cached protocol version when a profile's game version is changed

* Fix tint colors in navbar

* Fix server protocol version pinging

* UI fixes

* Fix protocol version handler

* Fix MOTD parsing

* Add worlds_updated profile event

* fix pkg

* Functional home screen with worlds

* lint

* Fix incorrect folder creation

* Make items clickable

* Add locked field to SingleplayerWorld indicating whether the world is locked by the game

* Implement locking frontend

* Fix locking condition

* Split worlds_updated profile event into servers_updated and world_updated

* Fix compile error

* Use port from resolve SRV record

* Fix serialization of ProfilePayload and ProfilePayloadType

* Individual singleplayer world refreshing

* Log when worlds are perceived to be updated

* Push logging + total refresh lock

* Unlisten fixes

* Highlight current world when clicked

* Launcher logs refactor (#3444)

* Switch live log to use STDOUT

* fix clippy, legacy logs support

* Fix lint

* Handle non-XML log messages in XML logging, and don't escape log messages into XML

---------

Co-authored-by: Josiah Glosson <soujournme@gmail.com>

* Update incompatibility text

* Home page fixes, and unlock after close

* Remove logging

* Add join log database migration

* Switch server join timing to being in the database instead of in a separate log file

* Create optimized get_recent_worlds function that takes in a limit

* Update dependencies and fix Cargo.lock

* temp disable overflow menus

* revert home page changes

* Enable overflow menus again

* Remove list

* Revert

* Push dev tools

* Remove default filter

* Disable debug renderer

* Fix random app errors

* Refactor

* Fix missing computed import

* Fix light mode issues

* Fix TS errors

* Lint

* Fix bad link in change modpack version modal

* fix lint

* fix intl

---------

Co-authored-by: Josiah Glosson <soujournme@gmail.com>
Co-authored-by: Jai A <jaiagr+gpg@pm.me>
Co-authored-by: Jai Agrawal <18202329+Geometrically@users.noreply.github.com>

packages/app-lib/src/launcher/args.rs

@@ -1,5 +1,6 @@
 //! Minecraft CLI argument logic
 use crate::launcher::parse_rules;
+use crate::profile::QuickPlayType;
 use crate::state::Credentials;
 use crate::{
     state::{MemorySettings, WindowSize},
@@ -31,7 +32,12 @@ pub fn get_class_paths(
         .iter()
         .filter_map(|library| {
             if let Some(rules) = &library.rules {
-                if !parse_rules(rules, java_arch, minecraft_updated) {
+                if !parse_rules(
+                    rules,
+                    java_arch,
+                    &QuickPlayType::None,
+                    minecraft_updated,
+                ) {
                     return None;
                 }
             }
@@ -111,6 +117,7 @@ pub fn get_jvm_arguments(
     memory: MemorySettings,
     custom_args: Vec<String>,
     java_arch: &str,
+    quick_play_type: &QuickPlayType,
     log_config: Option<&LoggingConfiguration>,
 ) -> crate::Result<Vec<String>> {
     let mut parsed_arguments = Vec::new();
@@ -130,6 +137,7 @@ pub fn get_jvm_arguments(
                 )
             },
             java_arch,
+            quick_play_type,
         )?;
     } else {
         parsed_arguments.push(format!(
@@ -214,6 +222,7 @@ pub fn get_minecraft_arguments(
     version_type: &VersionType,
     resolution: WindowSize,
     java_arch: &str,
+    quick_play_type: &QuickPlayType,
 ) -> crate::Result<Vec<String>> {
     if let Some(arguments) = arguments {
         let mut parsed_arguments = Vec::new();
@@ -233,9 +242,11 @@ pub fn get_minecraft_arguments(
                     assets_directory,
                     version_type,
                     resolution,
+                    quick_play_type,
                 )
             },
             java_arch,
+            quick_play_type,
         )?;
 
         Ok(parsed_arguments)
@@ -253,6 +264,7 @@ pub fn get_minecraft_arguments(
                 assets_directory,
                 version_type,
                 resolution,
+                quick_play_type,
             )?);
         }
         Ok(parsed_arguments)
@@ -273,6 +285,7 @@ fn parse_minecraft_argument(
     assets_directory: &Path,
     version_type: &VersionType,
     resolution: WindowSize,
+    quick_play_type: &QuickPlayType,
 ) -> crate::Result<String> {
     Ok(argument
         .replace("${accessToken}", access_token)
@@ -326,7 +339,21 @@ fn parse_minecraft_argument(
         )
         .replace("${version_type}", version_type.as_str())
         .replace("${resolution_width}", &resolution.0.to_string())
-        .replace("${resolution_height}", &resolution.1.to_string()))
+        .replace("${resolution_height}", &resolution.1.to_string())
+        .replace(
+            "${quickPlaySingleplayer}",
+            match quick_play_type {
+                QuickPlayType::Singleplayer(world) => world,
+                _ => "",
+            },
+        )
+        .replace(
+            "${quickPlayMultiplayer}",
+            match quick_play_type {
+                QuickPlayType::Server(address) => address,
+                _ => "",
+            },
+        ))
 }
 
 fn parse_arguments<F>(
@@ -334,6 +361,7 @@ fn parse_arguments<F>(
     parsed_arguments: &mut Vec<String>,
     parse_function: F,
     java_arch: &str,
+    quick_play_type: &QuickPlayType,
 ) -> crate::Result<()>
 where
     F: Fn(&str) -> crate::Result<String>,
@@ -348,7 +376,7 @@ where
                 }
             }
             Argument::Ruled { rules, value } => {
-                if parse_rules(rules, java_arch, true) {
+                if parse_rules(rules, java_arch, quick_play_type, true) {
                     match value {
                         ArgumentValue::Single(arg) => {
                             parsed_arguments.push(parse_function(

packages/app-lib/src/launcher/download.rs

@@ -1,6 +1,7 @@
 //! Downloader for Minecraft data
 
 use crate::launcher::parse_rules;
+use crate::profile::QuickPlayType;
 use crate::{
     event::{
         emit::{emit_loading, loading_try_for_each_concurrent},
@@ -295,7 +296,7 @@ pub async fn download_libraries(
         stream::iter(libraries.iter())
             .map(Ok::<&Library, crate::Error>), None, loading_bar,loading_amount,num_files, None,|library| async move {
                 if let Some(rules) = &library.rules {
-                    if !parse_rules(rules, java_arch, minecraft_updated) {
+                    if !parse_rules(rules, java_arch, &QuickPlayType::None, minecraft_updated) {
                         tracing::trace!("Skipped library {}", &library.name);
                         return Ok(());
                     }

packages/app-lib/src/launcher/mod.rs

@@ -4,6 +4,7 @@ use crate::event::emit::{emit_loading, init_or_edit_loading};
 use crate::event::{LoadingBarId, LoadingBarType};
 use crate::launcher::download::download_log_config;
 use crate::launcher::io::IOError;
+use crate::profile::QuickPlayType;
 use crate::state::{
     Credentials, JavaVersion, ProcessMetadata, ProfileInstallStage,
 };
@@ -13,8 +14,10 @@ use chrono::Utc;
 use daedalus as d;
 use daedalus::minecraft::{LoggingSide, RuleAction, VersionInfo};
 use daedalus::modded::LoaderVersion;
+use serde::Deserialize;
 use st::Profile;
 use std::collections::HashMap;
+use std::path::PathBuf;
 use tokio::process::Command;
 
 mod args;
@@ -28,11 +31,14 @@ pub mod download;
 pub fn parse_rules(
     rules: &[d::minecraft::Rule],
     java_version: &str,
+    quick_play_type: &QuickPlayType,
     minecraft_updated: bool,
 ) -> bool {
     let mut x = rules
         .iter()
-        .map(|x| parse_rule(x, java_version, minecraft_updated))
+        .map(|x| {
+            parse_rule(x, java_version, quick_play_type, minecraft_updated)
+        })
         .collect::<Vec<Option<bool>>>();
 
     if rules
@@ -53,6 +59,7 @@ pub fn parse_rules(
 pub fn parse_rule(
     rule: &d::minecraft::Rule,
     java_version: &str,
+    quick_play_type: &QuickPlayType,
     minecraft_updated: bool,
 ) -> Option<bool> {
     use d::minecraft::{Rule, RuleAction};
@@ -70,9 +77,14 @@ pub fn parse_rule(
             !features.is_demo_user.unwrap_or(true)
                 || features.has_custom_resolution.unwrap_or(false)
                 || !features.has_quick_plays_support.unwrap_or(true)
-                || !features.is_quick_play_multiplayer.unwrap_or(true)
+                || (features.is_quick_play_singleplayer.unwrap_or(false)
+                    && matches!(
+                        quick_play_type,
+                        QuickPlayType::Singleplayer(_)
+                    ))
+                || (features.is_quick_play_multiplayer.unwrap_or(false)
+                    && matches!(quick_play_type, QuickPlayType::Server(..)))
                 || !features.is_quick_play_realms.unwrap_or(true)
-                || !features.is_quick_play_singleplayer.unwrap_or(true)
         }
         _ => return Some(true),
     };
@@ -305,12 +317,11 @@ pub async fn install_minecraft(
     )
     .await?;
 
+    let client_path = state
+        .directories
+        .version_dir(&version_jar)
+        .join(format!("{version_jar}.jar"));
     if let Some(processors) = &version_info.processors {
-        let client_path = state
-            .directories
-            .version_dir(&version_jar)
-            .join(format!("{version_jar}.jar"));
-
         let libraries_dir = state.directories.libraries_dir();
 
         if let Some(ref mut data) = version_info.data {
@@ -403,8 +414,11 @@ pub async fn install_minecraft(
         }
     }
 
+    let protocol_version = read_protocol_version_from_jar(client_path).await?;
+
     crate::api::profile::edit(&profile.path, |prof| {
         prof.install_stage = ProfileInstallStage::Installed;
+        prof.protocol_version = protocol_version;
 
         async { Ok(()) }
     })
@@ -414,6 +428,34 @@ pub async fn install_minecraft(
     Ok(())
 }
 
+pub async fn read_protocol_version_from_jar(
+    path: PathBuf,
+) -> crate::Result<Option<i32>> {
+    let zip = async_zip::tokio::read::fs::ZipFileReader::new(path).await?;
+    let Some(entry_index) = zip
+        .file()
+        .entries()
+        .iter()
+        .position(|x| matches!(x.filename().as_str(), Ok("version.json")))
+    else {
+        return Ok(None);
+    };
+
+    #[derive(Deserialize, Debug)]
+    struct VersionData {
+        protocol_version: Option<i32>,
+    }
+
+    let mut data = vec![];
+    zip.reader_with_entry(entry_index)
+        .await?
+        .read_to_end_checked(&mut data)
+        .await?;
+    let data: VersionData = serde_json::from_slice(&data)?;
+
+    Ok(data.protocol_version)
+}
+
 #[tracing::instrument(skip_all)]
 #[allow(clippy::too_many_arguments)]
 pub async fn launch_minecraft(
@@ -426,6 +468,7 @@ pub async fn launch_minecraft(
     credentials: &Credentials,
     post_exit_hook: Option<String>,
     profile: &Profile,
+    quick_play_type: &QuickPlayType,
 ) -> crate::Result<ProcessMetadata> {
     if profile.install_stage == ProfileInstallStage::PackInstalling
         || profile.install_stage == ProfileInstallStage::MinecraftInstalling
@@ -581,6 +624,7 @@ pub async fn launch_minecraft(
                 *memory,
                 Vec::from(java_args),
                 &java_version.architecture,
+                quick_play_type,
                 version_info
                     .logging
                     .as_ref()
@@ -603,6 +647,7 @@ pub async fn launch_minecraft(
                 &version.type_,
                 *resolution,
                 &java_version.architecture,
+                quick_play_type,
             )?
             .into_iter()
             .collect::<Vec<_>>(),
@@ -708,6 +753,12 @@ pub async fn launch_minecraft(
     // This also spawns the process and prepares the subsequent processes
     state
         .process_manager
-        .insert_new_process(&profile.path, command, post_exit_hook)
+        .insert_new_process(
+            &profile.path,
+            command,
+            post_exit_hook,
+            state.directories.profile_logs_dir(&profile.path),
+            version_info.logging.is_some(),
+        )
         .await
 }