add many command like objectif command, ultimate command etc...

Author: Zat-Code

src/log_analyser/log_analyser.py

@@ -1,3 +1,4 @@
+import os
 from datetime import datetime, timedelta
 from objects.match import Match
 
@@ -7,23 +8,13 @@ class LogAnalyser:
     def __init__(self, path_csv, name) -> None:
 
         self.path_csv = path_csv
-        self.name = "Log-2023-12-22-21-12-32.txt"
+        self.name = name
 
         self.date = self.name2datetime()
 
         self.match = None
 
-        self.actions = {"match_start": self.process_match_start,
-                        "round_start": self.process_round_start,
-                        "hero_spawn": self.process_hero_spawn,
-                        "hero_swap": self.process_hero_swap,
-                        "kill": self.process_kill,
-                        "ultimate_charged": self.process_ultimate_charged,
-                        "ultimate_start": self.process_ultimate_start,
-                        "ultimate_end": self.process_ultimate_end,
-                        "objective_captured": self.process_objective_captured,
-                        "player_stat": self.process_player_stat
-                        }
+        self.actions = {"match_start": self.process_match_start}
 
     def run(self):
 
@@ -38,7 +29,8 @@ def run(self):
                     if type in self.actions:
                         self.actions[type](line_split)
 
-        self.match.export_json()
+        with open("../logs_process/{}.json".format(self.name.split(".")[0]), "w") as file:
+            file.write(self.match.export_json())
 
 
     def name2datetime(self):
@@ -48,49 +40,42 @@ def name2datetime(self):
 
         return date_object
 
-    def process_kill(self, data):
-        self.match.add_kill(data)
-
-    def process_player_stat(self, data):
-        self.match.add_player_stat(data)
-
-    def process_objective_captured(self, data):
-        pass
-        # self.match.add_objective_captured(data)
-
-    def process_ultimate_start(self, data):
-        pass
-
-    def process_ultimate_end(self, data):
-        pass
-    
-    def process_ultimate_charged(self, data):
-        pass
-    
-    def process_round_start(self, data):
-        
-        self.match.add_round(data)
-        # self.match.export_json()
-    
     def process_match_start(self, data):
 
         self.match = Match.from_json({"rounds": [], 
                        "date": self.date,
                        "map_name": data[3],
                        "map_type": data[4],
                        "team1_name": data[5],
-                       "team2_name": data[6]
+                       "team2_name": data[6],
+                       "score_team1": 0,
+                       "score_team2": 0,
                        })
 
+        self.actions = {"match_start": self.process_match_start,
+                        "round_start": self.match.add_round,
+                        "round_end": self.match.end_round,
+                        "hero_spawn": self.process_hero_spawn,
+                        "hero_swap": self.process_hero_swap,
+                        "kill": self.match.add_kill,
+                        "ultimate_charged": self.match.add_ultimate_charged,
+                        "ultimate_start": self.match.add_ultimate_start,
+                        "ultimate_end": self.match.add_ultimate_end,
+                        "objective_captured": self.match.add_objective_captured,
+                        "player_stat": self.match.add_player_stat,
+                        "point_progress": self.match.add_objective_progress,
+                        "payload_progress": self.match.add_objective_progress,
+                        }
+
     def process_hero_spawn(self, data):
 
-        player_data = {"time": data[0], "team_name": data[3], "player_name": data[4], "character_name": data[5]}
+        player_data = {"time": data[2], "team_name": data[3], "player_name": data[4], "character_name": data[5]}
         self.match.add_player(player_data)
 
     def process_hero_swap(self, data):
 
-        hero_data = {"time": data[0], "team_name": data[3], "player_name": data[4], "character_name": data[5]}
-        self.match.add_player(hero_data)
+        hero_data = {"time": data[2], "team_name": data[3], "player_name": data[4], "character_name": data[5], "character_swap": data[6]}
+        self.match.add_hero_swap(hero_data)
 
     def convert_timefile_to_datetime(self, time_string):
 
@@ -102,5 +87,11 @@ def convert_timefile_to_datetime(self, time_string):
         return duration
 
 
-la = LogAnalyser('../logs/Log-2023-12-22-21-12-32.txt', "Log-2023-12-22-21-12-32.txt")
-la.run()
+for file in os.listdir("../logs"):
+    if file.endswith(".txt"):
+        print(file)
+        la = LogAnalyser('../logs/{}'.format(file), file)
+        la.run()
+
+# la = LogAnalyser('../logs/Log-2023-12-22-21-12-32.txt', "Log-2023-12-22-21-12-32.txt")
+# la.run()

src/log_analyser/objects/character.py

@@ -2,21 +2,20 @@
 
 
 class Character(Object):
-    
     def __init__(self, **kwargs):
 
-        data_schema = {"name": str}
+        data_schema = {"name": str,
+                       "stats": dict,
+                       "played_time": list,
+                       "kills": list,
+                       "deads": list,
+                       "offensive_assists": list,
+                       "defensive_assists": list,
+                       "ultimate_charged": list,
+                       "ultimate_use": list}
 
         super().__init__(data_schema, **kwargs)
 
-        self.played_time = []
-        self.stats = {}
-        self.kills = []
-        self.deads = []
-        self.offensive_assists = []
-        self.defensive_assists = []
-        self.ultimate_charged = []
-        self.ultimate_use = []
 
     def add_played_time(self, data):
         self.played_time.append(data)
@@ -35,9 +34,15 @@ def add_defensive_assist(self, data):
 
     def add_ultimate_charged(self, data):
         self.ultimate_charged.append(data)
+
     def add_ultimate_start(self, data):
         self.ultimate_use.append(data)
-    def add_ultimate_stop(self, data):
-        self.ultimate_end[-1]["end"] = data["date"]
+
+    def add_ultimate_end(self, data):
+
+        if len(self.ultimate_use) == 0:
+            return -1
+        self.ultimate_use[-1]["end"] = data["end"]
+
     def add_character_stats(self, data):
         self.stats = data

src/log_analyser/objects/match.py

@@ -13,7 +13,9 @@ def __init__(self, **kwargs):
                        "map_name": str,
                        "map_type": str,
                        "team1_name": str,
-                       "team2_name": str
+                       "team2_name": str,
+                       "score_team1": int,
+                       "score_team2": int,
                        }
 
         super().__init__(data_schema, **kwargs)
@@ -25,9 +27,10 @@ def add_round(self, data):
         teams = {}
         teams[self.team1_name] = Team.from_json({"name": self.team1_name, "players": {}})
         teams[self.team2_name] = Team.from_json({"name": self.team2_name, "players": {}})
-        self.rounds.append(Round.from_json({"teams": teams, "start_time": data[0]}))
+        self.rounds.append(Round.from_json({"teams": teams, "start_time": data[2], "objective_captured": [], "objective_progress": []}))
 
         self.actual_round += 1
+
         print("###### NEW ROUND {} #######".format(self.actual_round))
 
     def add_player(self, data):
@@ -38,7 +41,7 @@ def add_player(self, data):
         else:
             self.rounds[self.actual_round].teams[data["team_name"]].add_player(
                 {"name": data["player_name"], "characters": {}})
-            print("add player", data["player_name"])
+            # print("add player", data["player_name"])
             self.add_character(data)
             return 0
 
@@ -47,7 +50,7 @@ def add_character(self, data):
         if data["character_name"] in self.rounds[self.actual_round].teams[data["team_name"]].players[data["player_name"]].characters:
             return -2
         else:
-            self.rounds[self.actual_round].teams[data["team_name"]].players[data["player_name"]].add_character({"name": data["character_name"]})
+            self.rounds[self.actual_round].teams[data["team_name"]].players[data["player_name"]].add_character({"name": data["character_name"], "stats": {}, "played_time": [], "kills": [], "deads": [], "offensive_assists": [], "defensive_assists": [], "ultimate_charged": [], "ultimate_use": []})
 
         if len(self.rounds[self.actual_round].teams[data["team_name"]].players[data["player_name"]].characters[data["character_name"]].played_time) > 0:
             self.rounds[self.actual_round].teams[data["team_name"]].players[data["player_name"]].characters[data["character_name"]].played_time[-1]["end"] = data["time"]
@@ -56,38 +59,102 @@ def add_character(self, data):
 
     def add_kill(self, data):
 
-        killer_data = {"time": data[0], "player_victim": data[7], "character_victim": data[8]}
-        victim_data = {"time": data[0], "player_killer": data[4], "character_killer": data[5]}
+        killer_data = {"time": data[2], "player_victim": data[7], "character_victim": data[8]}
+        victim_data = {"time": data[2], "player_killer": data[4], "character_killer": data[5]}
 
         self.create_if_player_and_caracter_not_exist(data[3], data[4], data[5])
         self.create_if_player_and_caracter_not_exist(data[6], data[7], data[8])
 
         if not data[5] in self.rounds[self.actual_round].teams[data[3]].players[data[4]].characters:
-            self.add_character({"time": data[0], "team_name": data[3], "player_name": data[4], "character_name": data[5]})
+            self.add_character({"time": data[2], "team_name": data[3], "player_name": data[4], "character_name": data[5]})
 
         if not data[6] in self.rounds[self.actual_round].teams[data[6]].players[data[7]].characters:
-            self.add_character({"time": data[0], "team_name": data[6], "player_name": data[7], "character_name": data[8]})
+            self.add_character({"time": data[2], "team_name": data[6], "player_name": data[7], "character_name": data[8]})
 
         self.rounds[self.actual_round].teams[data[3]].players[data[4]].characters[data[5]].add_kill(killer_data)
         self.rounds[self.actual_round].teams[data[6]].players[data[7]].characters[data[8]].add_death(victim_data)
 
     def add_player_stat(self, data):
 
-        self.create_if_player_and_caracter_not_exist(data[4], data[5], data[6])
+        # self.create_if_player_and_caracter_not_exist(data[4], data[5], data[6])
 
         player_data = {"eliminations": data[6], "final_blows": data[7], "deaths": data[8], "damage": data[9],
                        "barrier_damage": data[10], "hero_damage": data[11], "healing": data[12], "healing_receive": data[13],
                        "self_healing": data[14], "damage_taken": data[15], "damage_blocked": data[16], "defensive_assist": data[17],
                        "offensive_assists": data[18], "ultimated_earn": data[19], "ultimates_used": data[20], "solo_kills": data[23],
                        "critical_hits_accuracy": data[28], "weapon_accuracy": data[37], "hero_time_played": data[38]}
 
-        if player_data["hero_time_played"] != "0":
+        if player_data["hero_time_played"] != "0" and data[6] in self.rounds[self.actual_round].teams[data[4]].players[data[5]].characters:
             self.rounds[self.actual_round].teams[data[4]].players[data[5]].characters[data[6]].add_character_stats(player_data)
 
+    def add_hero_swap(self, data):
+
+        self.add_player(data)
+        if data["character_swap"] in self.rounds[self.actual_round].teams[data["team_name"]].players[data["player_name"]].characters:
+            self.rounds[self.actual_round].teams[data["team_name"]].players[data["player_name"]].characters[data["character_swap"]].add_played_time({"end": data["time"]})
+
+
     def create_if_player_and_caracter_not_exist(self, team, player_name, character_name):
 
         if not player_name in self.rounds[self.actual_round].teams[team].players:
             self.add_player({"team_name": team, "player_name": player_name, "character_name": character_name, "time": self.rounds[self.actual_round].start_time})
 
         if not character_name in self.rounds[self.actual_round].teams[team].players[player_name].characters:
             self.add_character({"team_name": team, "player_name": player_name, "character_name": character_name, "time": self.rounds[self.actual_round].start_time})
+
+    def add_ultimate_start(self, data):
+
+        self.create_if_player_and_caracter_not_exist(data[3], data[4], data[5])
+
+        ultimate_start_data = {"start": data[2]}
+        self.rounds[self.actual_round].teams[data[3]].players[data[4]].characters[data[5]].add_ultimate_start(ultimate_start_data)
+
+    def add_ultimate_end(self, data):
+
+        self.create_if_player_and_caracter_not_exist(data[3], data[4], data[5])
+
+        ultimate_end_data = {"end": data[2]}
+        self.rounds[self.actual_round].teams[data[3]].players[data[4]].characters[data[5]].add_ultimate_end(ultimate_end_data)
+
+    def add_ultimate_charged(self, data):
+
+        self.create_if_player_and_caracter_not_exist(data[3], data[4], data[5])
+
+        ultimate_charged_data = data[2]
+        self.rounds[self.actual_round].teams[data[3]].players[data[4]].characters[data[5]].add_ultimate_charged(ultimate_charged_data)
+
+    def add_objective_captured(self, data):
+
+        objective_capture_data = {"time": data[2], "team_name": data[4], "control_team1_progress": data[6],
+                                  "control_team2_progress": data[7]}
+
+        self.rounds[self.actual_round].add_objective_captured(objective_capture_data)
+
+
+    def add_objective_progress(self, data):
+
+        objectif_progress_data = {"time": data[2], "team_name": data[4], "progress": data[6]}
+        self.rounds[self.actual_round].add_objective_progress(objectif_progress_data)
+        pass
+
+    def end_round(self, data):
+
+        end_round_data = {"time": data[2], "score_team1": data[5], "score_team2": data[6]}
+
+        for team in self.rounds[self.actual_round].teams:
+            for player in self.rounds[self.actual_round].teams[team].players:
+                for character in self.rounds[self.actual_round].teams[team].players[player].characters:
+                    if not "end" in self.rounds[self.actual_round].teams[team].players[player].characters[character].played_time[-1]:
+                        self.rounds[self.actual_round].teams[team].players[player].characters[character].played_time[-1]["end"] = end_round_data["time"]
+
+
+        self.score_team1 = end_round_data["score_team1"]
+        self.score_team2 = end_round_data["score_team2"]
+        print("###### END ROUND {} #######\n".format(self.actual_round))
+
+    def end_match(self, data):
+
+        end_match_data = {"time": data[2], "score_team1": data[4], "score_team2": data[5]}
+
+        self.score_team1 = end_match_data["score_team1"]
+        self.score_team2 = end_match_data["score_team2"]

src/log_analyser/objects/object.py

@@ -18,6 +18,11 @@ def __init__(self, class_model, **kwargs):
                 print("key {} not find in dataschema".format(key))
                 self.from_json_ok = False
 
+        for key, value in class_model.items():
+            if not hasattr(self, key):
+                print("key {} not find in object".format(key, value()))
+                setattr(self, key, value())
+
     def export_json_recursive(self, data):
         if issubclass(type(data), Object):
             dict_class = data.__dict__.copy()
@@ -39,7 +44,7 @@ def export_json(self):
         for key, value in dict_class.items():
             dict_class[key] = self.export_json_recursive(value)
 
-        return json.dumps(dict_class)
+        return json.dumps(dict_class, indent=4, sort_keys=True, default=str)
 
     def convert_timefile_to_datetime(self, time_string):
 

src/log_analyser/objects/round.py

@@ -1,14 +1,21 @@
 from objects.object import Object
 from objects.team import Team
 
+
 class Round(Object):
 
     def __init__(self, **kwargs):
 
         data_schema = {"teams": dict,
-                       "start_time": str
+                       "start_time": str,
+                       "objective_captured": list,
+                       "objective_progress": list
                        }
 
         super().__init__(data_schema, **kwargs)
-    
-    
+
+    def add_objective_captured(self, data):
+        self.objective_captured.append(data)
+
+    def add_objective_progress(self, data):
+        self.objective_progress.append(data)