0.9.0

note: even if this raises binary size by a significant amount, it should in theory be more reliable, so it is a worthy sacrifice.

.github/workflows/release-on-tag.yml

@@ -0,0 +1,31 @@
+name: Create release for pushed tag
+
+on:
+  push:
+    tags:
+      - "*"
+
+jobs:
+  release-on-tag:
+    runs-on: windows-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Create release
+        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ github.ref_name }}
+        run: |
+          if gh release view "$TAG" >/dev/null 2>&1; then
+            echo "A release already exists for $TAG, skipping"
+          else
+            cargo build --release
+            prev_tag=$(gh release list --limit 100 --json tagName --jq '.[0].tagName')
+            notes="**Full Changelog**: https://github.com/${{ github.repository }}/compare/${prev_tag}...${TAG}"
+            gh release create "$TAG" target/release/gta-tools.exe \
+              --title "$TAG" \
+              --notes "$notes"
+          fi

.github/workflows/release-retroactively.yml

@@ -0,0 +1,43 @@
+name: Create releases for existing tags
+
+on:
+  workflow_dispatch:
+
+jobs:
+  release-retroactively:
+    runs-on: windows-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Get tags and create release for each
+        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          mapfile -t tags < <(git tag -l)
+          echo "${#tags[@]} tags found."
+          prev_tag=""
+          for tag in "${tags[@]}"; do
+            if gh release view "$tag" >/dev/null 2>&1; then
+              echo "A release already exists for $tag, skipping"
+            else
+              echo "Proceeding with tag $tag"
+              git checkout "$tag"
+              cargo build --release
+              if [ -n "$prev_tag" ]; then
+                notes="**Full Changelog**: https://github.com/${{ github.repository }}/compare/${prev_tag}...${tag}"
+              else
+                notes="**Full Changelog**: https://github.com/${{ github.repository }}/commits/${tag}"
+              fi
+              gh release create "$tag" target/release/gta-tools.exe \
+                --title "$tag" \
+                --notes "$notes"
+            fi
+            prev_tag="$tag"
+          done

.gitignore

@@ -1,2 +1,3 @@
 /target
 .vscode
+.idea

Cargo.toml

@@ -1,27 +1,38 @@
 [package]
 name = "gta-tools"
-version = "0.1.1"
+version = "0.9.0"
 edition = "2024"
 
 [dependencies]
-catppuccin-egui = { version = "5.5.0", default-features = false, features = [
-    "egui31",
+catppuccin-egui = { version = "5.6.0", default-features = false, features = [
+    "egui32",
 ] }
-eframe = "0.31.1"
-image = { version = "0.25.6", default-features = false }
+chrono = { version = "0.4.41", default-features = false, features = ["clock"] }
+eframe = { version = "0.32.2", default-features = false, features = [
+    "glow",
+    "default_fonts",
+] }
+egui_extras = { version = "0.32.2", default-features = false, features = [
+    "image",
+    "svg",
+] }
+image = { version = "0.25.8", default-features = false, features = ["png"] }
 open = "5.3.2"
-sysinfo = "0.33.1"
-windows = { version = "0.61.1", features = [
-    "Win32_UI_Input_KeyboardAndMouse",
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.143"
+strum = { version = "0.27.2", features = ["derive"] }
+windows = { version = "0.62.0", features = [
+    "Win32_NetworkManagement_WindowsFirewall",
+    "Win32_Security",
+    "Win32_System_Com",
+    "Win32_System_Diagnostics_ToolHelp",
     "Win32_System_Threading",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_Shell",
+    "Win32_UI_WindowsAndMessaging",
 ] }
 winreg = "0.55.0"
 
 [build-dependencies]
 static_vcruntime = "2.0.0"
-winresource = "0.1.20"
-
-[profile.release]
-strip = true
-lto = true
-codegen-units = 1
+winresource = "0.1.23"

LICENSE

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

README.md

@@ -1,3 +1,69 @@
-more spaghetti than the nation of italy
+# GTA Tools
 
-![](https://i.ibb.co/SwdWRfGj/gta-tools-WEQ02u-ROT5.png)
+A toolset of convenient things for GTA V Online.
+
+<picture>
+    <source srcset="https://i.vgy.me/M4sOHh.png" media="(prefers-color-scheme: dark)">
+    <img src="https://i.vgy.me/mpO9uc.png">
+</picture>
+
+## Installing
+
+**Option 1** — <ins>Download</ins>  
+Download the latest release [here](https://github.com/elituf/gta-tools/releases/latest/download/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**.
+
+## Guide
+
+Every feature of GTA Tools is Legacy/Enhanced-agnostic. Some functionality of GTA Tools requires administrator access. If necessary, GTA Tools can either be started as admin manually, or, the user can simply use the <kbd>Elevate</kbd> button to relaunch GTA Tools as admin.
+
+It is recommended to always use an up-to-date version of GTA Tools from [releases](https://github.com/elituf/gta-tools/releases). You can also easily access the current latest release by going to the <kbd>About</kbd> page of GTA Tools and clicking the <kbd>↓</kbd> button near the version number.
+
+#### Game
+
+This section is quite simple.
+
+There is a <kbd>Launch</kbd> feature, which will start your game on the chosen launcher and game version.
+
+There is also a <kbd>Force close game</kbd> feature, which simply kills all game processes. This button requires a second press after the first one for confirmation. This *does not* touch Rockstar Games Launcher or any other processes, only ones named `GTA5_Enhanced.exe` or `GTA5.exe`.
+
+#### Session
+
+This section also has two features.
+
+The first being <kbd>Empty current session</kbd>, which "removes everyone" from your session by suspending your game for 10 seconds, and then resuming it. This method is exceedingly similar to the Resource Monitor method, but made convenient in one button. This can be useful in numerous ways:
+* You are stuck loading into a session
+* You are stuck loading into an interior
+* You are about to get griefed while doing a freemode mission
+* You want to quickly get a "new" session
+
+The other feature is <kbd>Anti AFK</kbd>, which, when toggled, prevents you from getting kicked for idling by pressing keys on your keyboard every 60 seconds. At present, those keys are `VK_NUMPAD4` & `VK_NUMPAD6`, due to being a relatively good balance of keys that the game actually registers but don't interrupt gameplay too much if they activate while you're playing. You *must* be tabbed into GTA V for <kbd>Anti AFK</kbd> to work. While toggled, <kbd>Anti AFK</kbd> will only activate when all of the following conditions are true:
+* The `Grand Theft Auto V` window is currently focused
+* None of the designated keys are currently being pressed[^1]
+* The mouse cursor is not currently visible[^2]
+
+#### Network
+
+The last section has a single feature, <kbd>Game's network access</kbd>, with two buttons, <kbd>Block</kbd> and <kbd>Unblock</kbd>, and a coloured indicator dot. This feature requires administrator, and blocks/unblocks GTA V's entire internet access using the Windows Firewall. The coloured indicator dot has these meanings:
+* **Green** - the game is connected to the internet
+* **Yellow** - the game could not be found running, and thus was not blocked
+* **Red** - the game is blocked from the internet
+
+This feature is primarily useful for **replay glitching**, which is an exploit that allows you to complete any heist/mission finale, get the money for it, and then be able to do it again right away. Here's how you can do a replay glitch:
+1. Get to the finale of a heist/contract/mission series, such as **The Contract: Dr. Dre**
+2. Complete the finale as normal
+3. Right *after* the **HEIST/MISSION PASSED** screen you get when you complete a finale (basically, when your cut is being shown), <kbd>Block</kbd> the game's internet access
+4. After a few seconds, you will be shown an error screen and kicked to the main menu
+5. At this point, <kbd>Unblock</kbd> the game's internet access and load back into online
+6. Finally, spend any amount of money, and you should receive the finale cut, but also be able to go play the finale again immediately
+
+## Issues
+
+- I have noticed that on my current Windows 10 install, when not elevated (administrator), the <kbd>Force close game</kbd> and <kbd>Empty current session</kbd> features can fail due to being denied access. This was tested by other people and is not guaranteed to happen. If this does happen to you, I recommend using GTA Tools always in elevated mode. Check "Always start elevated" in the Settings tab.
+
+
+
+[^1]: Otherwise, if you are, for example, using those keys to fly a plane, <kbd>Anti AFK</kbd> activating could cancel the input.
+[^2]: Specifically, the Windows mouse cursor, not the in-game mouse cursor. This check is mostly used to prevent typing while you are in the Rockstar overlay.

assets/circle.svg

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="512"
+   height="512"
+   viewBox="0 0 512 512"
+   version="1.1"
+   id="svg1"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs1" />
+  <g
+     id="layer1">
+    <circle
+       style="fill:#ffffff"
+       id="path1"
+       cx="256"
+       cy="256"
+       r="256" />
+  </g>
+</svg>

justfile

@@ -0,0 +1,15 @@
+set windows-shell := ["pwsh", "-NoLogo", "-NoProfileLoadTime", "-Command"]
+
+install:
+    cargo build --release
+    cp .\target\release\gta-tools.exe ~\.cargo\bin
+    cp .\target\release\gta-tools.exe ~\Documents
+
+lint:
+    cargo clippy -- -W clippy::pedantic -W clippy::nursery -A clippy::cast_sign_loss -A clippy::cast_possible_truncation -A clippy::cast_possible_wrap
+
+lint-full:
+    cargo clippy -- -W clippy::pedantic -W clippy::nursery -W clippy::unwrap_used
+
+lint-unwraps:
+    cargo clippy -- -W clippy::unwrap_used

src/features.rs

@@ -1,4 +1,5 @@
 pub mod anti_afk;
 pub mod empty_session;
 pub mod force_close;
+pub mod game_networking;
 pub mod launch;

src/features/anti_afk.rs

@@ -1,11 +1,14 @@
+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, keybd_event,
+    INPUT, INPUT_KEYBOARD, KEYBD_EVENT_FLAGS, KEYBDINPUT, KEYEVENTF_KEYUP, MAPVK_VK_TO_VSC,
+    MapVirtualKeyW, SendInput, VIRTUAL_KEY, VK_NUMPAD4, VK_NUMPAD6,
 };
 
-pub const INTERVAL: Duration = Duration::from_secs(60);
-const VK_SHIFT: u8 = 16;
+const INTERVAL: Duration = Duration::from_secs(60);
+const PRESS_KEYS: [VIRTUAL_KEY; 2] = [VK_NUMPAD4, VK_NUMPAD6];
 
+#[derive(Debug)]
 pub struct AntiAfk {
     pub enabled: bool,
     pub interval: Instant,
@@ -20,23 +23,40 @@ impl Default for AntiAfk {
     }
 }
 
-pub fn send(vk_code: u8) {
-    unsafe {
-        keybd_event(
-            vk_code,
-            u8::try_from(MapVirtualKeyW(u32::from(vk_code), MAP_VIRTUAL_KEY_TYPE(0))).unwrap(),
-            KEYBD_EVENT_FLAGS(0),
-            0,
-        );
-        keybd_event(
-            vk_code,
-            u8::try_from(MapVirtualKeyW(u32::from(vk_code), MAP_VIRTUAL_KEY_TYPE(0))).unwrap(),
-            KEYBD_EVENT_FLAGS(2),
-            0,
-        );
+impl AntiAfk {
+    pub fn can_activate(&self) -> bool {
+        use util::win::{is_any_key_pressed, is_cursor_visible, is_window_focused};
+        is_window_focused(WINDOW_TITLE) && !is_any_key_pressed(&PRESS_KEYS) && !is_cursor_visible()
+    }
+
+    pub fn should_activate(&self) -> bool {
+        self.enabled && self.interval.elapsed() >= INTERVAL
+    }
+
+    pub fn activate(&mut self) {
+        send(&PRESS_KEYS);
+        self.interval = Instant::now();
     }
 }
 
-pub fn activate() {
-    send(VK_SHIFT);
+fn send(vk_codes: &[VIRTUAL_KEY]) {
+    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/empty_session.rs

@@ -1,17 +1,20 @@
-use crate::{features, gui::App, util::Countdown};
+use crate::util::{
+    consts::game::{EXE_ENHANCED, EXE_LEGACY},
+    countdown::Countdown,
+    log,
+    system_info::SystemInfo,
+};
 use std::time::{Duration, Instant};
-use sysinfo::System;
 use windows::Win32::{
-    Foundation::{HANDLE, NTSTATUS},
+    Foundation::{CloseHandle, HANDLE, NTSTATUS},
     System::Threading::{OpenProcess, PROCESS_SUSPEND_RESUME},
 };
 
-pub const INTERVAL: Duration = Duration::from_secs(10);
-const ENHANCED: &str = "GTA5_Enhanced.exe";
-const LEGACY: &str = "GTA5.exe";
+const INTERVAL: Duration = Duration::from_secs(10);
 
+#[derive(Debug)]
 pub struct EmptySession {
-    pub enabled: bool,
+    pub disabled: bool,
     pub interval: Instant,
     pub countdown: Countdown,
 }
@@ -19,44 +22,61 @@ pub struct EmptySession {
 impl Default for EmptySession {
     fn default() -> Self {
         Self {
-            enabled: true,
+            disabled: false,
             interval: Instant::now(),
-            countdown: Countdown::new(features::empty_session::INTERVAL.as_secs() as usize),
+            countdown: Countdown::new(INTERVAL.as_secs()),
+        }
+    }
+}
+
+impl EmptySession {
+    pub fn run_timers(&mut self, game_handle: &mut HANDLE) {
+        if self.disabled {
+            self.countdown.count();
+        } else {
+            self.countdown.reset();
+        }
+        if self.interval.elapsed() >= INTERVAL {
+            deactivate(game_handle);
+            self.disabled = false;
         }
     }
 }
 
 #[link(name = "ntdll")]
 unsafe extern "system" {
-    pub unsafe fn NtSuspendProcess(ProcessHandle: HANDLE) -> NTSTATUS;
-    pub unsafe fn NtResumeProcess(ProcessHandle: HANDLE) -> NTSTATUS;
+    unsafe fn NtSuspendProcess(ProcessHandle: HANDLE) -> NTSTATUS;
+    unsafe fn NtResumeProcess(ProcessHandle: HANDLE) -> NTSTATUS;
 }
 
-fn get_gta_pid(sysinfo: &mut System) -> u32 {
-    sysinfo.refresh_all();
-    if let Some((pid, _)) = sysinfo
+fn get_gta_pid(system_info: &mut SystemInfo) -> Option<u32> {
+    system_info.refresh();
+    system_info
         .processes()
         .iter()
-        .find(|(_, p)| p.name() == ENHANCED || p.name() == LEGACY)
-    {
-        return pid.as_u32();
+        .find(|p| p.name() == EXE_ENHANCED || p.name() == EXE_LEGACY)
+        .map(|p| p.pid())
+}
+
+pub fn activate(game_handle: &mut HANDLE, system_info: &mut SystemInfo) -> Result<(), ()> {
+    let Some(pid) = get_gta_pid(system_info) else {
+        return Err(());
     };
-    u32::MAX
+    match unsafe { OpenProcess(PROCESS_SUSPEND_RESUME, false, pid) } {
+        Ok(handle) => *game_handle = handle,
+        Err(why) => {
+            let message = format!("failed to suspend game for empty session:\n{why}");
+            log::log(log::LogLevel::Error, &message);
+            return Err(());
+        }
+    }
+    let _ = unsafe { NtSuspendProcess(*game_handle) };
+    Ok(())
 }
 
-pub fn activate(app: &mut App) {
-    let pid = get_gta_pid(&mut app.sysinfo);
-    if pid == u32::MAX {
-        return;
-    }
-    unsafe {
-        app.game_handle = OpenProcess(PROCESS_SUSPEND_RESUME, false, pid).unwrap();
-        let _ = NtSuspendProcess(app.game_handle);
-    }
-}
-
-pub fn deactivate(app: &mut App) {
-    unsafe {
-        let _ = NtResumeProcess(app.game_handle);
+pub fn deactivate(game_handle: &mut HANDLE) {
+    if !game_handle.is_invalid() {
+        let _ = unsafe { NtResumeProcess(*game_handle) };
+        let _ = unsafe { CloseHandle(*game_handle) };
     }
 }

src/features/force_close.rs

@@ -1,32 +1,72 @@
-use std::time::Instant;
-use sysinfo::System;
+use crate::util::{
+    consts::game::{EXE_ENHANCED, EXE_LEGACY},
+    log,
+    system_info::SystemInfo,
+};
+use std::time::{Duration, Instant};
 
-const ENHANCED: &str = "GTA5_Enhanced.exe";
-const LEGACY: &str = "GTA5.exe";
+const INTERVAL: Duration = Duration::from_secs(3);
 
+#[derive(Debug)]
 pub struct ForceClose {
     pub button_text: String,
-    pub prompting: bool,
-    pub interval: Instant,
+    timer: Instant,
+    counting: bool,
+    current_frame: bool,
 }
 
 impl Default for ForceClose {
     fn default() -> Self {
         Self {
-            button_text: "Force close game".to_string(),
-            prompting: false,
-            interval: Instant::now(),
+            button_text: "Force close game".to_owned(),
+            timer: Instant::now(),
+            counting: false,
+            current_frame: false,
         }
     }
 }
 
-pub fn activate(sysinfo: &mut System) {
-    sysinfo.refresh_all();
-    sysinfo
+impl ForceClose {
+    pub fn prompt(&mut self, force_close_button_clicked: bool, system_info: &mut SystemInfo) {
+        if force_close_button_clicked && !self.counting {
+            self.button_text = "Are you sure?".to_owned();
+            self.timer = Instant::now();
+            self.counting = true;
+            self.current_frame = true;
+        }
+        if self.counting && self.timer.elapsed() >= INTERVAL {
+            self.reset();
+        } else if force_close_button_clicked && !self.current_frame {
+            activate(system_info);
+            self.reset();
+        }
+        self.finish_current_frame();
+    }
+
+    fn reset(&mut self) {
+        *self = Self::default();
+    }
+
+    const fn finish_current_frame(&mut self) {
+        if self.current_frame {
+            self.current_frame = false;
+        }
+    }
+}
+
+fn activate(system_info: &mut SystemInfo) {
+    system_info.refresh();
+    system_info
         .processes()
         .iter()
-        .filter(|(_, p)| p.name() == ENHANCED || p.name() == LEGACY)
-        .for_each(|(_, p)| {
-            p.kill();
+        .filter(|p| p.name() == EXE_ENHANCED || p.name() == EXE_LEGACY)
+        .for_each(|p| {
+            if !p.kill() {
+                log::log(
+                    log::LogLevel::Error,
+                    "failed to force close game, probably due to access denied",
+                );
+            }
         });
+    system_info.refresh();
 }

src/features/game_networking.rs

@@ -0,0 +1,141 @@
+use crate::util::{
+    consts::game::{EXE_ENHANCED, EXE_LEGACY},
+    system_info::SystemInfo,
+};
+use std::{
+    path::Path,
+    time::{Duration, Instant},
+};
+use strum::{Display, EnumIter};
+use windows::{
+    Win32::{
+        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,
+        },
+        System::Com::{
+            CLSCTX_INPROC_SERVER, COINIT_MULTITHREADED, CoCreateInstance, CoInitializeEx,
+            CoUninitialize,
+        },
+    },
+    core::BSTR,
+};
+
+const FILTER_NAME_IN: &str = "[GTA Tools] Block all inbound traffic for GTA V";
+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, Display, PartialEq, Eq, EnumIter)]
+pub enum BlockedStatus {
+    Blocked,
+    Failed,
+    Unblocked,
+}
+
+impl From<bool> for BlockedStatus {
+    fn from(value: bool) -> Self {
+        if value {
+            Self::Blocked
+        } else {
+            Self::Unblocked
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct GameNetworking {
+    com_initialized: bool,
+    pub blocked_status: BlockedStatus,
+    timer: Instant,
+    counting: bool,
+}
+
+impl Default for GameNetworking {
+    fn default() -> Self {
+        Self {
+            blocked_status: Self::is_blocked().into(),
+            com_initialized: unsafe { CoInitializeEx(None, COINIT_MULTITHREADED) }.is_ok(),
+            timer: Instant::now(),
+            counting: false,
+        }
+    }
+}
+
+impl Drop for GameNetworking {
+    fn drop(&mut self) {
+        if self.com_initialized {
+            unsafe { CoUninitialize() };
+        }
+    }
+}
+
+impl GameNetworking {
+    pub fn block_all(&mut self, system_info: &mut SystemInfo) {
+        let Some(exe_path) = get_game_exe_path(system_info) else {
+            self.blocked_status = BlockedStatus::Failed;
+            return;
+        };
+        let policy: INetFwPolicy2 =
+            unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER) }.unwrap();
+        let rules = unsafe { policy.Rules() }.unwrap();
+        let exe_path = BSTR::from(exe_path.to_string_lossy().to_string());
+        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)) };
+            let rule: INetFwRule =
+                unsafe { CoCreateInstance(&NetFwRule, None, CLSCTX_INPROC_SERVER) }.unwrap();
+            unsafe { rule.SetName(&BSTR::from(filter.0)) }.unwrap();
+            unsafe { rule.SetApplicationName(&exe_path) }.unwrap();
+            unsafe { rule.SetDirection(filter.1) }.unwrap();
+            unsafe { rule.SetEnabled(true.into()) }.unwrap();
+            unsafe { rule.SetAction(NET_FW_ACTION_BLOCK) }.unwrap();
+            unsafe { rule.SetProtocol(NET_FW_IP_PROTOCOL_ANY.0) }.unwrap();
+            unsafe { rules.Add(&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 { 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() -> bool {
+        let policy: INetFwPolicy2 =
+            unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER) }.unwrap();
+        let rules = unsafe { policy.Rules() }.unwrap();
+        let in_rule_exists = unsafe { rules.Item(&BSTR::from(FILTER_NAME_IN)) }.is_ok();
+        let out_rule_exists = unsafe { rules.Item(&BSTR::from(FILTER_NAME_OUT)) }.is_ok();
+        in_rule_exists || out_rule_exists
+    }
+
+    pub fn if_failed_return_to_boolean(&mut self) {
+        if self.blocked_status == BlockedStatus::Failed && !self.counting {
+            self.counting = true;
+            self.timer = Instant::now();
+        }
+        if self.blocked_status == BlockedStatus::Failed
+            && self.counting
+            && self.timer.elapsed() >= INTERVAL
+        {
+            self.counting = false;
+            self.blocked_status = Self::is_blocked().into();
+        }
+    }
+}
+
+fn get_game_exe_path(system_info: &mut SystemInfo) -> Option<&Path> {
+    system_info.refresh();
+    system_info
+        .processes()
+        .iter()
+        .find(|p| p.name() == EXE_ENHANCED || p.name() == EXE_LEGACY)
+        .and_then(|p| p.exe())
+}

src/features/launch.rs

@@ -1,40 +1,40 @@
-use std::{fmt::Display, path::PathBuf, process::Command};
+use crate::gui::settings::LaunchVersion;
+use serde::{Deserialize, Serialize};
+use std::{path::PathBuf, process::Command};
+use strum::{Display, EnumIter};
 use winreg::{RegKey, enums::HKEY_LOCAL_MACHINE};
 
-#[derive(Default, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Default, Debug, Display, PartialEq, Eq, Serialize, Deserialize, EnumIter)]
 pub enum Platform {
     #[default]
     Steam,
+    #[strum(to_string = "Rockstar Games")]
     Rockstar,
+    #[strum(to_string = "Epic Games")]
     Epic,
 }
 
-impl Display for Platform {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let x = match self {
-            Self::Steam => "Steam",
-            Self::Rockstar => "Rockstar Games",
-            Self::Epic => "Epic Games",
-        };
-        write!(f, "{x}")
-    }
-}
-
-#[derive(Default)]
+#[derive(Debug, Default)]
 pub struct Launch {
     pub selected: Platform,
 }
 
-pub fn launch(platform: &Platform) {
+pub fn launch(platform: &Platform, version: &LaunchVersion) {
     match platform {
         Platform::Steam => {
-            let _ = open::that_detached("steam://run/3240220");
+            let steam_url = match version {
+                LaunchVersion::Enhanced => "steam://run/3240220",
+                LaunchVersion::Legacy => "steam://run/271590",
+            };
+            let _ = open::that_detached(steam_url);
         }
         Platform::Rockstar => {
             let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
-            let Ok(gta_v_enhanced) =
-                hklm.open_subkey(r"SOFTWARE\WOW6432Node\Rockstar Games\GTAV Enhanced")
-            else {
+            let rockstar_url = match version {
+                LaunchVersion::Enhanced => r"SOFTWARE\WOW6432Node\Rockstar Games\GTAV Enhanced",
+                LaunchVersion::Legacy => r"SOFTWARE\WOW6432Node\Rockstar Games\Grand Theft Auto V",
+            };
+            let Ok(gta_v_enhanced) = hklm.open_subkey(rockstar_url) else {
                 return;
             };
             let Ok(install_folder): Result<String, std::io::Error> =
@@ -47,9 +47,15 @@ pub fn launch(platform: &Platform) {
             let _ = Command::new(play_gtav_path).spawn();
         }
         Platform::Epic => {
-            let _ = open::that_detached(
-                "com.epicgames.launcher://apps/331226ba7c944720baa99103cb1fe80c?action=launch&silent=true",
-            );
+            let epic_url = match version {
+                LaunchVersion::Enhanced => {
+                    "com.epicgames.launcher://apps/8769e24080ea413b8ebca3f1b8c50951?action=launch&silent=true"
+                }
+                LaunchVersion::Legacy => {
+                    "com.epicgames.launcher://apps/9d2d0eb64d5c44529cece33fe2a46482?action=launch&silent=true"
+                }
+            };
+            let _ = open::that_detached(epic_url);
         }
     }
 }

src/gui.rs

@@ -1,170 +1,7 @@
-use crate::features::{
-    self,
-    anti_afk::AntiAfk,
-    empty_session::EmptySession,
-    force_close::ForceClose,
-    launch::{Launch, Platform},
-};
-use eframe::egui;
-use std::time::{Duration, Instant};
-use sysinfo::System;
-use windows::Win32::Foundation::HANDLE;
-
-pub struct App {
-    pub current_frame: bool,
-    pub sysinfo: System,
-    pub game_handle: HANDLE,
-    pub launch: Launch,
-    pub force_close: ForceClose,
-    pub empty_session: EmptySession,
-    pub anti_afk: AntiAfk,
-}
-
-impl Default for App {
-    fn default() -> Self {
-        Self {
-            current_frame: false,
-            sysinfo: System::new_all(),
-            game_handle: HANDLE::default(),
-            launch: Launch::default(),
-            force_close: ForceClose::default(),
-            empty_session: EmptySession::default(),
-            anti_afk: AntiAfk::default(),
-        }
-    }
-}
-
-impl eframe::App for App {
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        catppuccin_egui::set_theme(ctx, catppuccin_egui::MOCHA);
-        ctx.request_repaint_after(Duration::from_millis(100));
-        egui::CentralPanel::default().show(ctx, |ui| {
-            ui.horizontal(|ui| {
-                ui.label("Game");
-                ui.add(egui::Separator::default().horizontal());
-            });
-            ui.horizontal(|ui| {
-                if ui.button("Launch").clicked() {
-                    features::launch::launch(&self.launch.selected);
-                };
-                egui::ComboBox::from_label("")
-                    .selected_text(self.launch.selected.to_string())
-                    .width(125.0)
-                    .show_ui(ui, |ui| {
-                        ui.selectable_value(
-                            &mut self.launch.selected,
-                            Platform::Steam,
-                            Platform::Steam.to_string(),
-                        );
-                        ui.selectable_value(
-                            &mut self.launch.selected,
-                            Platform::Rockstar,
-                            Platform::Rockstar.to_string(),
-                        );
-                        ui.selectable_value(
-                            &mut self.launch.selected,
-                            Platform::Epic,
-                            Platform::Epic.to_string(),
-                        );
-                    });
-            });
-            let force_close_button = ui.button(&self.force_close.button_text);
-            if force_close_button.clicked() && !self.force_close.prompting {
-                self.force_close.button_text = "Are you sure?".to_string();
-                self.force_close.prompting = true;
-                self.force_close.interval = Instant::now();
-                self.current_frame = true;
-            };
-            if self.force_close.prompting
-                && self.force_close.interval.elapsed() <= Duration::from_secs(3)
-            {
-                if force_close_button.clicked() && !self.current_frame {
-                    features::force_close::activate(&mut self.sysinfo);
-                    self.force_close = ForceClose::default();
-                }
-            } else {
-                self.force_close = ForceClose::default();
-            }
-            if self.current_frame {
-                self.current_frame = false;
-            }
-            ui.horizontal(|ui| {
-                ui.label("Session");
-                ui.add(egui::Separator::default().horizontal());
-            });
-            ui.add_enabled_ui(self.empty_session.enabled, |ui| {
-                ui.horizontal(|ui| {
-                    if ui.button("Empty current session").clicked() {
-                        self.empty_session.interval = Instant::now();
-                        self.empty_session.enabled = false;
-                        features::empty_session::activate(self);
-                    }
-                    if !self.empty_session.enabled {
-                        self.empty_session.countdown.count();
-                    } else {
-                        self.empty_session.countdown.reset();
-                    }
-                    if self.empty_session.interval.elapsed() >= features::empty_session::INTERVAL {
-                        features::empty_session::deactivate(self);
-                        self.empty_session.enabled = true;
-                    }
-                    ui.label(&self.empty_session.countdown.i_string);
-                });
-            });
-            ui.checkbox(&mut self.anti_afk.enabled, "Anti AFK")
-                .on_hover_text("You should be tabbed in\nwhile this is enabled.");
-            if self.anti_afk.enabled
-                && self.anti_afk.interval.elapsed() >= features::anti_afk::INTERVAL
-            {
-                features::anti_afk::activate();
-                self.anti_afk.interval = Instant::now();
-            }
-            ui.with_layout(egui::Layout::bottom_up(egui::Align::Center), |ui| {
-                ui.horizontal(|ui| {
-                    ui.horizontal(|ui| {
-                        ui.spacing_mut().item_spacing.x = 0.0;
-                        ui.label("with love from ");
-                        ui.hyperlink_to("futile", "http://futile.eu");
-                    });
-                    ui.separator();
-                    ui.label(format!("v{}", env!("CARGO_PKG_VERSION")));
-                });
-                // ui.separator();
-            });
-        });
-    }
-}
-
-fn load_icon() -> eframe::egui::IconData {
-    let (icon_rgba, icon_width, icon_height) = {
-        let icon = include_bytes!("../assets/icon.png");
-        let image = image::load_from_memory(icon).unwrap().into_rgba8();
-        let (width, height) = image.dimensions();
-        let rgba = image.into_raw();
-        (rgba, width, height)
-    };
-
-    eframe::egui::IconData {
-        rgba: icon_rgba,
-        width: icon_width,
-        height: icon_height,
-    }
-}
-
-pub fn run() {
-    let options = eframe::NativeOptions {
-        viewport: egui::ViewportBuilder::default()
-            .with_resizable(false)
-            .with_maximize_button(false)
-            .with_inner_size([250.0, 180.0])
-            .with_icon(load_icon()),
-        centered: true,
-        ..Default::default()
-    };
-    eframe::run_native(
-        "GTA Tools",
-        options,
-        Box::new(|_cc| Ok(Box::<App>::default())),
-    )
-    .unwrap();
-}
+mod app;
+mod colours;
+mod debug;
+pub mod run;
+pub mod settings;
+mod tools;
+mod ui_ext;

src/gui/app.rs

@@ -0,0 +1,270 @@
+use crate::{
+    features,
+    gui::{colours, settings::Settings, tools, ui_ext::UiExt},
+    util::{
+        consts::game::WINDOW_TITLE, persistent_state::PersistentState, system_info::SystemInfo, win,
+    },
+};
+use eframe::egui;
+use std::time::{Duration, Instant};
+use strum::{Display, EnumIter};
+
+pub const WINDOW_SIZE: [f32; 2] = [240.0, 240.0];
+
+#[derive(Clone, Copy, Debug, Default, Display, PartialEq, Eq, EnumIter)]
+enum Stage {
+    #[default]
+    Main,
+    Settings,
+    About,
+}
+
+#[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 settings: Settings,
+    stage: Stage,
+    pub flags: Flags,
+    pub system_info: SystemInfo,
+    game_handle: windows::Win32::Foundation::HANDLE,
+    pub anti_afk: features::anti_afk::AntiAfk,
+    empty_session: features::empty_session::EmptySession,
+    force_close: features::force_close::ForceClose,
+    pub game_networking: features::game_networking::GameNetworking,
+    pub launch: features::launch::Launch,
+}
+
+impl eframe::App for App {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        ctx.request_repaint_after(Duration::from_millis(100));
+        self.empty_session.run_timers(&mut self.game_handle);
+        egui::TopBottomPanel::bottom("bottom_panel")
+            .exact_height(25.0)
+            .show(ctx, |ui| {
+                ui.with_layout(egui::Layout::left_to_right(egui::Align::Center), |ui| {
+                    ui.build_menu(&mut self.stage);
+                    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                        let button = ui
+                            .add_enabled(!self.flags.elevated, egui::Button::new("Elevate"))
+                            .on_hover_text("Relaunch ourselves as administrator.")
+                            .on_disabled_hover_text("We are already running elevated.");
+                        if button.clicked() {
+                            win::elevate(win::ElevationExitMethod::Gentle(&mut self.flags.closing));
+                        }
+                    });
+                });
+            });
+        egui::CentralPanel::default().show(ctx, |ui| {
+            egui::ScrollArea::vertical()
+                .auto_shrink([false, true])
+                .show(ui, |ui| match self.stage {
+                    Stage::Main => self.show_main_stage(ctx, ui),
+                    Stage::Settings => self.show_settings_stage(ctx, ui),
+                    Stage::About => self.show_about_stage(ctx, ui),
+                });
+        });
+        if tools::debug_keycombo_pressed(ctx) || tools::debug_viewport_close_pressed(ctx) {
+            self.flags.debug = !self.flags.debug;
+        }
+        if self.flags.debug {
+            self.show_debug_viewport(ctx);
+        }
+        if self.flags.closing {
+            ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+        }
+    }
+}
+
+impl App {
+    fn show_game_section(&mut self, _ctx: &egui::Context, ui: &mut egui::Ui) {
+        ui.header("Game");
+        ui.horizontal(|ui| {
+            if ui.button("Launch").clicked() {
+                features::launch::launch(&self.launch.selected, &self.settings.launch_version);
+            }
+            egui::ComboBox::from_id_salt("Launch")
+                .selected_text(self.launch.selected.to_string())
+                .width(120.0)
+                .show_ui(ui, |ui| {
+                    ui.build_menu(&mut self.launch.selected);
+                });
+        });
+        let force_close_button = ui.add_sized(
+            [104.0, 0.0],
+            egui::Button::new(&self.force_close.button_text),
+        );
+        self.force_close
+            .prompt(force_close_button.clicked(), &mut self.system_info);
+    }
+
+    fn show_session_section(&mut self, _ctx: &egui::Context, ui: &mut egui::Ui) {
+        ui.header("Session");
+        ui.add_enabled_ui(!self.empty_session.disabled, |ui| {
+            ui.horizontal(|ui| {
+                if ui.button("Empty current session").clicked()
+                    && features::empty_session::activate(
+                        &mut self.game_handle,
+                        &mut self.system_info,
+                    )
+                    .is_ok()
+                {
+                    self.empty_session.interval = Instant::now();
+                    self.empty_session.disabled = true;
+                }
+                ui.label(&self.empty_session.countdown.i_string);
+            });
+        });
+        ui.horizontal(|ui| {
+            ui.checkbox(&mut self.anti_afk.enabled, "Anti AFK")
+                .on_hover_text("You should be tabbed in\nfor this to work.");
+            if self.anti_afk.enabled {
+                ui.add_space(8.0);
+                ui.add_enabled_ui(false, |ui| {
+                    ui.label(if win::is_window_focused(WINDOW_TITLE) {
+                        "GTA is focused."
+                    } else {
+                        "GTA is not focused!"
+                    })
+                });
+            }
+        });
+        if self.anti_afk.can_activate() && self.anti_afk.should_activate() {
+            self.anti_afk.activate();
+        }
+    }
+
+    fn show_network_section(&mut self, _ctx: &egui::Context, ui: &mut egui::Ui) {
+        ui.header("Network");
+        egui::Frame::new()
+            .outer_margin(egui::vec2(0.0, -2.0))
+            .show(ui, |ui| {
+                let response = ui.add_enabled_ui(self.flags.elevated, |ui| {
+                    let label = ui.horizontal(|ui| {
+                        let label = ui.label("Game's network access");
+                        ui.add_space(1.0);
+                        ui.create_indicator_dot(self.game_networking.blocked_status)
+                            .on_hover_text(
+                                "This turns yellow if GTA Tools\ncannot find your game.",
+                            );
+                        self.game_networking.if_failed_return_to_boolean();
+                        label
+                    });
+                    ui.horizontal(|ui| {
+                        let available_width = label.inner.rect.width();
+                        let spacing = ui.spacing().item_spacing.x;
+                        let button_width = (available_width - spacing) / 2.0;
+                        if ui
+                            .add_sized([button_width, 18.0], egui::Button::new("Block"))
+                            .clicked()
+                        {
+                            self.game_networking.block_all(&mut self.system_info);
+                        }
+                        if ui
+                            .add_sized([button_width, 18.0], egui::Button::new("Unblock"))
+                            .clicked()
+                        {
+                            self.game_networking.unblock_all();
+                        }
+                    });
+                });
+                response.response.on_disabled_hover_text(
+                    "This requires administrator.\nUse the Elevate button.",
+                );
+            });
+    }
+
+    fn show_main_stage(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) {
+        self.show_game_section(ctx, ui);
+        self.show_session_section(ctx, ui);
+        self.show_network_section(ctx, ui);
+    }
+
+    fn show_settings_stage(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) {
+        ui.horizontal(|ui| {
+            ui.label("Launch version");
+            egui::ComboBox::from_id_salt("Launch version")
+                .selected_text(self.settings.launch_version.to_string())
+                .show_ui(ui, |ui| {
+                    ui.build_menu(&mut self.settings.launch_version);
+                });
+        });
+        ui.horizontal(|ui| {
+            let selection = self.settings.theme;
+            ui.label("Theme");
+            egui::ComboBox::from_id_salt("Theme")
+                .selected_text(self.settings.theme.to_string())
+                .show_ui(ui, |ui| {
+                    ui.build_menu(&mut self.settings.theme);
+                });
+            if selection != self.settings.theme {
+                catppuccin_egui::set_theme(ctx, self.settings.theme.into());
+            }
+        });
+        ui.checkbox(&mut self.settings.start_elevated, "Always start elevated");
+    }
+
+    fn show_about_stage(&self, _ctx: &egui::Context, ui: &mut egui::Ui) {
+        ui.with_layout(egui::Layout::bottom_up(egui::Align::Center), |ui| {
+            ui.horizontal(|ui| {
+                ui.horizontal(|ui| {
+                    ui.spacing_mut().item_spacing.x = 0.0;
+                    ui.label("with ");
+                    ui.scope(|ui| {
+                        ui.style_mut().visuals.hyperlink_color = colours::RED;
+                        ui.hyperlink_to("❤", "https://github.com/elituf/gta-tools");
+                    });
+                    ui.label(" from ");
+                    ui.hyperlink_to("futile", "https://futile.eu");
+                });
+                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                    if cfg!(debug_assertions) {
+                        ui.label("(dev)");
+                    }
+                    ui.label(format!("v{}", env!("CARGO_PKG_VERSION")));
+                    ui.scope(|ui| {
+                        ui.style_mut().spacing.button_padding = egui::Vec2::new(3.0, 0.0);
+                        let button = ui
+                            .button("⬇")
+                            .on_hover_text("Go to current latest version.");
+                        if button.clicked() {
+                            let _ =
+                                open::that("https://github.com/elituf/gta-tools/releases/latest");
+                        }
+                    });
+                });
+            });
+            ui.add(egui::Image::new(egui::include_image!(
+                "../../assets/icon.png"
+            )));
+        });
+    }
+}
+
+impl Drop for App {
+    fn drop(&mut self) {
+        // save any persistent state to config file
+        PersistentState {
+            launcher: self.launch.selected,
+            settings: self.settings.clone(),
+        }
+        .set();
+        // make sure we are not suspending game
+        features::empty_session::deactivate(&mut self.game_handle);
+    }
+}

src/gui/colours.rs

@@ -0,0 +1,16 @@
+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,
+        }
+    }
+}

src/gui/debug.rs

@@ -0,0 +1,90 @@
+use crate::{
+    gui::{
+        app::{App, WINDOW_SIZE},
+        tools,
+        ui_ext::UiExt,
+    },
+    util::consts::{
+        game::{EXE_ENHANCED, EXE_LEGACY},
+        path,
+    },
+};
+use eframe::egui;
+
+impl App {
+    fn add_debug_viewport_contents(&mut self, ui: &mut egui::Ui) {
+        ui.collapsing("misc", |ui| {
+            if ui.button("open storage path").clicked() {
+                open::that_detached(path::APP_STORAGE.as_path()).unwrap();
+            }
+            ui.scope(|ui| {
+                use windows::Win32::UI::WindowsAndMessaging::{
+                    GetForegroundWindow, GetWindowTextW,
+                };
+                let current_title = {
+                    let mut buffer = [0; 512];
+                    let hwnd = unsafe { GetForegroundWindow() };
+                    let length = unsafe { GetWindowTextW(hwnd, &mut buffer) };
+                    String::from_utf16_lossy(&buffer[..length as usize])
+                };
+                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| {
+                        ui.build_menu(&mut self.game_networking.blocked_status);
+                    });
+            });
+            if ui.add(egui::Button::new("force refresh theme")).clicked() {
+                catppuccin_egui::set_theme(ui.ctx(), self.settings.theme.into());
+            }
+        });
+        ui.collapsing("anti afk", |ui| {
+            ui.label(format!(
+                "timer: {}",
+                self.anti_afk.interval.elapsed().as_secs()
+            ));
+            ui.label(format!("can activate: {}", self.anti_afk.can_activate()));
+        });
+        ui.collapsing("system info", |ui| {
+            if ui.button("refresh").clicked() {
+                self.system_info.refresh();
+            }
+            let pid = self
+                .system_info
+                .processes()
+                .iter()
+                .find(|p| p.name() == EXE_ENHANCED || p.name() == EXE_LEGACY)
+                .map_or_else(|| "no pid found!".to_owned(), |p| p.pid().to_string());
+            ui.label(format!("gta pid: {pid}"));
+        });
+        ui.collapsing("app state", |ui| ui.label(format!("{self:#?}")));
+    }
+
+    pub fn show_debug_viewport(&mut self, ctx: &egui::Context) {
+        let main = ctx.input(|i| i.viewport().outer_rect.unwrap_or(egui::Rect::EVERYTHING));
+        let builder = egui::ViewportBuilder::default()
+            .with_title("GTA Tools Debug")
+            .with_minimize_button(false)
+            .with_maximize_button(false)
+            .with_inner_size(WINDOW_SIZE)
+            .with_position([main.right() - 12.0, main.min.y])
+            .with_icon(tools::load_icon());
+        ctx.show_viewport_immediate(
+            egui::ViewportId::from_hash_of("debug_viewport"),
+            builder,
+            |ctx, _class| {
+                if tools::debug_keycombo_pressed(ctx) {
+                    self.flags.debug = !self.flags.debug;
+                }
+                egui::CentralPanel::default().show(ctx, |ui| {
+                    egui::ScrollArea::both()
+                        .auto_shrink([false, true])
+                        .show(ui, |ui| self.add_debug_viewport_contents(ui));
+                });
+            },
+        );
+    }
+}

src/gui/run.rs

@@ -0,0 +1,64 @@
+use crate::{
+    gui::{
+        app::{App, WINDOW_SIZE},
+        tools,
+    },
+    util::{persistent_state::PersistentState, win},
+};
+use eframe::egui;
+
+fn app_creator(
+    cc: &eframe::CreationContext<'_>,
+) -> Result<Box<dyn eframe::App>, Box<dyn std::error::Error + Send + Sync>> {
+    // initialize App early to modify some things before returning it
+    let mut app = Box::new(App::default());
+    // load previously selected launch platform & settings from persistent state
+    if let Some(persistent_state) = PersistentState::get() {
+        app.launch.selected = persistent_state.launcher;
+        app.settings = persistent_state.settings;
+    }
+    // check if we're elevated. if not, and the user wants an elevated launch - relaunch elevated
+    if !app.flags.elevated && app.settings.start_elevated {
+        win::elevate(win::ElevationExitMethod::Forced);
+    }
+    // refresh system info because it initializes with nothing
+    app.system_info.refresh();
+    // enable image loading support in egui
+    egui_extras::install_image_loaders(&cc.egui_ctx);
+    // set our initial theme, from earlier loaded settings. we set the egui theme
+    // to dark here to work around system theme based switching of the egui style
+    cc.egui_ctx.set_theme(egui::Theme::Dark);
+    catppuccin_egui::set_theme(&cc.egui_ctx, app.settings.theme.into());
+    // apply some global styling that we like
+    cc.egui_ctx.all_styles_mut(|style| {
+        style.spacing.item_spacing = egui::vec2(4.0, 4.0);
+        style.interaction.selectable_labels = false;
+        style.visuals.hyperlink_color = catppuccin_egui::Theme::from(app.settings.theme).text;
+    });
+    // load any extra fonts that we need
+    let mut fonts = egui::FontDefinitions::default();
+    fonts.font_data.insert(
+        "Ubuntu-Regular".to_owned(),
+        egui::FontData::from_static(include_bytes!("../../assets/Ubuntu-Regular.ttf")).into(),
+    );
+    fonts.families.insert(
+        egui::FontFamily::Name("Ubuntu-Regular".into()),
+        vec!["Ubuntu-Regular".to_owned()],
+    );
+    cc.egui_ctx.set_fonts(fonts);
+    // finally return the App
+    Ok(app)
+}
+
+pub fn run() {
+    let options = eframe::NativeOptions {
+        viewport: egui::ViewportBuilder::default()
+            .with_resizable(false)
+            .with_maximize_button(false)
+            .with_inner_size(WINDOW_SIZE)
+            .with_icon(tools::load_icon()),
+        centered: true,
+        ..Default::default()
+    };
+    eframe::run_native("GTA Tools", options, Box::new(app_creator)).unwrap();
+}

src/gui/settings.rs

@@ -0,0 +1,50 @@
+use crate::util::win;
+use serde::{Deserialize, Serialize};
+use strum::{Display, EnumIter};
+
+#[derive(Clone, Copy, Debug, Default, Display, PartialEq, Eq, Serialize, Deserialize, EnumIter)]
+pub enum LaunchVersion {
+    #[default]
+    Enhanced,
+    Legacy,
+}
+
+#[derive(Clone, Copy, Debug, Default, Display, PartialEq, Eq, Serialize, Deserialize, EnumIter)]
+pub enum Theme {
+    #[default]
+    #[strum(to_string = "Auto")]
+    Auto,
+    #[strum(to_string = "Catppuccin Latte")]
+    CatppuccinLatte,
+    #[strum(to_string = "Catppuccin Frappe")]
+    CatppuccinFrappe,
+    #[strum(to_string = "Catppuccin Macchiato")]
+    CatppuccinMacchiato,
+    #[strum(to_string = "Catppuccin Mocha")]
+    CatppuccinMocha,
+}
+
+impl From<Theme> for catppuccin_egui::Theme {
+    fn from(val: Theme) -> Self {
+        match val {
+            Theme::Auto => {
+                if win::is_system_theme_dark() {
+                    catppuccin_egui::MOCHA
+                } else {
+                    catppuccin_egui::LATTE
+                }
+            }
+            Theme::CatppuccinLatte => catppuccin_egui::LATTE,
+            Theme::CatppuccinFrappe => catppuccin_egui::FRAPPE,
+            Theme::CatppuccinMacchiato => catppuccin_egui::MACCHIATO,
+            Theme::CatppuccinMocha => catppuccin_egui::MOCHA,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct Settings {
+    pub launch_version: LaunchVersion,
+    pub theme: Theme,
+    pub start_elevated: bool,
+}

src/gui/tools.rs

@@ -0,0 +1,26 @@
+use eframe::egui;
+
+pub fn load_icon() -> egui::IconData {
+    let icon = include_bytes!("../../assets/icon.png");
+    let image = image::load_from_memory(icon).unwrap().into_rgba8();
+    let (width, height) = image.dimensions();
+    egui::IconData {
+        rgba: image.into_raw(),
+        width,
+        height,
+    }
+}
+
+pub fn debug_keycombo_pressed(ctx: &egui::Context) -> bool {
+    ctx.input(|i| i.modifiers.all() && i.key_pressed(egui::Key::D))
+}
+
+pub fn debug_viewport_close_pressed(ctx: &egui::Context) -> bool {
+    ctx.input(|i| {
+        i.raw
+            .viewports
+            .get(&egui::ViewportId::from_hash_of("debug_viewport"))
+            .filter(|vp| vp.close_requested())
+            .is_some()
+    })
+}

src/gui/ui_ext.rs

@@ -0,0 +1,38 @@
+use eframe::egui;
+
+pub trait UiExt {
+    fn header(&mut self, text: &str);
+    fn build_menu<E>(&mut self, current_value: &mut E)
+    where
+        E: strum::IntoEnumIterator + std::fmt::Display + std::cmp::PartialEq + Copy;
+    fn create_indicator_dot(&mut self, colour: impl Into<egui::Color32>) -> egui::Response;
+}
+
+impl UiExt for egui::Ui {
+    fn header(&mut self, text: &str) {
+        self.horizontal(|ui| {
+            ui.label(egui::RichText::new(text).font(egui::FontId::new(
+                12.5,
+                egui::FontFamily::Name("Ubuntu-Regular".into()),
+            )));
+            ui.add(egui::Separator::default().horizontal());
+        });
+    }
+
+    fn build_menu<E>(&mut self, current_value: &mut E)
+    where
+        E: strum::IntoEnumIterator + std::fmt::Display + std::cmp::PartialEq + Copy,
+    {
+        E::iter().for_each(|variant| {
+            self.selectable_value(current_value, variant, variant.to_string());
+        });
+    }
+
+    fn create_indicator_dot(&mut self, colour: impl Into<egui::Color32>) -> egui::Response {
+        self.add(
+            egui::Image::new(egui::include_image!("../../assets/circle.svg"))
+                .max_size([4.0, 4.0].into())
+                .tint(colour),
+        )
+    }
+}

src/main.rs

@@ -1,9 +1,26 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
+#[cfg(not(target_os = "windows"))]
+compile_error!("This application must be compiled for Windows.");
+
 mod features;
 mod gui;
 mod util;
 
+fn init_storage() {
+    if !crate::util::consts::path::APP_STORAGE.exists() {
+        std::fs::create_dir_all(crate::util::consts::path::APP_STORAGE.as_path()).unwrap();
+    }
+}
+
+fn panic_hook(panic_info: &std::panic::PanicHookInfo<'_>) {
+    let backtrace = std::backtrace::Backtrace::capture();
+    let message = format!("{panic_info}\nstack backtrace:\n{backtrace}\n");
+    crate::util::log::log(crate::util::log::LogLevel::Panic, &message);
+}
+
 fn main() {
-    gui::run();
+    init_storage();
+    std::panic::set_hook(Box::new(panic_hook));
+    gui::run::run();
 }

src/util.rs

@@ -1,40 +1,6 @@
-use std::time::{Duration, Instant};
-
-pub struct Countdown {
-    pub i: usize,
-    pub i_original: usize,
-    pub i_string: String,
-    pub interval: Instant,
-    pub first_count: bool,
-}
-
-impl Countdown {
-    pub fn new(i: usize) -> Self {
-        Self {
-            i,
-            i_original: i,
-            i_string: String::new(),
-            interval: Instant::now(),
-            first_count: true,
-        }
-    }
-
-    pub fn reset(&mut self) {
-        *self = Self::new(self.i_original);
-    }
-
-    pub fn count(&mut self) {
-        if self.first_count {
-            self.interval = Instant::now();
-            self.first_count = false;
-        }
-        if self.interval.elapsed() >= Duration::from_secs(1) {
-            self.i -= 1;
-            self.interval = Instant::now();
-        }
-        self.i_string = self.i.to_string();
-        if self.i == 0 {
-            self.reset();
-        };
-    }
-}
+pub mod consts;
+pub mod countdown;
+pub mod log;
+pub mod persistent_state;
+pub mod system_info;
+pub mod win;

src/util/consts.rs

@@ -0,0 +1,15 @@
+pub mod path {
+    use std::{env, path::PathBuf, sync::LazyLock};
+    pub static APP_STORAGE: LazyLock<PathBuf> = LazyLock::new(|| {
+        PathBuf::from(env::var("LOCALAPPDATA").unwrap_or_else(|_| String::from(".")))
+            .join("GTA Tools")
+    });
+    pub static APP_CONFIG: LazyLock<PathBuf> = LazyLock::new(|| APP_STORAGE.join("config.json"));
+    pub static APP_LOG: LazyLock<PathBuf> = LazyLock::new(|| APP_STORAGE.join("gta-tools.log"));
+}
+
+pub mod game {
+    pub const EXE_ENHANCED: &str = "GTA5_Enhanced.exe";
+    pub const EXE_LEGACY: &str = "GTA5.exe";
+    pub const WINDOW_TITLE: &str = "Grand Theft Auto V";
+}

src/util/countdown.rs

@@ -0,0 +1,41 @@
+use std::time::{Duration, Instant};
+
+#[derive(Debug)]
+pub struct Countdown {
+    i: u64,
+    i_original: u64,
+    pub i_string: String,
+    interval: Instant,
+    first_count: bool,
+}
+
+impl Countdown {
+    pub fn new(i: u64) -> Self {
+        Self {
+            i,
+            i_original: i,
+            i_string: String::new(),
+            interval: Instant::now(),
+            first_count: true,
+        }
+    }
+
+    pub fn reset(&mut self) {
+        *self = Self::new(self.i_original);
+    }
+
+    pub fn count(&mut self) {
+        if self.first_count {
+            self.interval = Instant::now();
+            self.first_count = false;
+        }
+        if self.interval.elapsed() >= Duration::from_secs(1) {
+            self.i -= 1;
+            self.interval = Instant::now();
+        }
+        self.i_string = self.i.to_string();
+        if self.i == 0 {
+            self.reset();
+        }
+    }
+}

src/util/log.rs

@@ -0,0 +1,20 @@
+use crate::util::consts::path;
+use std::{fs::File, io::Write};
+use strum::Display;
+
+#[derive(Clone, Copy, Display)]
+pub enum LogLevel {
+    Error,
+    Panic,
+}
+
+pub fn log(level: LogLevel, message: &str) {
+    let mut file = File::options()
+        .create(true)
+        .append(true)
+        .open(path::APP_LOG.as_path())
+        .unwrap();
+    let timestamp = chrono::Local::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, false);
+    let message = format!("[{timestamp}] [{level}]\n{message}\n\n");
+    file.write_all(message.as_bytes()).unwrap();
+}

src/util/persistent_state.rs

@@ -0,0 +1,26 @@
+use crate::{features::launch::Platform, gui::settings::Settings, util::consts::path};
+use serde::{Deserialize, Serialize};
+use std::{
+    fs::{self, File},
+    io::Write,
+};
+
+#[derive(Serialize, Deserialize)]
+pub struct PersistentState {
+    pub launcher: Platform,
+    pub settings: Settings,
+}
+
+impl PersistentState {
+    pub fn get() -> Option<Self> {
+        fs::read_to_string(path::APP_CONFIG.as_path())
+            .ok()
+            .and_then(|config| serde_json::from_str::<Self>(&config).ok())
+    }
+
+    pub fn set(&self) {
+        let mut config_file = File::create(path::APP_CONFIG.as_path()).unwrap();
+        let json = serde_json::to_string_pretty(&self).unwrap();
+        config_file.write_all(json.as_bytes()).unwrap();
+    }
+}

src/util/system_info.rs

@@ -0,0 +1,117 @@
+use std::{
+    ffi::{OsStr, OsString},
+    os::windows::{ffi::OsStringExt, process::CommandExt},
+    path::{Path, PathBuf},
+    process::Command,
+};
+use windows::{
+    Win32::System::{
+        Diagnostics::ToolHelp::{
+            CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW,
+            TH32CS_SNAPPROCESS,
+        },
+        Threading::{
+            CREATE_NO_WINDOW, OpenProcess, PROCESS_NAME_WIN32, PROCESS_QUERY_LIMITED_INFORMATION,
+            QueryFullProcessImageNameW,
+        },
+    },
+    core::PWSTR,
+};
+
+#[derive(Clone, Debug)]
+pub struct Process {
+    pid: u32,
+    name: OsString,
+    exe: Option<PathBuf>,
+}
+
+impl Process {
+    pub fn pid(&self) -> u32 {
+        self.pid
+    }
+
+    pub fn name(&self) -> &OsStr {
+        &self.name
+    }
+
+    pub fn exe(&self) -> Option<&Path> {
+        self.exe.as_deref()
+    }
+
+    pub fn kill(&self) -> bool {
+        let mut taskkill = Command::new("taskkill.exe");
+        taskkill.creation_flags(CREATE_NO_WINDOW.0);
+        taskkill.arg("/F").arg("/PID").arg(self.pid.to_string());
+        match taskkill.output() {
+            Ok(output) => output.status.success(),
+            Err(_) => false,
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct SystemInfo {
+    processes: Vec<Process>,
+}
+
+impl SystemInfo {
+    pub fn refresh(&mut self) {
+        let mut processes = Vec::new();
+        let snapshot_handle = unsafe { CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) }.unwrap();
+        let mut process_entry = PROCESSENTRY32W {
+            dwSize: size_of::<PROCESSENTRY32W>() as u32,
+            ..Default::default()
+        };
+        unsafe { Process32FirstW(snapshot_handle, &raw mut process_entry) }.unwrap();
+        let exe_full_path = get_exe_full_path(&process_entry);
+        processes.push(Process {
+            pid: process_entry.th32ProcessID,
+            name: wide_array_to_os_string(&process_entry.szExeFile),
+            exe: exe_full_path,
+        });
+        while unsafe { Process32NextW(snapshot_handle, &raw mut process_entry) }.is_ok() {
+            let exe_full_path = get_exe_full_path(&process_entry);
+            processes.push(Process {
+                pid: process_entry.th32ProcessID,
+                name: wide_array_to_os_string(&process_entry.szExeFile),
+                exe: exe_full_path,
+            });
+        }
+        self.processes = processes;
+    }
+
+    pub fn processes(&self) -> &[Process] {
+        &self.processes
+    }
+}
+
+fn get_exe_full_path(process_entry: &PROCESSENTRY32W) -> Option<PathBuf> {
+    let process_handle_result = unsafe {
+        OpenProcess(
+            PROCESS_QUERY_LIMITED_INFORMATION,
+            false,
+            process_entry.th32ProcessID,
+        )
+    };
+    process_handle_result.map_or(None, |process_handle| {
+        let mut exe_name = [0u16; 260];
+        let mut dw_size = exe_name.len() as u32;
+        let image_name_result = unsafe {
+            QueryFullProcessImageNameW(
+                process_handle,
+                PROCESS_NAME_WIN32,
+                PWSTR(exe_name.as_mut_ptr()),
+                &raw mut dw_size,
+            )
+        };
+        match image_name_result {
+            Ok(()) => Some(PathBuf::from(wide_array_to_os_string(&exe_name))),
+            Err(_) => None,
+        }
+    })
+}
+
+fn wide_array_to_os_string(wide: &[u16]) -> OsString {
+    let null_pos = wide.iter().position(|&x| x == 0).unwrap_or(wide.len());
+    OsString::from_wide(&wide[..null_pos])
+}

src/util/win.rs

@@ -0,0 +1,95 @@
+use windows::{
+    Win32::{
+        Foundation::{CloseHandle, HANDLE},
+        Security::{GetTokenInformation, TOKEN_ELEVATION, TOKEN_QUERY, TokenElevation},
+        System::Threading::{GetCurrentProcess, OpenProcessToken},
+        UI::{
+            Input::KeyboardAndMouse::{GetAsyncKeyState, VIRTUAL_KEY},
+            Shell::ShellExecuteW,
+            WindowsAndMessaging::{
+                CURSOR_SHOWING, CURSORINFO, GetCursorInfo, GetForegroundWindow, GetWindowTextW,
+                SW_NORMAL,
+            },
+        },
+    },
+    core::{HSTRING, PCWSTR},
+};
+
+pub enum ElevationExitMethod<'a> {
+    Gentle(&'a mut bool),
+    Forced,
+}
+
+pub fn is_cursor_visible() -> bool {
+    let mut ci = CURSORINFO {
+        cbSize: u32::try_from(std::mem::size_of::<CURSORINFO>()).unwrap(),
+        ..Default::default()
+    };
+    unsafe { GetCursorInfo(&raw mut ci) }.unwrap();
+    ci.flags == CURSOR_SHOWING
+}
+
+pub fn is_window_focused(target_title: &str) -> bool {
+    let mut buffer = [0; 512];
+    let hwnd = unsafe { GetForegroundWindow() };
+    let length = unsafe { GetWindowTextW(hwnd, &mut buffer) };
+    let current_title = String::from_utf16_lossy(&buffer[..length as usize]);
+    current_title == target_title
+}
+
+pub fn is_any_key_pressed(keys: &[VIRTUAL_KEY]) -> bool {
+    keys.iter()
+        .any(|&key| unsafe { GetAsyncKeyState(i32::from(key.0)) } & i16::MIN != 0)
+}
+
+pub fn elevate(closing: ElevationExitMethod) {
+    let exe = std::env::current_exe().unwrap();
+    unsafe {
+        ShellExecuteW(
+            None,
+            &HSTRING::from("runas"),
+            &HSTRING::from(exe.as_path()),
+            PCWSTR::null(),
+            PCWSTR::null(),
+            SW_NORMAL,
+        );
+    }
+    match closing {
+        ElevationExitMethod::Gentle(closing) => *closing = true,
+        ElevationExitMethod::Forced => std::process::exit(0),
+    }
+}
+
+pub fn is_elevated() -> bool {
+    let mut token: HANDLE = HANDLE::default();
+    if unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &raw mut token) }.is_err() {
+        return false;
+    }
+    let mut elevation = TOKEN_ELEVATION::default();
+    let mut size = u32::try_from(std::mem::size_of::<TOKEN_ELEVATION>()).unwrap();
+    let result = unsafe {
+        GetTokenInformation(
+            token,
+            TokenElevation,
+            Some((&raw mut elevation).cast()),
+            size,
+            &raw mut size,
+        )
+    };
+    unsafe { CloseHandle(token) }.unwrap();
+    result.is_ok() && elevation.TokenIsElevated != 0
+}
+
+pub fn is_system_theme_dark() -> bool {
+    use winreg::RegKey;
+    let hkcu = RegKey::predef(winreg::enums::HKEY_CURRENT_USER);
+    let Ok(subkey) =
+        hkcu.open_subkey("Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize")
+    else {
+        return true;
+    };
+    let Ok(dword): Result<u32, std::io::Error> = subkey.get_value("AppsUseLightTheme") else {
+        return true;
+    };
+    dword != 1
+}