feat: add gui

Author: VolcanoCookies

Cargo.lock

@@ -9,6 +9,8 @@ edition = "2021"
 axum = "0.7.1"
 axum-macros = "0.4.0"
 config-file = "0.2.3"
+eframe = "0.24.1"
+egui = "0.24.1"
 log = "0.4.20"
 rand = "0.8.5"
 reqwest = { version = "0.11.22", features = ["json"] }

Cargo.toml

@@ -0,0 +1,12 @@
+{
+  "shock_mode": "LastHitPercentage",
+  "min_duration": 5,
+  "max_duration": 15,
+  "min_intensity": 15,
+  "max_intensity": 83,
+  "beep_on_match_start": false,
+  "beep_on_round_start": true,
+  "username": "test",
+  "code": "somesharecode",
+  "apikey": "1349390485"
+}

assets/icon.png

@@ -0,0 +1,149 @@
+use std::sync::Arc;
+
+use axum::{extract::State, http::StatusCode, routing::post, Json, Router};
+use log::info;
+use rand::{rngs::StdRng, Rng, SeedableRng};
+use tokio::sync::{Mutex, RwLock};
+
+use crate::{
+    config::{self, Config},
+    gamestateintegration::{MapPhase, Payload, RoundPhase},
+    pishock, AppState, GameState, PlayerState,
+};
+
+pub async fn run(config: Arc<RwLock<Config>>) {
+    info!("Sending test beep");
+    pishock::beep(config.clone(), 1).await;
+
+    let state = AppState {
+        game_state: Arc::from(Mutex::from(GameState::default())),
+        config: config.clone(),
+    };
+
+    let app = Router::new()
+        .route("/data", post(read_data))
+        .with_state(state);
+
+    info!("Starting server on {}", "127.0.0.1:3000");
+
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
+        .await
+        .unwrap();
+    axum::serve(listener, app).await.unwrap();
+}
+
+async fn read_data(State(state): State<AppState>, Json(payload): Json<Payload>) -> StatusCode {
+    let mut game_state = state.game_state.lock().await;
+    let config = state.config.read().await;
+
+    if let Some(provider) = payload.provider {
+        game_state.steam_id = provider.steamid;
+    }
+
+    if let Some(map) = payload.map {
+        if game_state.map_phase == MapPhase::Warmup && map.phase == MapPhase::Live {
+            info!("Match started");
+
+            if config.beep_on_match_start {
+                pishock::beep(state.config.clone(), 2).await;
+            }
+
+            // Reset game state to default
+            game_state.reset();
+        }
+
+        game_state.map_phase = map.phase;
+    }
+
+    if let Some(round) = payload.round {
+        if game_state.round_phase == RoundPhase::Freezetime && round.phase == RoundPhase::Live {
+            if config.beep_on_round_start {
+                info!("Round started");
+                pishock::beep(state.config.clone(), 1).await;
+            }
+        }
+
+        game_state.round_phase = round.phase;
+    }
+
+    if game_state.map_phase != MapPhase::Live {
+        return StatusCode::OK;
+    }
+
+    if let Some(player) = payload.player {
+        if player.steamid != game_state.steam_id {
+            return StatusCode::OK;
+        }
+
+        if let Some(player_state) = &mut game_state.player_state {
+            if player_state.health > player.state.health && player.state.health > 0 {
+                // Took damage and survived
+
+                /*
+                println!("Player took damage, vibrating");
+
+                let diff = player_state.health - player.state.health;
+
+                let res = pishock::post(
+                    &config,
+                    pishock::PiShockOp::Vibrate {
+                        intensity: diff,
+                        duration: 1,
+                    },
+                )
+                .await;
+
+                match res {
+                    Ok(code) => println!("Vibrated with code {}", code),
+                    Err(e) => println!("Error while vibrating: {}", e),
+                };
+                 */
+            }
+
+            if player.match_stats.deaths > player_state.deaths {
+                // Died
+
+                // Github Copilot is based
+                // let res = pishock::post(&api_state, pishock::PiShockOp::Shock { intensity: 100, duration: 1 }).await;
+
+                info!("Player died, shocking");
+
+                match config.shock_mode {
+                    config::ShockMode::Random => {
+                        let mut rng = StdRng::from_entropy();
+                        let intensity = rng.gen_range(config.min_intensity..=config.max_intensity);
+                        let duration = rng.gen_range(config.min_duration..=config.max_duration);
+
+                        pishock::shock(state.config.clone(), intensity, duration).await;
+                    }
+                    config::ShockMode::LastHitPercentage => {
+                        let intensity = (player_state.health as f32 / 100.0
+                            * config.max_intensity as f32)
+                            as i32;
+                        let duration = (player_state.health as f32 / 100.0
+                            * config.max_duration as f32)
+                            as i32;
+
+                        pishock::shock(state.config.clone(), intensity, duration).await;
+                    }
+                };
+            }
+
+            player_state.health = player.state.health;
+            player_state.armor = player.state.armor;
+            player_state.kills = player.match_stats.kills;
+            player_state.deaths = player.match_stats.deaths;
+        } else {
+            println!("Player state initialized");
+
+            game_state.player_state = Some(PlayerState {
+                health: player.state.health,
+                armor: player.state.armor,
+                kills: player.match_stats.kills,
+                deaths: player.match_stats.deaths,
+            });
+        }
+    }
+
+    StatusCode::OK
+}

config.json

@@ -1,16 +1,15 @@
 use std::{fs::OpenOptions, io::Write};
 
 use log::error;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
-#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Eq)]
 pub enum ShockMode {
     Random,
     LastHitPercentage,
 }
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Deserialize, Serialize, Debug, Clone, Eq, PartialEq)]
 pub struct Config {
     pub shock_mode: ShockMode,
     pub min_duration: i32,
@@ -79,42 +78,13 @@ impl Config {
         let mut file = OpenOptions::new()
             .create(true)
             .write(true)
+            .truncate(true)
             .open(path)
             .expect(format!("Failed to open config file, {}", path).as_str());
 
-        let raw = format!(
-            "# Shock mode, one of; random, last_hit_percentage
-shock_mode = \"random\"
-# Minimum duration of the shock
-min_duration = {}
-# Maximum duration of the shock
-max_duration = {}
-# Minimum intensity of the shock, 1-100
-min_intensity = {}
-# Maximum intensity of the shock, 1-100
-max_intensity = {}
-# Beep when match starts
-beep_on_match_start = {}
-# Beep when round starts
-beep_on_round_start = {}
-# PiShock username to access the api
-username = \"{}\"
-# PiShock share code to access the api
-code = \"{}\"
-# PiShock api key to access the api
-apikey = \"{}\"",
-            self.min_duration,
-            self.max_duration,
-            self.min_intensity,
-            self.max_intensity,
-            self.beep_on_match_start,
-            self.beep_on_round_start,
-            self.username,
-            self.code,
-            self.apikey
-        );
+        let json = serde_json::to_string_pretty(self).expect("Failed to serialize config");
 
-        file.write_all(raw.as_bytes())
+        file.write_all(json.as_bytes())
             .expect("Failed to write config file");
     }
 }