0.5.2

Cargo.toml

@@ -1,16 +1,22 @@
 [package]
 name = "gta-tools"
-version = "0.5.1"
+version = "0.5.2"
 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"
+eframe = { version = "0.31.1", default-features = false, features = [
-egui_extras = { version = "0.31.1", features = ["image", "svg"] }
+    "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

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,
+    INPUT, INPUT_KEYBOARD, KEYBD_EVENT_FLAGS, KEYBDINPUT, KEYEVENTF_KEYUP, MAPVK_VK_TO_VSC,
-    keybd_event,
+    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 {
+    let mut inputs = Vec::new();
-        keybd_event(
+    for &vk_code in vk_codes {
-            vk_code.0 as u8,
+        let scan_code = unsafe { MapVirtualKeyW(u32::from(vk_code.0), MAPVK_VK_TO_VSC) as u16 };
-            u8::try_from(MapVirtualKeyW(
+        for event in [KEYBD_EVENT_FLAGS(0), KEYEVENTF_KEYUP] {
-                u32::from(vk_code.0),
+            let mut input = INPUT {
-                MAP_VIRTUAL_KEY_TYPE(0),
+                r#type: INPUT_KEYBOARD,
-            ))
+                ..Default::default()
-            .unwrap(),
+            };
-            KEYBD_EVENT_FLAGS(0),
+            input.Anonymous.ki = KEYBDINPUT {
-            0,
+                wVk: vk_code,
-        );
+                wScan: scan_code,
-        keybd_event(
+                dwFlags: event,
-            vk_code.0 as u8,
+                time: 0,
-            u8::try_from(MapVirtualKeyW(
+                dwExtraInfo: 0,
-                u32::from(vk_code.0),
+            };
-                MAP_VIRTUAL_KEY_TYPE(0),
+            inputs.push(input);
-            ))
+        }
-            .unwrap(),
+        unsafe { SendInput(&inputs, size_of::<INPUT>() as i32) };
-            KEYBD_EVENT_FLAGS(2),
+    }
-            0,
-        );
-    });
 }

src/features/force_close.rs

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

src/features/game_networking.rs

@@ -1,7 +1,4 @@
-use crate::util::consts::{
+use crate::util::consts::game::{EXE_ENHANCED, EXE_LEGACY};
-    colours,
-    game::{EXE_ENHANCED, EXE_LEGACY},
-};
 use std::{
     path::Path,
     time::{Duration, Instant},
@@ -9,7 +6,6 @@ use std::{
 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,
@@ -36,29 +32,14 @@ pub enum BlockedStatus {
 
 impl From<bool> for BlockedStatus {
     fn from(value: bool) -> Self {
-        match value {
+        if value {
-            true => Self::Blocked,
+            Self::Blocked
-            false => Self::Unblocked,
+        } 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 +50,12 @@ pub struct GameNetworking {
 
 impl Default for GameNetworking {
     fn default() -> Self {
-        let mut gn = Self {
+        Self {
-            blocked_status: BlockedStatus::Unblocked,
+            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 +78,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 {
+        for filter in [
-            let inbound_rule: INetFwRule =
+            (FILTER_NAME_IN, NET_FW_RULE_DIR_IN),
-                CoCreateInstance(&NetFwRule, None, CLSCTX_INPROC_SERVER).unwrap();
+            (FILTER_NAME_OUT, NET_FW_RULE_DIR_OUT),
-            inbound_rule.SetName(&filter_name_in).unwrap();
+        ] {
-            inbound_rule.SetApplicationName(&exe_path).unwrap();
+            let _ = unsafe { rules.Remove(&BSTR::from(filter.0)) };
-            inbound_rule.SetDirection(NET_FW_RULE_DIR_IN).unwrap();
+            unsafe {
-            inbound_rule.SetEnabled(true.into()).unwrap();
+                let rule: INetFwRule =
-            inbound_rule.SetAction(NET_FW_ACTION_BLOCK).unwrap();
+                    CoCreateInstance(&NetFwRule, None, CLSCTX_INPROC_SERVER).unwrap();
-            inbound_rule.SetProtocol(NET_FW_IP_PROTOCOL_ANY.0).unwrap();
+                rule.SetName(&BSTR::from(filter.0)).unwrap();
-            rules.Add(&inbound_rule).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 {
+        self.blocked_status = Self::is_blocked().into();
-            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();
     }
 
     pub fn unblock_all(&mut self) {
         let policy: INetFwPolicy2 =
             unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER).unwrap() };
         let rules = unsafe { policy.Rules().unwrap() };
-        unsafe {
+        unsafe { rules.Remove(&BSTR::from(FILTER_NAME_IN)).unwrap() };
-            let result = rules.Remove(&BSTR::from(FILTER_NAME_IN));
+        unsafe { rules.Remove(&BSTR::from(FILTER_NAME_OUT)).unwrap() };
-            if let Err(ref why) = result {
+        self.blocked_status = Self::is_blocked().into();
-                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();
     }
 
-    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 +128,7 @@ impl GameNetworking {
         {
             self.counting = false;
             self.blocked_status = BlockedStatus::Unblocked;
-        };
+        }
     }
 }
 

src/gui/app.rs

@@ -139,9 +139,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 +167,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, 128, 128);
+pub const YELLOW: egui::Color32 = egui::Color32::from_rgb(255, 255, 128);
+pub const GREEN: egui::Color32 = egui::Color32::from_rgb(128, 255, 128);
+
+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/mod.rs

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

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);
-}