Merge branch 'pull_62'

.gitignore

@@ -1,3 +1,4 @@
 **/target/
 _*
 .vscode
+.idea

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

@@ -20,6 +20,7 @@ use cs2_schema_generated::cs2::client::{
     CModelState,
     CSkeletonInstance,
     C_CSPlayerPawn,
+    CCSPlayer_ItemServices
 };
 use obfstr::obfstr;
 
@@ -38,6 +39,7 @@ pub struct PlayerInfo {
     pub team_id: u8,
 
     pub player_health: i32,
+    pub player_has_defuser: bool,
     pub player_name: String,
     pub weapon: WeaponId,
 
@@ -145,6 +147,12 @@ impl PlayerESP {
             "unknown".to_string()
         };
 
+
+        let player_has_defuser = player_pawn.m_pItemServices()?
+            .cast::<CCSPlayer_ItemServices>()
+            .reference_schema()?
+            .m_bHasDefuser()?;
+
         let position =
             nalgebra::Vector3::<f32>::from_column_slice(&game_screen_node.m_vecAbsOrigin()?);
 
@@ -178,6 +186,7 @@ impl PlayerESP {
             team_id: player_team,
 
             player_name,
+            player_has_defuser,
             player_health,
             weapon: WeaponId::from_id(weapon_type).unwrap_or(WeaponId::Unknown),
 
@@ -414,7 +423,7 @@ impl Enhancement for PlayerESP {
                 }
             }
 
-            if settings.esp_info_weapon {
+            if 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;
@@ -434,6 +443,30 @@ impl Enhancement for PlayerESP {
                         y_offset += ui.text_line_height_with_spacing() * target_scale;
                     }
 
+                    if settings.esp_info_weapon {
+                        let text = entry.weapon.display_name();
+                        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;
+                    }
+
+                    if entry.player_has_defuser && settings.esp_info_kit {
+                        let text = "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,192 @@
+use std::{
+    ffi::CStr,
+};
+
+use anyhow::Context;
+use cs2::CEntityIdentityEx;
+use obfstr::obfstr;
+use cs2_schema_generated::cs2::client::{
+    C_CSObserverPawn,
+    C_CSPlayerPawnBase
+};
+
+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 actual_entity_index = if local_player_controller.m_bPawnIsAlive()?
+        {
+            local_player_controller.m_hOriginalControllerOfCurrentPawn()?.get_entity_index()
+        } else {
+            let local_obs_pawn = match {
+                ctx.cs2_entities
+                    .get_by_handle(&local_player_controller.m_hObserverPawn()?)?
+            } {
+                Some(pawn) => pawn.entity()?.reference_schema()?,
+                None => {
+                    /* this is odd... */
+                    return Ok(());
+                }
+            };
+
+            let local_observer_target_handle = local_obs_pawn
+                .m_pObserverServices()?
+                .read_schema()?
+                .m_hObserverTarget()?;
+
+            let current_local_observer_target = ctx.cs2_entities.get_by_handle(&local_observer_target_handle)?;
+
+            let local_observer_target_pawn = if let Some(identity) = &current_local_observer_target
+            {
+                identity
+                    .entity()?
+                    .cast::<C_CSPlayerPawnBase>()
+                    .try_reference_schema()
+                    .with_context(|| obfstr!("failed to read local observer target pawn").to_string())?
+            } else {
+                return Ok(());
+            };
+
+            let local_observed_controller = match local_observer_target_pawn{
+                Some(controller) => controller.m_hController()?,
+                None => {
+                    /* We have no target to spectate */
+                    return Ok(());
+                }
+            };
+
+            local_observed_controller.get_entity_index()
+        };
+
+        for entity_identity in ctx.cs2_entities.all_identities() {
+            let entity_class = ctx
+                .class_name_cache
+                .lookup(&entity_identity.entity_class_info()?)?;
+
+            if !entity_class
+                .map(|name| *name == "C_CSObserverPawn")
+                .unwrap_or(false)
+            {
+                /* entity is not a player pawn */
+                continue;
+            }
+
+            let player_pawn_ptr = entity_identity.entity_ptr::<C_CSObserverPawn>()?;
+            let player_pawn = player_pawn_ptr.read_schema()?;
+            let player_controller_handle = player_pawn.m_hController()?;
+
+            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_observer_target = ctx.cs2_entities.get_by_handle(&observer_target_handle)?;
+
+            let observer_target_pawn = if let Some(identity) = &current_observer_target
+            {
+                identity.entity()?.cast::<C_CSPlayerPawnBase>().reference_schema()?
+            } else {
+                continue;
+            };
+
+            let target_controller_handle = observer_target_pawn.m_hController()?;
+
+            if target_controller_handle.get_entity_index() != actual_entity_index {
+                continue;
+            }
+
+            let current_player_controller = ctx.cs2_entities.get_by_handle(&player_controller_handle)?;
+
+            let player_controller = if let Some(identity) = &current_player_controller
+            {
+                identity.entity()?.reference_schema()?
+            } else {
+                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

@@ -98,12 +98,18 @@ pub struct AppSettings {
     #[serde(default = "bool_false")]
     pub esp_health_bar_rainbow: 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

@@ -113,6 +113,7 @@ impl SettingsUI {
                                     .build(&mut settings.esp_skeleton_thickness);
                             }
 
+                            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);
@@ -142,6 +143,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")) {
@@ -172,7 +174,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);
                     }