Local player spectator list. Defuse kit identificator.

controller/src/enhancements/mod.rs

@@ -23,6 +23,9 @@ pub use player::*;
 mod trigger;
 pub use trigger::*;
 
+mod spectators_list;
+pub use spectators_list::*;
+
 mod aim;
 pub use aim::*;
 

controller/src/enhancements/player.rs

@@ -38,6 +38,7 @@ pub struct PlayerInfo {
     pub team_id: u8,
 
     pub player_health: i32,
+    pub player_has_defuser: bool,
     pub player_name: String,
     pub weapon: WeaponId,
 
@@ -130,11 +131,11 @@ impl PlayerESP {
             return Ok(None);
         }
 
-        let controller_handle = player_pawn.m_hController()?;
-        let current_controller = ctx.cs2_entities.get_by_handle(&controller_handle)?;
+        let player_controller_handle = player_pawn.m_hOriginalController()?;
+        let player_current_controller = ctx.cs2_entities.get_by_handle(&player_controller_handle)?;
 
         let player_team = player_pawn.m_iTeamNum()?;
-        let player_name = if let Some(identity) = &current_controller {
+        let player_name = if let Some(identity) = &player_current_controller {
             let player_controller = identity.entity()?.reference_schema()?;
             CStr::from_bytes_until_nul(&player_controller.m_iszPlayerName()?)
                 .context("player name missing nul terminator")?
@@ -145,6 +146,13 @@ impl PlayerESP {
             "unknown".to_string()
         };
 
+        let player_has_defuser = if let Some(identity) = &player_current_controller {
+            let player_controller = identity.entity()?.reference_schema()?;
+            player_controller.m_bPawnHasDefuser()?
+        } else {
+            false
+        };
+
         let position =
             nalgebra::Vector3::<f32>::from_column_slice(&game_screen_node.m_vecAbsOrigin()?);
 
@@ -174,10 +182,11 @@ impl PlayerESP {
         };
 
         Ok(Some(PlayerInfo {
-            controller_entity_id: controller_handle.get_entity_index(),
+            controller_entity_id: player_controller_handle.get_entity_index(),
             team_id: player_team,
 
             player_name,
+            player_has_defuser,
             player_health,
             weapon: WeaponId::from_id(weapon_type).unwrap_or(WeaponId::Unknown),
 
@@ -363,7 +372,7 @@ impl Enhancement for PlayerESP {
                 }
             }
 
-            if settings.esp_info_health || settings.esp_info_weapon {
+            if settings.esp_info_health || settings.esp_info_weapon || settings.esp_info_kit {
                 if let Some(pos) = view.world_to_screen(&entry.position, false) {
                     let entry_height = entry.calculate_screen_height(view).unwrap_or(100.0);
                     let target_scale = entry_height * 15.0 / view.screen_bounds.y;
@@ -393,7 +402,18 @@ impl Enhancement for PlayerESP {
 
                         draw.add_text(pos, esp_color.clone(), text);
 
-                        // y_offset += ui.text_line_height_with_spacing() * target_scale;
+                        y_offset += ui.text_line_height_with_spacing() * target_scale;
+                    }
+
+                    if entry.player_has_defuser && settings.esp_info_kit {
+                        let text = format!("KIT");
+                        let [text_width, _] = ui.calc_text_size(&text);
+                        let mut pos = pos.clone();
+                        pos.x -= text_width / 2.0;
+                        pos.y += y_offset;
+                        draw.add_text(pos, esp_color.clone(),text);
+
+                        //y_offset += ui.text_line_height_with_spacing() * target_scale;
                     }
 
                     ui.set_window_font_scale(1.0);

controller/src/enhancements/spectators_list.rs

@@ -0,0 +1,166 @@
+use std::{
+    ffi::CStr,
+};
+
+use anyhow::Context;
+use cs2::CEntityIdentityEx;
+use obfstr::obfstr;
+use cs2_schema_generated::cs2::client::{
+    CCSPlayerController,
+    C_CSObserverPawn,
+};
+
+use super::Enhancement;
+
+pub struct SpectatorInfo {
+    pub spectator_name: String,
+}
+
+pub struct SpectatorsList {
+    spectators: Vec<SpectatorInfo>
+}
+
+impl SpectatorsList {
+    pub fn new() -> Self {
+        SpectatorsList{
+            spectators: Default::default(),
+        }
+    }
+}
+
+impl Enhancement for SpectatorsList {
+    fn update(&mut self, ctx: &crate::UpdateContext) -> anyhow::Result<()> {
+        self.spectators.clear();
+
+        if !ctx.settings.spectators_list {
+            return Ok(());
+        }
+
+        let local_player_controller = ctx
+            .cs2_entities
+            .get_local_player_controller()?
+            .try_reference_schema()
+            .with_context(|| obfstr!("failed to read local player controller").to_string())?;
+
+        let local_player_controller = match local_player_controller {
+            Some(controller) => controller,
+            None => {
+                /* We're currently not connected */
+                return Ok(());
+            }
+        };
+
+        let observice_entity_handle = if local_player_controller.m_bPawnIsAlive()? {
+            local_player_controller.m_hPawn()?.get_entity_index()
+        } else {
+            return Ok(());
+        };
+
+        for entity_identity in ctx.cs2_entities.all_identities() {
+            if entity_identity.handle::<()>()?.get_entity_index() == observice_entity_handle {
+                /* current pawn we control/observe */
+                continue;
+            }
+
+            let entity_class = ctx
+                .class_name_cache
+                .lookup(&entity_identity.entity_class_info()?)?;
+
+            if !entity_class
+                .map(|name| *name == "CCSPlayerController")
+                .unwrap_or(false)
+            {
+                /* entity is not a player pawn */
+                continue;
+            }
+
+            let player_controller_ptr = entity_identity.entity_ptr::<CCSPlayerController>()?;
+            let player_controller = player_controller_ptr.read_schema()?;
+            let player_pawn_handle = player_controller.m_hPawn()?;
+            let current_player_pawn = ctx.cs2_entities.get_by_handle(&player_pawn_handle)?;
+
+            let player_pawn = if let Some(identity) = &current_player_pawn
+            {
+                identity.entity()?.reference_schema()?
+            } else {
+                continue;
+            };
+
+            let observer_services_ptr = player_pawn.m_pObserverServices();
+            let observer_services = observer_services_ptr?
+                .try_reference_schema()
+                .with_context(|| obfstr!("failed to read observer services").to_string())?;
+
+            let observer_target_handle = match observer_services {
+                Some(observer) => observer.m_hObserverTarget()?,
+                None => {
+                    continue;
+                }
+            };
+
+            let current_target = ctx.cs2_entities.get_by_handle(&observer_target_handle)?;
+
+            let observer_target = if let Some(identity) = &current_target
+            {
+                identity.entity()?.cast::<C_CSObserverPawn>().reference_schema()?
+            } else {
+                continue;
+            };
+
+            let target_controller_handle = observer_target.m_hController()?;
+            let target_current_controller = ctx.cs2_entities.get_by_handle(&target_controller_handle)?;
+
+            let target_controller = if let Some(identity) = &target_current_controller
+            {
+                identity.entity()?.reference_schema()?
+            } else {
+                continue;
+            };
+
+            if target_controller.m_hPawn()?.get_entity_index() != observice_entity_handle {
+                continue;
+            }
+
+            let spectator_name = CStr::from_bytes_until_nul(&player_controller.m_iszPlayerName()?)
+                .context("player name missing nul terminator")?
+                .to_str()
+                .context("invalid player name")?
+                .to_string();
+
+            self.spectators.push(SpectatorInfo{
+                spectator_name
+            });
+            continue;
+        }
+
+        Ok(())
+    }
+
+    fn render(
+        &self,
+        settings: &crate::settings::AppSettings,
+        ui: &imgui::Ui,
+        _view: &crate::view::ViewController,
+    ) {
+        if !settings.spectators_list {
+            return;
+        }
+
+        let group = ui.begin_group();
+
+        let line_count = self.spectators.iter().count();
+        let text_height = ui.text_line_height_with_spacing() * line_count as f32;
+
+        let offset_x = ui.io().display_size[0] * 0.01;
+        let offset_y = (ui.io().display_size[1] + text_height) * 0.5;
+        let mut offset_y = offset_y;
+
+        for spectator in self.spectators.iter() {
+            ui.set_cursor_pos([offset_x, offset_y]);
+            ui.text(&format!("{}", spectator.spectator_name));
+            offset_y += ui.text_line_height_with_spacing();
+        };
+
+        group.end();
+    }
+}

controller/src/main.rs

@@ -70,6 +70,7 @@ use crate::{
         BombInfo,
         PlayerESP,
         TriggerBot,
+        SpectatorsList
     },
     settings::save_app_settings,
     view::LocalCrosshair,
@@ -484,6 +485,7 @@ fn main_overlay() -> anyhow::Result<()> {
 
         enhancements: vec![
             Rc::new(RefCell::new(PlayerESP::new())),
+            Rc::new(RefCell::new(SpectatorsList::new())),
             Rc::new(RefCell::new(BombInfo::new())),
             Rc::new(RefCell::new(TriggerBot::new(LocalCrosshair::new(
                 cs2_offsets.offset_crosshair_id,

controller/src/settings/config.rs

@@ -90,12 +90,18 @@ pub struct AppSettings {
     #[serde(default = "bool_false")]
     pub esp_info_health: bool,
 
+    #[serde(default = "bool_false")]
+    pub esp_info_kit: bool,
+
     #[serde(default = "bool_false")]
     pub esp_info_weapon: bool,
 
     #[serde(default = "bool_true")]
     pub bomb_timer: bool,
 
+    #[serde(default = "bool_false")]
+    pub spectators_list: bool,
+
     #[serde(default = "bool_true")]
     pub valthrun_watermark: bool,
 

controller/src/settings/ui.rs

@@ -106,6 +106,7 @@ impl SettingsUI {
                             }
 
                             ui.checkbox(obfstr!("Display player health"), &mut settings.esp_info_health);
+                            ui.checkbox(obfstr!("Display if player has kit"), &mut settings.esp_info_kit);
                             ui.checkbox(obfstr!("Show player weapon"), &mut settings.esp_info_weapon);
 
                             ui.checkbox(obfstr!("ESP Team"), &mut settings.esp_enabled_team);
@@ -135,6 +136,7 @@ impl SettingsUI {
                         }
 
                         ui.checkbox(obfstr!("Bomb Timer"), &mut settings.bomb_timer);
+                        ui.checkbox(obfstr!("Spectators List"), &mut settings.spectators_list);
                     }
 
                     if let Some(_) = ui.tab_item(obfstr!("Aim Assist")) {
@@ -165,7 +167,7 @@ impl SettingsUI {
                             ui.separator();
                         }
 
-                        // ui.checkbox("Simle Recoil Helper", &mut settings.aim_assist_recoil);
+                        //ui.checkbox("Simle Recoil Helper", &mut settings.aim_assist_recoil);
                     }