0.5.3

Cargo.toml

@@ -1,16 +1,22 @@
 [package]
 name = "gta-tools"
-version = "0.5.1"
+version = "0.5.3"
 edition = "2024"
 
 [dependencies]
 catppuccin-egui = { version = "5.5.0", default-features = false, features = [
     "egui31",
 ] }
-chrono = "0.4.40"
+chrono = { version = "0.4.40", default-features = false, features = ["clock"] }
 dirs = "6.0.0"
-eframe = "0.31.1"
-egui_extras = { version = "0.31.1", features = ["image", "svg"] }
+eframe = { version = "0.31.1", default-features = false, features = [
+    "glow",
+    "default_fonts",
+] }
+egui_extras = { version = "0.31.1", default-features = false, features = [
+    "image",
+    "svg",
+] }
 image = { version = "0.25.6", default-features = false, features = ["png"] }
 open = "5.3.2"
 semver = "1.0.26"
@@ -34,6 +40,5 @@ static_vcruntime = "2.0.0"
 winresource = "0.1.20"
 
 [profile.release]
-strip = true
 lto = true
 codegen-units = 1

README.md

@@ -1,4 +1,13 @@
 # GTA Tools
+
 A toolset of convenient things for GTA V Online.
 
-![](https://i.vgy.me/s6bf1g.png)
+![](https://i.vgy.me/maLh8W.png)
+
+## Installing
+
+**Option 1** — <ins>Download</ins>  
+Download the latest release [here](https://codeberg.org/futile/gta-tools/releases/download/latest/gta-tools.exe) and place it somewhere convenient for you, such as Documents. You could then make a shortcut titled "GTA Tools", and pin it to taskbar or Start.
+
+**Option 2** — <ins>Build from source</ins>  
+You will need the Rust toolchain, which can be obtained [here](https://rustup.rs). Follow the instructions of its installer. Once you have Rust installed, clone this repo and navigate to it. At this point, you should probably `git checkout x.x.x`, where `x.x.x` is the latest tag. You can then run `cargo build --release`. Once you do that, you can use the binary located at `.\target\release\gta-tools.exe` in the same way as **Option 1**.

src/features/anti_afk.rs

@@ -1,8 +1,8 @@
 use crate::util::{self, consts::game::WINDOW_TITLE};
 use std::time::{Duration, Instant};
 use windows::Win32::UI::Input::KeyboardAndMouse::{
-    KEYBD_EVENT_FLAGS, MAP_VIRTUAL_KEY_TYPE, MapVirtualKeyW, VIRTUAL_KEY, VK_NUMPAD4, VK_NUMPAD6,
-    keybd_event,
+    INPUT, INPUT_KEYBOARD, KEYBD_EVENT_FLAGS, KEYBDINPUT, KEYEVENTF_KEYUP, MAPVK_VK_TO_VSC,
+    MapVirtualKeyW, SendInput, VIRTUAL_KEY, VK_NUMPAD4, VK_NUMPAD6,
 };
 
 const INTERVAL: Duration = Duration::from_secs(60);
@@ -40,26 +40,23 @@ impl AntiAfk {
 }
 
 fn send(vk_codes: &[VIRTUAL_KEY]) {
-    vk_codes.iter().for_each(|vk_code| unsafe {
-        keybd_event(
-            vk_code.0 as u8,
-            u8::try_from(MapVirtualKeyW(
-                u32::from(vk_code.0),
-                MAP_VIRTUAL_KEY_TYPE(0),
-            ))
-            .unwrap(),
-            KEYBD_EVENT_FLAGS(0),
-            0,
-        );
-        keybd_event(
-            vk_code.0 as u8,
-            u8::try_from(MapVirtualKeyW(
-                u32::from(vk_code.0),
-                MAP_VIRTUAL_KEY_TYPE(0),
-            ))
-            .unwrap(),
-            KEYBD_EVENT_FLAGS(2),
-            0,
-        );
-    });
+    let mut inputs = Vec::new();
+    for &vk_code in vk_codes {
+        let scan_code = unsafe { MapVirtualKeyW(u32::from(vk_code.0), MAPVK_VK_TO_VSC) as u16 };
+        for event in [KEYBD_EVENT_FLAGS(0), KEYEVENTF_KEYUP] {
+            let mut input = INPUT {
+                r#type: INPUT_KEYBOARD,
+                ..Default::default()
+            };
+            input.Anonymous.ki = KEYBDINPUT {
+                wVk: vk_code,
+                wScan: scan_code,
+                dwFlags: event,
+                time: 0,
+                dwExtraInfo: 0,
+            };
+            inputs.push(input);
+        }
+        unsafe { SendInput(&inputs, size_of::<INPUT>() as i32) };
+    }
 }

src/features/force_close.rs

@@ -33,11 +33,9 @@ impl ForceClose {
         }
         if self.counting && self.timer.elapsed() >= INTERVAL {
             self.reset();
-        } else {
-            if force_close_button_clicked && !self.current_frame {
-                activate(sysinfo);
-                self.reset();
-            }
+        } else if force_close_button_clicked && !self.current_frame {
+            activate(sysinfo);
+            self.reset();
         }
         self.finish_current_frame();
     }

src/features/game_networking.rs

@@ -1,15 +1,12 @@
-use crate::util::consts::{
-    colours,
-    game::{EXE_ENHANCED, EXE_LEGACY},
-};
+use crate::util::consts::game::{EXE_ENHANCED, EXE_LEGACY};
 use std::{
     path::Path,
     time::{Duration, Instant},
 };
+use strum::{Display, EnumIter};
 use sysinfo::System;
 use windows::{
     Win32::{
-        Foundation::E_INVALIDARG,
         NetworkManagement::WindowsFirewall::{
             INetFwPolicy2, INetFwRule, NET_FW_ACTION_BLOCK, NET_FW_IP_PROTOCOL_ANY,
             NET_FW_RULE_DIR_IN, NET_FW_RULE_DIR_OUT, NetFwPolicy2, NetFwRule,
@@ -27,7 +24,7 @@ const FILTER_NAME_OUT: &str = "[GTA Tools] Block all outbound traffic for GTA V"
 
 const INTERVAL: Duration = Duration::from_secs(3);
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Display, PartialEq, Eq, EnumIter)]
 pub enum BlockedStatus {
     Blocked,
     Failed,
@@ -36,29 +33,14 @@ pub enum BlockedStatus {
 
 impl From<bool> for BlockedStatus {
     fn from(value: bool) -> Self {
-        match value {
-            true => Self::Blocked,
-            false => Self::Unblocked,
+        if value {
+            Self::Blocked
+        } else {
+            Self::Unblocked
         }
     }
 }
 
-impl From<BlockedStatus> for eframe::egui::Color32 {
-    fn from(value: BlockedStatus) -> Self {
-        match value {
-            BlockedStatus::Blocked => colours::RED,
-            BlockedStatus::Failed => colours::YELLOW,
-            BlockedStatus::Unblocked => colours::GREEN,
-        }
-    }
-}
-
-impl BlockedStatus {
-    pub fn to_color32(&self) -> eframe::egui::Color32 {
-        (*self).into()
-    }
-}
-
 #[derive(Debug)]
 pub struct GameNetworking {
     com_initialized: bool,
@@ -69,14 +51,12 @@ pub struct GameNetworking {
 
 impl Default for GameNetworking {
     fn default() -> Self {
-        let mut gn = Self {
-            blocked_status: BlockedStatus::Unblocked,
+        Self {
+            blocked_status: Self::is_blocked().into(),
             com_initialized: unsafe { CoInitializeEx(None, COINIT_MULTITHREADED) }.is_ok(),
             timer: Instant::now(),
             counting: false,
-        };
-        gn.blocked_status = gn.is_blocked().into();
-        gn
+        }
     }
 }
 
@@ -99,60 +79,37 @@ impl GameNetworking {
         let policy: INetFwPolicy2 =
             unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER).unwrap() };
         let rules = unsafe { policy.Rules().unwrap() };
-        let filter_name_in = BSTR::from(FILTER_NAME_IN);
-        let filter_name_out = BSTR::from(FILTER_NAME_OUT);
-        unsafe {
-            let _ = rules.Remove(&filter_name_in);
-            let _ = rules.Remove(&filter_name_out);
-        }
         let exe_path = BSTR::from(exe_path.to_string_lossy().to_string());
-        unsafe {
-            let inbound_rule: INetFwRule =
-                CoCreateInstance(&NetFwRule, None, CLSCTX_INPROC_SERVER).unwrap();
-            inbound_rule.SetName(&filter_name_in).unwrap();
-            inbound_rule.SetApplicationName(&exe_path).unwrap();
-            inbound_rule.SetDirection(NET_FW_RULE_DIR_IN).unwrap();
-            inbound_rule.SetEnabled(true.into()).unwrap();
-            inbound_rule.SetAction(NET_FW_ACTION_BLOCK).unwrap();
-            inbound_rule.SetProtocol(NET_FW_IP_PROTOCOL_ANY.0).unwrap();
-            rules.Add(&inbound_rule).unwrap();
+        for filter in [
+            (FILTER_NAME_IN, NET_FW_RULE_DIR_IN),
+            (FILTER_NAME_OUT, NET_FW_RULE_DIR_OUT),
+        ] {
+            let _ = unsafe { rules.Remove(&BSTR::from(filter.0)) };
+            unsafe {
+                let rule: INetFwRule =
+                    CoCreateInstance(&NetFwRule, None, CLSCTX_INPROC_SERVER).unwrap();
+                rule.SetName(&BSTR::from(filter.0)).unwrap();
+                rule.SetApplicationName(&exe_path).unwrap();
+                rule.SetDirection(filter.1).unwrap();
+                rule.SetEnabled(true.into()).unwrap();
+                rule.SetAction(NET_FW_ACTION_BLOCK).unwrap();
+                rule.SetProtocol(NET_FW_IP_PROTOCOL_ANY.0).unwrap();
+                rules.Add(&rule).unwrap();
+            }
         }
-        unsafe {
-            let outbound_rule: INetFwRule =
-                CoCreateInstance(&NetFwRule, None, CLSCTX_INPROC_SERVER).unwrap();
-            outbound_rule.SetName(&filter_name_out).unwrap();
-            outbound_rule.SetApplicationName(&exe_path).unwrap();
-            outbound_rule.SetDirection(NET_FW_RULE_DIR_OUT).unwrap();
-            outbound_rule.SetEnabled(true.into()).unwrap();
-            outbound_rule.SetAction(NET_FW_ACTION_BLOCK).unwrap();
-            outbound_rule.SetProtocol(NET_FW_IP_PROTOCOL_ANY.0).unwrap();
-            rules.Add(&outbound_rule).unwrap();
-        }
-        self.blocked_status = self.is_blocked().into();
+        self.blocked_status = Self::is_blocked().into();
     }
 
     pub fn unblock_all(&mut self) {
         let policy: INetFwPolicy2 =
             unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER).unwrap() };
         let rules = unsafe { policy.Rules().unwrap() };
-        unsafe {
-            let result = rules.Remove(&BSTR::from(FILTER_NAME_IN));
-            if let Err(ref why) = result {
-                if why.code() != E_INVALIDARG {
-                    result.unwrap();
-                }
-            }
-            let result = rules.Remove(&BSTR::from(FILTER_NAME_OUT));
-            if let Err(ref why) = result {
-                if why.code() != E_INVALIDARG {
-                    result.unwrap();
-                }
-            }
-        }
-        self.blocked_status = self.is_blocked().into();
+        unsafe { rules.Remove(&BSTR::from(FILTER_NAME_IN)).unwrap() };
+        unsafe { rules.Remove(&BSTR::from(FILTER_NAME_OUT)).unwrap() };
+        self.blocked_status = Self::is_blocked().into();
     }
 
-    fn is_blocked(&self) -> bool {
+    fn is_blocked() -> bool {
         let policy: INetFwPolicy2 =
             unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER).unwrap() };
         let rules = unsafe { policy.Rules().unwrap() };
@@ -172,7 +129,7 @@ impl GameNetworking {
         {
             self.counting = false;
             self.blocked_status = BlockedStatus::Unblocked;
-        };
+        }
     }
 }
 

src/gui/app.rs

@@ -17,13 +17,23 @@ enum Stage {
     About,
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct Flags {
     pub elevated: bool,
     pub debug: bool,
     closing: bool,
 }
 
+impl Default for Flags {
+    fn default() -> Self {
+        Self {
+            elevated: win::is_elevated(),
+            debug: false,
+            closing: false,
+        }
+    }
+}
+
 #[derive(Debug, Default)]
 pub struct App {
     pub meta: Meta,
@@ -35,7 +45,7 @@ pub struct App {
     pub anti_afk: features::anti_afk::AntiAfk,
     empty_session: features::empty_session::EmptySession,
     force_close: features::force_close::ForceClose,
-    game_networking: features::game_networking::GameNetworking,
+    pub game_networking: features::game_networking::GameNetworking,
     pub launch: features::launch::Launch,
 }
 
@@ -139,9 +149,20 @@ impl App {
             .outer_margin(egui::vec2(0.0, -2.0))
             .show(ui, |ui| {
                 let response = ui.add_enabled_ui(self.flags.elevated, |ui| {
-                    let label = ui.label("Game's network access");
+                    let label = ui.horizontal(|ui| {
+                        let label = ui.label("Game's network access");
+                        ui.add_space(1.0);
+                        ui.add(
+                            egui::Image::new(egui::include_image!("../../assets/circle.svg"))
+                                .max_size([4.0, 4.0].into())
+                                .tint(self.game_networking.blocked_status.to_color32()),
+                        )
+                        .on_hover_text("This turns yellow if GTA Tools\ncannot find your game.");
+                        self.game_networking.if_failed_return_to_unblocked();
+                        label
+                    });
                     ui.horizontal(|ui| {
-                        let available_width = label.rect.width();
+                        let available_width = label.inner.rect.width();
                         let spacing = ui.spacing().item_spacing.x;
                         let button_width = (available_width - spacing) / 2.0;
                         if ui
@@ -156,12 +177,6 @@ impl App {
                         {
                             self.game_networking.unblock_all();
                         }
-                        ui.add(
-                            egui::Image::new(egui::include_image!("../../assets/circle.svg"))
-                                .max_size([4.0, 4.0].into())
-                                .tint(self.game_networking.blocked_status.to_color32()),
-                        );
-                        self.game_networking.if_failed_return_to_unblocked();
                     });
                 });
                 response.response.on_disabled_hover_text(

src/gui/colours.rs

@@ -0,0 +1,22 @@
+use crate::features::game_networking::BlockedStatus;
+use eframe::egui;
+
+pub const RED: egui::Color32 = egui::Color32::from_rgb(255, 96, 96);
+pub const YELLOW: egui::Color32 = egui::Color32::from_rgb(255, 255, 96);
+pub const GREEN: egui::Color32 = egui::Color32::from_rgb(96, 255, 96);
+
+impl From<BlockedStatus> for egui::Color32 {
+    fn from(value: BlockedStatus) -> Self {
+        match value {
+            BlockedStatus::Blocked => RED,
+            BlockedStatus::Failed => YELLOW,
+            BlockedStatus::Unblocked => GREEN,
+        }
+    }
+}
+
+impl BlockedStatus {
+    pub fn to_color32(self) -> egui::Color32 {
+        self.into()
+    }
+}

src/gui/debug.rs

@@ -50,6 +50,15 @@ impl App {
                                     };
                                     ui.label(format!("focused: \"{current_title}\""));
                                 });
+                                ui.horizontal(|ui| {
+                                    ui.label("blocked_status");
+                                    egui::ComboBox::from_id_salt("blocked_status")
+                                    .selected_text(&self.game_networking.blocked_status.to_string())
+                                    .show_ui(ui, |ui| {
+                                        tools::build_menu(ui, &mut self.game_networking.blocked_status);
+                                    });
+
+                                });
                             });
                             ui.collapsing("anti afk", |ui| {
                                 ui.label(format!(

src/gui/mod.rs

@@ -1,4 +1,5 @@
 mod app;
+mod colours;
 mod debug;
 pub mod run;
 pub mod settings;

src/gui/run.rs

@@ -34,11 +34,9 @@ fn app_creator(
         app.settings = persistent_state.settings;
     }
     // check if we're elevated. if not, and the user wants an elevated launch - relaunch elevated
-    let elevated = util::win::is_elevated();
-    if app.settings.start_elevated && !elevated {
+    if !app.flags.elevated && app.settings.start_elevated {
         util::win::elevate(util::win::ElevationExitMethod::Forced);
     }
-    app.flags.elevated = elevated;
     // refresh sysinfo because it initializes with nothing
     app.sysinfo.refresh_all();
     // enable image loading support in egui

src/util/consts.rs

@@ -8,10 +8,3 @@ pub mod game {
     pub const EXE_LEGACY: &str = "GTA5.exe";
     pub const WINDOW_TITLE: &str = "Grand Theft Auto V";
 }
-
-pub mod colours {
-    use eframe::egui::Color32;
-    pub const RED: Color32 = Color32::from_rgb(249, 101, 84);
-    pub const YELLOW: Color32 = Color32::from_rgb(249, 236, 84);
-    pub const GREEN: Color32 = Color32::from_rgb(104, 249, 84);
-}