1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Defines Race mini-game."""
  4
  5# ba_meta require api 7
  6# (see https://ballistica.net/wiki/meta-tag-system)
  7
  8from __future__ import annotations
  9
 10import random
 11from typing import TYPE_CHECKING
 12from dataclasses import dataclass
 13
 14import ba
 15from bastd.actor.bomb import Bomb
 16from bastd.actor.playerspaz import PlayerSpaz
 17from bastd.actor.scoreboard import Scoreboard
 18from bastd.gameutils import SharedObjects
 19
 20if TYPE_CHECKING:
 21    from typing import Any, Sequence
 22    from bastd.actor.onscreentimer import OnScreenTimer
 23
 24
 25@dataclass
 26class RaceMine:
 27    """Holds info about a mine on the track."""
 28    point: Sequence[float]
 29    mine: Bomb | None
 30
 31
 32class RaceRegion(ba.Actor):
 33    """Region used to track progress during a race."""
 34
 35    def __init__(self, pt: Sequence[float], index: int):
 36        super().__init__()
 37        activity = self.activity
 38        assert isinstance(activity, RaceGame)
 39        self.pos = pt
 40        self.index = index
 41        self.node = ba.newnode(
 42            'region',
 43            delegate=self,
 44            attrs={
 45                'position': pt[:3],
 46                'scale': (pt[3] * 2.0, pt[4] * 2.0, pt[5] * 2.0),
 47                'type': 'box',
 48                'materials': [activity.race_region_material]
 49            })
 50
 51
 52class Player(ba.Player['Team']):
 53    """Our player type for this game."""
 54
 55    def __init__(self) -> None:
 56        self.distance_txt: ba.Node | None = None
 57        self.last_region = 0
 58        self.lap = 0
 59        self.distance = 0.0
 60        self.finished = False
 61        self.rank: int | None = None
 62
 63
 64class Team(ba.Team[Player]):
 65    """Our team type for this game."""
 66
 67    def __init__(self) -> None:
 68        self.time: float | None = None
 69        self.lap = 0
 70        self.finished = False
 71
 72
 73# ba_meta export game
 74class RaceGame(ba.TeamGameActivity[Player, Team]):
 75    """Game of racing around a track."""
 76
 77    name = 'Race'
 78    description = 'Run real fast!'
 79    scoreconfig = ba.ScoreConfig(label='Time',
 80                                 lower_is_better=True,
 81                                 scoretype=ba.ScoreType.MILLISECONDS)
 82
 83    @classmethod
 84    def get_available_settings(
 85            cls, sessiontype: type[ba.Session]) -> list[ba.Setting]:
 86        settings = [
 87            ba.IntSetting('Laps', min_value=1, default=3, increment=1),
 88            ba.IntChoiceSetting(
 89                'Time Limit',
 90                default=0,
 91                choices=[
 92                    ('None', 0),
 93                    ('1 Minute', 60),
 94                    ('2 Minutes', 120),
 95                    ('5 Minutes', 300),
 96                    ('10 Minutes', 600),
 97                    ('20 Minutes', 1200),
 98                ],
 99            ),
100            ba.IntChoiceSetting(
101                'Mine Spawning',
102                default=4000,
103                choices=[
104                    ('No Mines', 0),
105                    ('8 Seconds', 8000),
106                    ('4 Seconds', 4000),
107                    ('2 Seconds', 2000),
108                ],
109            ),
110            ba.IntChoiceSetting(
111                'Bomb Spawning',
112                choices=[
113                    ('None', 0),
114                    ('8 Seconds', 8000),
115                    ('4 Seconds', 4000),
116                    ('2 Seconds', 2000),
117                    ('1 Second', 1000),
118                ],
119                default=2000,
120            ),
121            ba.BoolSetting('Epic Mode', default=False),
122        ]
123
124        # We have some specific settings in teams mode.
125        if issubclass(sessiontype, ba.DualTeamSession):
126            settings.append(
127                ba.BoolSetting('Entire Team Must Finish', default=False))
128        return settings
129
130    @classmethod
131    def supports_session_type(cls, sessiontype: type[ba.Session]) -> bool:
132        return issubclass(sessiontype, ba.MultiTeamSession)
133
134    @classmethod
135    def get_supported_maps(cls, sessiontype: type[ba.Session]) -> list[str]:
136        return ba.getmaps('race')
137
138    def __init__(self, settings: dict):
139        self._race_started = False
140        super().__init__(settings)
141        self._scoreboard = Scoreboard()
142        self._score_sound = ba.getsound('score')
143        self._swipsound = ba.getsound('swip')
144        self._last_team_time: float | None = None
145        self._front_race_region: int | None = None
146        self._nub_tex = ba.gettexture('nub')
147        self._beep_1_sound = ba.getsound('raceBeep1')
148        self._beep_2_sound = ba.getsound('raceBeep2')
149        self.race_region_material: ba.Material | None = None
150        self._regions: list[RaceRegion] = []
151        self._team_finish_pts: int | None = None
152        self._time_text: ba.Actor | None = None
153        self._timer: OnScreenTimer | None = None
154        self._race_mines: list[RaceMine] | None = None
155        self._race_mine_timer: ba.Timer | None = None
156        self._scoreboard_timer: ba.Timer | None = None
157        self._player_order_update_timer: ba.Timer | None = None
158        self._start_lights: list[ba.Node] | None = None
159        self._bomb_spawn_timer: ba.Timer | None = None
160        self._laps = int(settings['Laps'])
161        self._entire_team_must_finish = bool(
162            settings.get('Entire Team Must Finish', False))
163        self._time_limit = float(settings['Time Limit'])
164        self._mine_spawning = int(settings['Mine Spawning'])
165        self._bomb_spawning = int(settings['Bomb Spawning'])
166        self._epic_mode = bool(settings['Epic Mode'])
167
168        # Base class overrides.
169        self.slow_motion = self._epic_mode
170        self.default_music = (ba.MusicType.EPIC_RACE
171                              if self._epic_mode else ba.MusicType.RACE)
172
173    def get_instance_description(self) -> str | Sequence:
174        if (isinstance(self.session, ba.DualTeamSession)
175                and self._entire_team_must_finish):
176            t_str = ' Your entire team has to finish.'
177        else:
178            t_str = ''
179
180        if self._laps > 1:
181            return 'Run ${ARG1} laps.' + t_str, self._laps
182        return 'Run 1 lap.' + t_str
183
184    def get_instance_description_short(self) -> str | Sequence:
185        if self._laps > 1:
186            return 'run ${ARG1} laps', self._laps
187        return 'run 1 lap'
188
189    def on_transition_in(self) -> None:
190        super().on_transition_in()
191        shared = SharedObjects.get()
192        pts = self.map.get_def_points('race_point')
193        mat = self.race_region_material = ba.Material()
194        mat.add_actions(conditions=('they_have_material',
195                                    shared.player_material),
196                        actions=(
197                            ('modify_part_collision', 'collide', True),
198                            ('modify_part_collision', 'physical', False),
199                            ('call', 'at_connect',
200                             self._handle_race_point_collide),
201                        ))
202        for rpt in pts:
203            self._regions.append(RaceRegion(rpt, len(self._regions)))
204
205    def _flash_player(self, player: Player, scale: float) -> None:
206        assert isinstance(player.actor, PlayerSpaz)
207        assert player.actor.node
208        pos = player.actor.node.position
209        light = ba.newnode('light',
210                           attrs={
211                               'position': pos,
212                               'color': (1, 1, 0),
213                               'height_attenuated': False,
214                               'radius': 0.4
215                           })
216        ba.timer(0.5, light.delete)
217        ba.animate(light, 'intensity', {0: 0, 0.1: 1.0 * scale, 0.5: 0})
218
219    def _handle_race_point_collide(self) -> None:
220        # FIXME: Tidy this up.
221        # pylint: disable=too-many-statements
222        # pylint: disable=too-many-branches
223        # pylint: disable=too-many-nested-blocks
224        collision = ba.getcollision()
225        try:
226            region = collision.sourcenode.getdelegate(RaceRegion, True)
227            spaz = collision.opposingnode.getdelegate(PlayerSpaz, True)
228        except ba.NotFoundError:
229            return
230
231        if not spaz.is_alive():
232            return
233
234        try:
235            player = spaz.getplayer(Player, True)
236        except ba.NotFoundError:
237            return
238
239        last_region = player.last_region
240        this_region = region.index
241
242        if last_region != this_region:
243
244            # If a player tries to skip regions, smite them.
245            # Allow a one region leeway though (its plausible players can get
246            # blown over a region, etc).
247            if this_region > last_region + 2:
248                if player.is_alive():
249                    assert player.actor
250                    player.actor.handlemessage(ba.DieMessage())
251                    ba.screenmessage(ba.Lstr(
252                        translate=('statements', 'Killing ${NAME} for'
253                                   ' skipping part of the track!'),
254                        subs=[('${NAME}', player.getname(full=True))]),
255                                     color=(1, 0, 0))
256            else:
257                # If this player is in first, note that this is the
258                # front-most race-point.
259                if player.rank == 0:
260                    self._front_race_region = this_region
261
262                player.last_region = this_region
263                if last_region >= len(self._regions) - 2 and this_region == 0:
264                    team = player.team
265                    player.lap = min(self._laps, player.lap + 1)
266
267                    # In teams mode with all-must-finish on, the team lap
268                    # value is the min of all team players.
269                    # Otherwise its the max.
270                    if isinstance(self.session, ba.DualTeamSession
271                                  ) and self._entire_team_must_finish:
272                        team.lap = min(p.lap for p in team.players)
273                    else:
274                        team.lap = max(p.lap for p in team.players)
275
276                    # A player is finishing.
277                    if player.lap == self._laps:
278
279                        # In teams mode, hand out points based on the order
280                        # players come in.
281                        if isinstance(self.session, ba.DualTeamSession):
282                            assert self._team_finish_pts is not None
283                            if self._team_finish_pts > 0:
284                                self.stats.player_scored(player,
285                                                         self._team_finish_pts,
286                                                         screenmessage=False)
287                            self._team_finish_pts -= 25
288
289                        # Flash where the player is.
290                        self._flash_player(player, 1.0)
291                        player.finished = True
292                        assert player.actor
293                        player.actor.handlemessage(
294                            ba.DieMessage(immediate=True))
295
296                        # Makes sure noone behind them passes them in rank
297                        # while finishing.
298                        player.distance = 9999.0
299
300                        # If the whole team has finished the race.
301                        if team.lap == self._laps:
302                            ba.playsound(self._score_sound)
303                            player.team.finished = True
304                            assert self._timer is not None
305                            elapsed = ba.time() - self._timer.getstarttime()
306                            self._last_team_time = player.team.time = elapsed
307                            self._check_end_game()
308
309                        # Team has yet to finish.
310                        else:
311                            ba.playsound(self._swipsound)
312
313                    # They've just finished a lap but not the race.
314                    else:
315                        ba.playsound(self._swipsound)
316                        self._flash_player(player, 0.3)
317
318                        # Print their lap number over their head.
319                        try:
320                            assert isinstance(player.actor, PlayerSpaz)
321                            mathnode = ba.newnode('math',
322                                                  owner=player.actor.node,
323                                                  attrs={
324                                                      'input1': (0, 1.9, 0),
325                                                      'operation': 'add'
326                                                  })
327                            player.actor.node.connectattr(
328                                'torso_position', mathnode, 'input2')
329                            tstr = ba.Lstr(resource='lapNumberText',
330                                           subs=[('${CURRENT}',
331                                                  str(player.lap + 1)),
332                                                 ('${TOTAL}', str(self._laps))
333                                                 ])
334                            txtnode = ba.newnode('text',
335                                                 owner=mathnode,
336                                                 attrs={
337                                                     'text': tstr,
338                                                     'in_world': True,
339                                                     'color': (1, 1, 0, 1),
340                                                     'scale': 0.015,
341                                                     'h_align': 'center'
342                                                 })
343                            mathnode.connectattr('output', txtnode, 'position')
344                            ba.animate(txtnode, 'scale', {
345                                0.0: 0,
346                                0.2: 0.019,
347                                2.0: 0.019,
348                                2.2: 0
349                            })
350                            ba.timer(2.3, mathnode.delete)
351                        except Exception:
352                            ba.print_exception('Error printing lap.')
353
354    def on_team_join(self, team: Team) -> None:
355        self._update_scoreboard()
356
357    def on_player_leave(self, player: Player) -> None:
358        super().on_player_leave(player)
359
360        # A player leaving disqualifies the team if 'Entire Team Must Finish'
361        # is on (otherwise in teams mode everyone could just leave except the
362        # leading player to win).
363        if (isinstance(self.session, ba.DualTeamSession)
364                and self._entire_team_must_finish):
365            ba.screenmessage(ba.Lstr(
366                translate=('statements',
367                           '${TEAM} is disqualified because ${PLAYER} left'),
368                subs=[('${TEAM}', player.team.name),
369                      ('${PLAYER}', player.getname(full=True))]),
370                             color=(1, 1, 0))
371            player.team.finished = True
372            player.team.time = None
373            player.team.lap = 0
374            ba.playsound(ba.getsound('boo'))
375            for otherplayer in player.team.players:
376                otherplayer.lap = 0
377                otherplayer.finished = True
378                try:
379                    if otherplayer.actor is not None:
380                        otherplayer.actor.handlemessage(ba.DieMessage())
381                except Exception:
382                    ba.print_exception('Error sending DieMessage.')
383
384        # Defer so team/player lists will be updated.
385        ba.pushcall(self._check_end_game)
386
387    def _update_scoreboard(self) -> None:
388        for team in self.teams:
389            distances = [player.distance for player in team.players]
390            if not distances:
391                teams_dist = 0.0
392            else:
393                if (isinstance(self.session, ba.DualTeamSession)
394                        and self._entire_team_must_finish):
395                    teams_dist = min(distances)
396                else:
397                    teams_dist = max(distances)
398            self._scoreboard.set_team_value(
399                team,
400                teams_dist,
401                self._laps,
402                flash=(teams_dist >= float(self._laps)),
403                show_value=False)
404
405    def on_begin(self) -> None:
406        from bastd.actor.onscreentimer import OnScreenTimer
407        super().on_begin()
408        self.setup_standard_time_limit(self._time_limit)
409        self.setup_standard_powerup_drops()
410        self._team_finish_pts = 100
411
412        # Throw a timer up on-screen.
413        self._time_text = ba.NodeActor(
414            ba.newnode('text',
415                       attrs={
416                           'v_attach': 'top',
417                           'h_attach': 'center',
418                           'h_align': 'center',
419                           'color': (1, 1, 0.5, 1),
420                           'flatness': 0.5,
421                           'shadow': 0.5,
422                           'position': (0, -50),
423                           'scale': 1.4,
424                           'text': ''
425                       }))
426        self._timer = OnScreenTimer()
427
428        if self._mine_spawning != 0:
429            self._race_mines = [
430                RaceMine(point=p, mine=None)
431                for p in self.map.get_def_points('race_mine')
432            ]
433            if self._race_mines:
434                self._race_mine_timer = ba.Timer(0.001 * self._mine_spawning,
435                                                 self._update_race_mine,
436                                                 repeat=True)
437
438        self._scoreboard_timer = ba.Timer(0.25,
439                                          self._update_scoreboard,
440                                          repeat=True)
441        self._player_order_update_timer = ba.Timer(0.25,
442                                                   self._update_player_order,
443                                                   repeat=True)
444
445        if self.slow_motion:
446            t_scale = 0.4
447            light_y = 50
448        else:
449            t_scale = 1.0
450            light_y = 150
451        lstart = 7.1 * t_scale
452        inc = 1.25 * t_scale
453
454        ba.timer(lstart, self._do_light_1)
455        ba.timer(lstart + inc, self._do_light_2)
456        ba.timer(lstart + 2 * inc, self._do_light_3)
457        ba.timer(lstart + 3 * inc, self._start_race)
458
459        self._start_lights = []
460        for i in range(4):
461            lnub = ba.newnode('image',
462                              attrs={
463                                  'texture': ba.gettexture('nub'),
464                                  'opacity': 1.0,
465                                  'absolute_scale': True,
466                                  'position': (-75 + i * 50, light_y),
467                                  'scale': (50, 50),
468                                  'attach': 'center'
469                              })
470            ba.animate(
471                lnub, 'opacity', {
472                    4.0 * t_scale: 0,
473                    5.0 * t_scale: 1.0,
474                    12.0 * t_scale: 1.0,
475                    12.5 * t_scale: 0.0
476                })
477            ba.timer(13.0 * t_scale, lnub.delete)
478            self._start_lights.append(lnub)
479
480        self._start_lights[0].color = (0.2, 0, 0)
481        self._start_lights[1].color = (0.2, 0, 0)
482        self._start_lights[2].color = (0.2, 0.05, 0)
483        self._start_lights[3].color = (0.0, 0.3, 0)
484
485    def _do_light_1(self) -> None:
486        assert self._start_lights is not None
487        self._start_lights[0].color = (1.0, 0, 0)
488        ba.playsound(self._beep_1_sound)
489
490    def _do_light_2(self) -> None:
491        assert self._start_lights is not None
492        self._start_lights[1].color = (1.0, 0, 0)
493        ba.playsound(self._beep_1_sound)
494
495    def _do_light_3(self) -> None:
496        assert self._start_lights is not None
497        self._start_lights[2].color = (1.0, 0.3, 0)
498        ba.playsound(self._beep_1_sound)
499
500    def _start_race(self) -> None:
501        assert self._start_lights is not None
502        self._start_lights[3].color = (0.0, 1.0, 0)
503        ba.playsound(self._beep_2_sound)
504        for player in self.players:
505            if player.actor is not None:
506                try:
507                    assert isinstance(player.actor, PlayerSpaz)
508                    player.actor.connect_controls_to_player()
509                except Exception:
510                    ba.print_exception('Error in race player connects.')
511        assert self._timer is not None
512        self._timer.start()
513
514        if self._bomb_spawning != 0:
515            self._bomb_spawn_timer = ba.Timer(0.001 * self._bomb_spawning,
516                                              self._spawn_bomb,
517                                              repeat=True)
518
519        self._race_started = True
520
521    def _update_player_order(self) -> None:
522
523        # Calc all player distances.
524        for player in self.players:
525            pos: ba.Vec3 | None
526            try:
527                pos = player.position
528            except ba.NotFoundError:
529                pos = None
530            if pos is not None:
531                r_index = player.last_region
532                rg1 = self._regions[r_index]
533                r1pt = ba.Vec3(rg1.pos[:3])
534                rg2 = self._regions[0] if r_index == len(
535                    self._regions) - 1 else self._regions[r_index + 1]
536                r2pt = ba.Vec3(rg2.pos[:3])
537                r2dist = (pos - r2pt).length()
538                amt = 1.0 - (r2dist / (r2pt - r1pt).length())
539                amt = player.lap + (r_index + amt) * (1.0 / len(self._regions))
540                player.distance = amt
541
542        # Sort players by distance and update their ranks.
543        p_list = [(player.distance, player) for player in self.players]
544
545        p_list.sort(reverse=True, key=lambda x: x[0])
546        for i, plr in enumerate(p_list):
547            plr[1].rank = i
548            if plr[1].actor:
549                node = plr[1].distance_txt
550                if node:
551                    node.text = str(i + 1) if plr[1].is_alive() else ''
552
553    def _spawn_bomb(self) -> None:
554        if self._front_race_region is None:
555            return
556        region = (self._front_race_region + 3) % len(self._regions)
557        pos = self._regions[region].pos
558
559        # Don't use the full region so we're less likely to spawn off a cliff.
560        region_scale = 0.8
561        x_range = ((-0.5, 0.5) if pos[3] == 0 else
562                   (-region_scale * pos[3], region_scale * pos[3]))
563        z_range = ((-0.5, 0.5) if pos[5] == 0 else
564                   (-region_scale * pos[5], region_scale * pos[5]))
565        pos = (pos[0] + random.uniform(*x_range), pos[1] + 1.0,
566               pos[2] + random.uniform(*z_range))
567        ba.timer(random.uniform(0.0, 2.0),
568                 ba.WeakCall(self._spawn_bomb_at_pos, pos))
569
570    def _spawn_bomb_at_pos(self, pos: Sequence[float]) -> None:
571        if self.has_ended():
572            return
573        Bomb(position=pos, bomb_type='normal').autoretain()
574
575    def _make_mine(self, i: int) -> None:
576        assert self._race_mines is not None
577        rmine = self._race_mines[i]
578        rmine.mine = Bomb(position=rmine.point[:3], bomb_type='land_mine')
579        rmine.mine.arm()
580
581    def _flash_mine(self, i: int) -> None:
582        assert self._race_mines is not None
583        rmine = self._race_mines[i]
584        light = ba.newnode('light',
585                           attrs={
586                               'position': rmine.point[:3],
587                               'color': (1, 0.2, 0.2),
588                               'radius': 0.1,
589                               'height_attenuated': False
590                           })
591        ba.animate(light, 'intensity', {0.0: 0, 0.1: 1.0, 0.2: 0}, loop=True)
592        ba.timer(1.0, light.delete)
593
594    def _update_race_mine(self) -> None:
595        assert self._race_mines is not None
596        m_index = -1
597        rmine = None
598        for _i in range(3):
599            m_index = random.randrange(len(self._race_mines))
600            rmine = self._race_mines[m_index]
601            if not rmine.mine:
602                break
603        assert rmine is not None
604        if not rmine.mine:
605            self._flash_mine(m_index)
606            ba.timer(0.95, ba.Call(self._make_mine, m_index))
607
608    def spawn_player(self, player: Player) -> ba.Actor:
609        if player.team.finished:
610            # FIXME: This is not type-safe!
611            #   This call is expected to always return an Actor!
612            #   Perhaps we need something like can_spawn_player()...
613            # noinspection PyTypeChecker
614            return None  # type: ignore
615        pos = self._regions[player.last_region].pos
616
617        # Don't use the full region so we're less likely to spawn off a cliff.
618        region_scale = 0.8
619        x_range = ((-0.5, 0.5) if pos[3] == 0 else
620                   (-region_scale * pos[3], region_scale * pos[3]))
621        z_range = ((-0.5, 0.5) if pos[5] == 0 else
622                   (-region_scale * pos[5], region_scale * pos[5]))
623        pos = (pos[0] + random.uniform(*x_range), pos[1],
624               pos[2] + random.uniform(*z_range))
625        spaz = self.spawn_player_spaz(
626            player, position=pos, angle=90 if not self._race_started else None)
627        assert spaz.node
628
629        # Prevent controlling of characters before the start of the race.
630        if not self._race_started:
631            spaz.disconnect_controls_from_player()
632
633        mathnode = ba.newnode('math',
634                              owner=spaz.node,
635                              attrs={
636                                  'input1': (0, 1.4, 0),
637                                  'operation': 'add'
638                              })
639        spaz.node.connectattr('torso_position', mathnode, 'input2')
640
641        distance_txt = ba.newnode('text',
642                                  owner=spaz.node,
643                                  attrs={
644                                      'text': '',
645                                      'in_world': True,
646                                      'color': (1, 1, 0.4),
647                                      'scale': 0.02,
648                                      'h_align': 'center'
649                                  })
650        player.distance_txt = distance_txt
651        mathnode.connectattr('output', distance_txt, 'position')
652        return spaz
653
654    def _check_end_game(self) -> None:
655
656        # If there's no teams left racing, finish.
657        teams_still_in = len([t for t in self.teams if not t.finished])
658        if teams_still_in == 0:
659            self.end_game()
660            return
661
662        # Count the number of teams that have completed the race.
663        teams_completed = len(
664            [t for t in self.teams if t.finished and t.time is not None])
665
666        if teams_completed > 0:
667            session = self.session
668
669            # In teams mode its over as soon as any team finishes the race
670
671            # FIXME: The get_ffa_point_awards code looks dangerous.
672            if isinstance(session, ba.DualTeamSession):
673                self.end_game()
674            else:
675                # In ffa we keep the race going while there's still any points
676                # to be handed out. Find out how many points we have to award
677                # and how many teams have finished, and once that matches
678                # we're done.
679                assert isinstance(session, ba.FreeForAllSession)
680                points_to_award = len(session.get_ffa_point_awards())
681                if teams_completed >= points_to_award - teams_completed:
682                    self.end_game()
683                    return
684
685    def end_game(self) -> None:
686
687        # Stop updating our time text, and set it to show the exact last
688        # finish time if we have one. (so users don't get upset if their
689        # final time differs from what they see onscreen by a tiny amount)
690        assert self._timer is not None
691        if self._timer.has_started():
692            self._timer.stop(
693                endtime=None if self._last_team_time is None else (
694                    self._timer.getstarttime() + self._last_team_time))
695
696        results = ba.GameResults()
697
698        for team in self.teams:
699            if team.time is not None:
700                # We store time in seconds, but pass a score in milliseconds.
701                results.set_team_score(team, int(team.time * 1000.0))
702            else:
703                results.set_team_score(team, None)
704
705        # We don't announce a winner in ffa mode since its probably been a
706        # while since the first place guy crossed the finish line so it seems
707        # odd to be announcing that now.
708        self.end(results=results,
709                 announce_winning_team=isinstance(self.session,
710                                                  ba.DualTeamSession))
711
712    def handlemessage(self, msg: Any) -> Any:
713        if isinstance(msg, ba.PlayerDiedMessage):
714            # Augment default behavior.
715            super().handlemessage(msg)
716            player = msg.getplayer(Player)
717            if not player.finished:
718                self.respawn_player(player, respawn_time=1)
719        else:
720            super().handlemessage(msg)