player connect bugfix

Author: LaihoE

src/parser/src/parse_demo.rs

@@ -94,10 +94,33 @@ impl<'a> Parser<'a> {
         if let Some(new_df) = self.rm_unwanted_ticks(&mut outputs.df) {
             outputs.df = new_df;
         }
+        
+        Parser::remove_duplicate_player_connects(&mut outputs.game_events);
         Parser::add_item_purchase_sell_column(&mut outputs.game_events);
         Parser::remove_item_sold_events(&mut outputs.game_events);
         Ok(outputs)
     }
+    fn remove_duplicate_player_connects(events: &mut Vec<GameEvent>){
+        let mut v = events.iter().filter(|x| x.name == "player_first_connect").collect_vec();
+        v.sort_by_key(|x| x.tick);
+        let mut ids = AHashMap::default();
+        for x in v{
+            for f in &x.fields{
+                if f.name == "steamid"{
+                    if let Some(Variant::U64(s)) = f.data{
+                        match ids.get(&s) {
+                            Some(_) => {},
+                            None => {
+                                ids.insert(s, x.clone());
+                            }
+                        }
+                    }
+                    }
+                }
+            }
+        events.retain(|x|x.name != "player_first_connect");
+        events.extend(ids.values().map(|x| x.clone()));
+    }
 
     fn second_pass_single_threaded(&self, outer_bytes: &[u8], first_pass_output: FirstPassOutput) -> Result<DemoOutput, DemoParserError> {
         let mut parser = SecondPassParser::new(first_pass_output.clone(), 16, true, None)?;

src/parser/src/second_pass/entities.rs

@@ -246,8 +246,8 @@ impl<'a> SecondPassParser<'a> {
                 }
             }
             // Custom events
-            if !is_fullpacket && !is_baseline {
-                events_to_emit.extend(SecondPassParser::listen_for_events(entity, &result, field, field_info, &self.prop_controller, &self.prop_controller.special_ids));
+            if !is_baseline {
+                events_to_emit.extend(SecondPassParser::listen_for_events(entity, &result, field, field_info, &self.prop_controller, &self.prop_controller.special_ids, is_fullpacket));
             }
             // Debug
             if self.is_debug_mode {

src/parser/src/second_pass/game_events.rs

@@ -482,15 +482,15 @@ impl<'a> SecondPassParser<'a> {
                     data: Some(Variant::I32(self.tick)),
                     name: "tick".to_string(),
                 });
+                fields.extend(self.find_non_player_props());
+                let ge = GameEvent {
+                    name: "server_cvar".to_string(),
+                    fields: fields.clone(),
+                    tick: self.tick,
+                };
+                self.game_events.push(ge);
+                self.game_events_counter.insert("server_cvar".to_string());
             }
-            fields.extend(self.find_non_player_props());
-            let ge = GameEvent {
-                name: "server_cvar".to_string(),
-                fields,
-                tick: self.tick,
-            };
-            self.game_events.push(ge);
-            self.game_events_counter.insert("server_cvar".to_string());
         }
         Ok(())
     }
@@ -583,23 +583,24 @@ impl<'a> SecondPassParser<'a> {
                 };
                 if let Some(e) = player_entid {
                     if e != PLAYER_ENTITY_HANDLE_MISSING && steamid != Some(0) && team_num != Some(SPECTATOR_TEAM_NUM) {
-                        if self.players.iter().all(|x| x.1.steamid != steamid){
-                            // println!("{:?} {:?}", steamid, self.players.iter().filter_map(|x| x.1.steamid).collect_vec());
-                            match self.should_remove(steamid) {
-                                Some(eid) => {
-                                    self.players.remove(&eid);
-                                }
-                                None => {}
+                        match self.should_remove(steamid) {
+                            Some(eid) => {
+                                self.players.remove(&eid);
                             }
-                            let p = PlayerMetaData {
-                                name,
-                                team_num,
-                                player_entity_id: player_entid,
-                                steamid,
-                                controller_entid: Some(*entity_id),
-                            };
-                            self.players.insert(e,p.clone());
+                            None => {}
+                        }
+                        let p = PlayerMetaData {
+                            name,
+                            team_num,
+                            player_entity_id: player_entid,
+                            steamid,
+                            controller_entid: Some(*entity_id),
+                        };
+                        if self.players.iter().all(|x| x.1.steamid != steamid){
                             self.create_custom_event_player_connect(&p)?;
+                            self.players.insert(e,p.clone());
+                        }else{
+                            self.players.insert(e,p.clone());
                         }
                     }
                 }
@@ -1171,6 +1172,10 @@ impl<'a> SecondPassParser<'a> {
             data: Some(Variant::String(player_metadata.clone().name.unwrap_or("".to_string()))),
             name: "name".to_string(),
         });
+        fields.push(EventField {
+            data: Some(Variant::I32(player_metadata.controller_entid.unwrap_or(0))),
+            name: "controller_entid".to_string(),
+        });
         let team=  match player_metadata.team_num {
             Some(1) => "spectator",
             Some(2) => "T",
@@ -1420,20 +1425,26 @@ impl<'a> SecondPassParser<'a> {
         _field: &Field,
         field_info: Option<FieldInfo>,
         prop_controller: &PropController,
-        special_ids: &SpecialIDs
+        special_ids: &SpecialIDs,
+        is_fullpacket: bool,
     ) -> Vec<GameEventInfo> {
         // Might want to start splitting this function
         let mut events = vec![];
         if let Some(fi) = field_info {
+
             if entity.entity_type == EntityType::PlayerController{
                 if let Some(f) = field_info{
                     let connect_ids = [special_ids.teamnum,  special_ids.player_name, special_ids.steamid, special_ids.player_pawn];
                     if connect_ids.contains(&Some(f.prop_id)) {
                         events.push(GameEventInfo::PlayerConnect(entity.entity_id));
                     }
                 }
+                if fi.prop_id != 3014{
+                }
+            }
+            if is_fullpacket{
+                return events;
             }
-
             // round end
             if let Some(id) = prop_controller.special_ids.round_end_count {
                 if fi.prop_id == id {