feat(controller): add radar + improve critical error logging

Author: PetrSeifert

controller/examples/mock_radar.rs

@@ -0,0 +1,57 @@
+use std::{
+    sync::mpsc,
+    thread,
+    time::Duration,
+};
+
+use ratatui::text::Line;
+use utils_console::{
+    self,
+    RadarFrame,
+    RadarPoint,
+};
+
+fn main() {
+    // Init logger and channels
+    utils_console::init_logger().expect("logger");
+    let (log_tx, log_rx) = mpsc::channel::<Vec<Line<'static>>>();
+    let (radar_tx, radar_rx) = mpsc::channel::<RadarFrame>();
+
+    // Mock data producer
+    thread::spawn(move || {
+        let mut t: f32 = 0.0;
+        loop {
+            // Log some lines
+            log::info!("[STATUS] Mock radar running");
+            log::info!("Frame t={:.1}", t);
+
+            // Drain logger buffer and forward to TUI
+            let logs = utils_console::get_and_clear_log_lines();
+            let _ = log_tx.send(logs);
+
+            // Create moving points around player within bounds
+            let mut points: Vec<RadarPoint> = Vec::new();
+            for i in 0..20 {
+                let a = t + (i as f32) * 0.31415926;
+                let r = 100.0 + ((i * 47) as f32 % 300.0);
+                let x = r * a.cos();
+                let y = r * a.sin();
+                let dz = (((i as i32) % 21) - 10) * 2;
+                let health = (50 + ((i as i32 * 7 + (t as i32)) % 50)).max(1) as u32;
+                points.push(RadarPoint { x, y, dz, health });
+            }
+
+            let yaw_deg = (t * 30.0) % 360.0;
+            let frame = RadarFrame { yaw_deg, points };
+            let _ = radar_tx.send(frame);
+
+            t += 0.1;
+            thread::sleep(Duration::from_millis(100));
+        }
+    });
+
+    // Run TUI until user quits with 'q'
+    if let Err(e) = utils_console::run_tui(log_rx, radar_rx) {
+        eprintln!("TUI error: {:?}", e);
+    }
+}

controller/src/enhancements/player.rs

@@ -28,7 +28,7 @@ impl PlayerSpyer {
         &self,
         states: &StateRegistry,
         actor_list: &Vec<(u64, Ptr64<dyn AActor>)>,
-        players_data: &mut Vec<(StatePlayerInfo, u32, u32, i32)>,
+        players_data: &mut Vec<(StatePlayerInfo, f32, u32, i32)>,
     ) -> anyhow::Result<()> {
         let decrypt = states.resolve::<StateDecrypt>(())?;
         let pubg_handle = states.resolve::<StatePubgHandle>(())?;
@@ -77,10 +77,13 @@ impl PlayerSpyer {
                 continue;
             }
 
-            let distance = ((player_info.position[0] - local_player_info.location[0]).powi(2)
+            let distance_in_meters = (((player_info.position[0] - local_player_info.location[0])
+                .powi(2)
                 + (player_info.position[1] - local_player_info.location[1]).powi(2)
                 + (player_info.position[2] - local_player_info.location[2]).powi(2))
-            .sqrt() as u32;
+            .sqrt())
+            .round()
+                / 100.0;
 
             let difference = [
                 player_info.position[0] - local_player_info.location[0],
@@ -106,7 +109,7 @@ impl PlayerSpyer {
                 angle_diff as i32
             };
 
-            players_data.push((player_info.clone(), distance, team_id, angle_diff));
+            players_data.push((player_info.clone(), distance_in_meters, team_id, angle_diff));
         }
         Ok(())
     }
@@ -115,8 +118,9 @@ impl PlayerSpyer {
 impl Enhancement for PlayerSpyer {
     fn update(&mut self, ctx: &crate::UpdateContext) -> anyhow::Result<()> {
         let actor_lists = ctx.states.resolve::<StateActorLists>(())?;
+        let local_player_info = ctx.states.resolve::<StateLocalPlayerInfo>(())?;
 
-        let mut players_data: Vec<(StatePlayerInfo, u32, u32, i32)> = Vec::new();
+        let mut players_data: Vec<(StatePlayerInfo, f32, u32, i32)> = Vec::new();
 
         let cached_actors = actor_lists.cached_actors();
         for (_actor_id, actor_list) in cached_actors {
@@ -134,16 +138,39 @@ impl Enhancement for PlayerSpyer {
 
         players_data.dedup_by(|a, b| a.1 == b.1);
 
+        // Prepare radar frame points (keep logs as well)
+        let mut radar_points: Vec<utils_console::RadarPoint> = Vec::new();
+
         for (player_info, distance, team_id, angle) in players_data {
             log::info!(
-                "Distance: {} Health: {} Angle: {} Team: {}",
+                "Distance: {}m Health: {} Angle: {} Team: {}",
                 distance,
                 player_info.health,
                 angle,
                 team_id
             );
+
+            // Convert to horizontal x/y in meters relative to local player
+            let dx = (player_info.position[0] - local_player_info.location[0]) as f32 / 100.0;
+            let dy = (player_info.position[1] - local_player_info.location[1]) as f32 / 100.0;
+            let dz =
+                ((player_info.position[2] - local_player_info.location[2]) / 100.0).round() as i32;
+            radar_points.push(utils_console::RadarPoint {
+                x: dx,
+                y: dy,
+                dz,
+                health: player_info.health,
+            });
         }
 
+        // Send radar frame
+        let yaw_deg = local_player_info.rotation[1];
+        let frame = utils_console::RadarFrame {
+            yaw_deg,
+            points: radar_points,
+        };
+        let _ = ctx.radar_tx.send(frame);
+
         Ok(())
     }
 }

controller/src/main.rs

@@ -32,6 +32,7 @@ mod enhancements;
 
 pub struct UpdateContext<'a> {
     pub states: &'a StateRegistry,
+    pub radar_tx: std::sync::mpsc::Sender<utils_console::RadarFrame>,
 }
 
 pub struct Application {
@@ -41,6 +42,7 @@ pub struct Application {
     pub enhancements: Vec<Rc<RefCell<dyn Enhancement>>>,
 
     pub frame_read_calls: usize,
+    pub radar_tx: std::sync::mpsc::Sender<utils_console::RadarFrame>,
 }
 
 impl Application {
@@ -49,6 +51,7 @@ impl Application {
 
         let update_context = UpdateContext {
             states: &self.states,
+            radar_tx: self.radar_tx.clone(),
         };
 
         for enhancement in &self.enhancements {
@@ -81,14 +84,15 @@ fn main() {
     }
 
     let (log_sender, log_receiver) = mpsc::channel::<Vec<Line<'static>>>();
+    let (radar_sender, radar_receiver) = mpsc::channel::<utils_console::RadarFrame>();
 
     let app_thread_handle = thread::spawn(move || {
-        if let Err(err) = app_logic_thread(log_sender) {
+        if let Err(err) = app_logic_thread(log_sender, radar_sender) {
             log::error!("Critical error in app logic thread: {:#}", err);
         }
     });
 
-    if let Err(e) = utils_console::run_tui(log_receiver) {
+    if let Err(e) = utils_console::run_tui(log_receiver, radar_receiver) {
         log::error!("TUI exited with an error: {:?}", e);
     }
 
@@ -99,7 +103,10 @@ fn main() {
     log::info!("Application terminated.");
 }
 
-fn app_logic_thread(log_sender: mpsc::Sender<Vec<Line<'static>>>) -> anyhow::Result<()> {
+fn app_logic_thread(
+    log_sender: mpsc::Sender<Vec<Line<'static>>>,
+    radar_sender: mpsc::Sender<utils_console::RadarFrame>,
+) -> anyhow::Result<()> {
     let os_info = get_os_info()?;
 
     let platform_info = if os_info.is_windows {
@@ -155,6 +162,7 @@ fn app_logic_thread(log_sender: mpsc::Sender<Vec<Line<'static>>>) -> anyhow::Res
         pubg: pubg.clone(),
         enhancements: vec![Rc::new(RefCell::new(PlayerSpyer {}))],
         frame_read_calls: 0,
+        radar_tx: radar_sender.clone(),
     };
     let app = Rc::new(RefCell::new(app));
 

utils/console/src/lib.rs

@@ -11,4 +11,8 @@ pub use logger::{
 };
 
 mod tui;
-pub use tui::run_tui;
+pub use tui::{
+    run_tui,
+    RadarFrame,
+    RadarPoint,
+};