Merge pull request spookybear0#130 from EboMike/scorecard

Add friendly medic hits as a notable event.

Author: spookybear0

helpers/sm5helper.py

@@ -485,7 +485,7 @@ async def get_sm5_player_stats(game: SM5Game, main_player: Optional[EntityStarts
 
 @cache()
 async def get_sm5_lives_over_time(game: SM5Game, team_roster: dict[Team, List[PlayerInfo]], granularity_millis: int) -> \
-        dict[int, list[int]]:
+    dict[int, list[int]]:
     lives_timeline = defaultdict(list)
     current_lives = {}
 
@@ -554,7 +554,7 @@ async def get_sm5_lives_over_time(game: SM5Game, team_roster: dict[Team, List[Pl
 
 async def get_sm5_rating_over_time(entity_id: str, min_time: datetime = _MIN_DATETIME,
                                    max_time: datetime = _MAX_DATETIME) -> \
-        Optional[TimeSeriesRawData]:
+    Optional[TimeSeriesRawData]:
     """Creates a time series of the SM5 rating for a specific player.
 
     entity_id: Entity ID of the player to get the rating for.
@@ -883,6 +883,52 @@ def add_event(time_ms: int, event: str, short_event: list[str], team: Team):
                             break
 
                     nuke_check_index += 1
+
+        # Any friendly medic hits?
+        if events[event_index].type in [
+            EventType.DOWNED_OPPONENT,
+            EventType.DOWNED_TEAM,
+            EventType.MISSILE_DOWN_OPPONENT,
+            EventType.MISSILE_DOWN_TEAM]:
+            # One player downed another. Was it a medic?
+            tag_time_ms = events[event_index].time
+            target_entity_id = events[event_index].entity2
+
+            if target_entity_id not in entity_id_map:
+                print(f"ERROR - cannot find entity for target {target_entity_id}")
+                event_index += 1
+                continue
+
+            target_entity = entity_id_map[target_entity_id]
+            target_team = team_from_entity_id[target_entity_id]
+
+            # We only care about medics getting hit.
+            if target_entity.role != IntRole.MEDIC:
+                event_index += 1
+                continue
+
+            aggressor_entity_id = events[event_index].entity1
+
+            if aggressor_entity_id not in entity_id_map:
+                print(f"ERROR - cannot find entity for aggressor {aggressor_entity_id}")
+                event_index += 1
+                continue
+
+            aggressor_entity = entity_id_map[aggressor_entity_id]
+            aggressor_team = team_from_entity_id[aggressor_entity_id]
+
+            if target_team == aggressor_team:
+                # Friendly fire!
+                if events[event_index].type in [EventType.MISSILE_DOWN_TEAM,
+                                                EventType.MISSILE_DOWN_OPPONENT]:
+                    add_event(tag_time_ms,
+                              f"{aggressor_entity.name} MISSILES own medic {target_entity.name}",
+                              [aggressor_entity.name, "MISSILES own medic"], target_team)
+                else:
+                    add_event(tag_time_ms,
+                              f"{aggressor_entity.name} tags own medic {target_entity.name}",
+                              [aggressor_entity.name, "tags own medic"], target_team)
+
         event_index += 1
 
     sort_notable_events(result)

tests/helpers/sm5helper_test.py

@@ -5,7 +5,7 @@
 from helpers.sm5helper import get_sm5_last_team_standing, get_sm5_notable_events, update_team_sizes
 from helpers.statshelper import NotableEvent
 from helpers.tdfhelper import create_event
-from tests.helpers.environment import setup_test_database, ENTITY_ID_1, ENTITY_ID_2, get_sm5_game_id, \
+from tests.helpers.environment import setup_test_database, ENTITY_ID_1, ENTITY_ID_2, ENTITY_ID_4, get_sm5_game_id, \
     teardown_test_database, add_entity, get_red_team, get_green_team, add_sm5_stats, ENTITY_ID_3, add_sm5_event
 
 
@@ -31,7 +31,6 @@ async def test_get_team_sizes_counts_correctly(self):
         team_sizes = [game.team1_size, game.team2_size]
         self.assertCountEqual([1, 2], team_sizes)
 
-
     async def test_get_team_sizes_counts_only_one_team(self):
         game = await SM5Game.filter(id=get_sm5_game_id()).first()
 
@@ -45,7 +44,6 @@ async def test_get_team_sizes_counts_only_one_team(self):
         self.assertEqual(2, game.team1_size)
         self.assertEqual(0, game.team2_size)
 
-
     async def test_get_team_sizes_counts_no_players(self):
         game = await SM5Game.filter(id=get_sm5_game_id()).first()
 
@@ -54,7 +52,6 @@ async def test_get_team_sizes_counts_no_players(self):
         self.assertEqual(0, game.team1_size)
         self.assertEqual(0, game.team2_size)
 
-
     async def test_get_sm5_last_team_standing_both_alive(self):
         game = await SM5Game.filter(id=get_sm5_game_id()).first()
         entity_start, entity_end = await add_entity(entity_id=ENTITY_ID_1, team=get_red_team())
@@ -265,5 +262,96 @@ async def test_get_sm5_notable_events(self):
                                        id='event11',
                                        position='80%')], notable_events)
 
+    async def test_get_sm5_notable_events_medic_hits(self):
+        await teardown_test_database()
+        await setup_test_database(basic_events=False)
+
+        game = await SM5Game.filter(id=get_sm5_game_id()).first()
+
+        # Player 1 is RED MEDIC.
+        entity_start, entity_end = await add_entity(entity_id=ENTITY_ID_1, team=get_red_team(),
+                                                    role=IntRole.MEDIC,
+                                                    name="FireMedic")
+        await add_sm5_stats(entity_start)
+
+        # Player 2 is GREEN MEDIC.
+        entity_start2, entity_end2 = await add_entity(entity_id=ENTITY_ID_2, team=get_green_team(),
+                                                      role=IntRole.MEDIC,
+                                                      name="GreenMedic")
+        await add_sm5_stats(entity_start2)
+
+        # Player 3 is RED SCOUT.
+        entity_start3, entity_end3 = await add_entity(entity_id=ENTITY_ID_3, team=get_red_team(),
+                                                      role=IntRole.SCOUT,
+                                                      name="Red Scout")
+        await add_sm5_stats(entity_start3)
+
+        # Player 4 is GREEN AMMO.
+        entity_start4, entity_end4 = await add_entity(entity_id=ENTITY_ID_4, team=get_green_team(),
+                                                      role=IntRole.AMMO,
+                                                      name="Green Ammo")
+        await add_sm5_stats(entity_start4)
+
+        await game.entity_starts.add(entity_start, entity_start2, entity_start3, entity_start4)
+        await game.entity_ends.add(entity_end, entity_end2, entity_end3, entity_end4)
+
+        # 5000: Irrelevant event.
+        await add_sm5_event(await create_event(time_ms=10000, type=EventType.LOCKING,
+                                               entity1=ENTITY_ID_3,
+                                               entity2=ENTITY_ID_1,
+                                               ))
+
+        # 10000: Medic to medic. IGNORED: Across teams, ignored
+        await add_sm5_event(await create_event(time_ms=10000, type=EventType.DOWNED_OPPONENT,
+                                               entity1=ENTITY_ID_1,
+                                               entity2=ENTITY_ID_2,
+                                               ))
+
+        # 20000: Scout to medic. Friendly fire
+        await add_sm5_event(await create_event(time_ms=20000, type=EventType.DOWNED_OPPONENT,
+                                               entity1=ENTITY_ID_3,
+                                               entity2=ENTITY_ID_1,
+                                               ))
+
+        # 30000: Medic to scout. Ignored
+        await add_sm5_event(await create_event(time_ms=30000, type=EventType.DOWNED_OPPONENT,
+                                               entity1=ENTITY_ID_1,
+                                               entity2=ENTITY_ID_3,
+                                               ))
+
+        # 40000: Ammo to medic. Friendly fire.
+        await add_sm5_event(await create_event(time_ms=40000, type=EventType.DOWNED_TEAM,
+                                               entity1=ENTITY_ID_4,
+                                               entity2=ENTITY_ID_2,
+                                               ))
+
+        # 50000: Scout to medic with missile (yeah right). Friendly fire
+        await add_sm5_event(await create_event(time_ms=50000, type=EventType.MISSILE_DOWN_OPPONENT,
+                                               entity1=ENTITY_ID_3,
+                                               entity2=ENTITY_ID_1,
+                                               ))
+
+        notable_events = await get_sm5_notable_events(game)
+
+        # All events, in chronological order.
+        self.assertEqual([NotableEvent(seconds=20,
+                                       event='Red Scout tags own medic FireMedic',
+                                       short_event=['Red Scout', 'tags own medic'],
+                                       team=Team.RED,
+                                       id='event1',
+                                       position='90%'),
+                          NotableEvent(seconds=40,
+                                       event='Green Ammo tags own medic GreenMedic',
+                                       short_event=['Green Ammo', 'tags own medic'],
+                                       team=Team.GREEN,
+                                       id='event2',
+                                       position='80%'),
+                          NotableEvent(seconds=50,
+                                       event='Red Scout MISSILES own medic FireMedic',
+                                       short_event=['Red Scout', 'MISSILES own medic'],
+                                       team=Team.RED,
+                                       id='event3',
+                                       position='70%')], notable_events)
+
         if __name__ == '__main__':
             unittest.main()