1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Elimination mini-game."""
  4
  5# ba_meta require api 9
  6# (see https://ballistica.net/wiki/meta-tag-system)
  7
  8from __future__ import annotations
  9
 10import logging
 11from typing import TYPE_CHECKING, override
 12
 13import bascenev1 as bs
 14
 15from bascenev1lib.actor.spazfactory import SpazFactory
 16from bascenev1lib.actor.scoreboard import Scoreboard
 17
 18if TYPE_CHECKING:
 19    from typing import Any, Sequence
 20
 21
 22class Icon(bs.Actor):
 23    """Creates in in-game icon on screen."""
 24
 25    def __init__(
 26        self,
 27        player: Player,
 28        position: tuple[float, float],
 29        scale: float,
 30        *,
 31        show_lives: bool = True,
 32        show_death: bool = True,
 33        name_scale: float = 1.0,
 34        name_maxwidth: float = 115.0,
 35        flatness: float = 1.0,
 36        shadow: float = 1.0,
 37    ):
 38        super().__init__()
 39
 40        self._player = player
 41        self._show_lives = show_lives
 42        self._show_death = show_death
 43        self._name_scale = name_scale
 44        self._outline_tex = bs.gettexture('characterIconMask')
 45
 46        icon = player.get_icon()
 47        self.node = bs.newnode(
 48            'image',
 49            delegate=self,
 50            attrs={
 51                'texture': icon['texture'],
 52                'tint_texture': icon['tint_texture'],
 53                'tint_color': icon['tint_color'],
 54                'vr_depth': 400,
 55                'tint2_color': icon['tint2_color'],
 56                'mask_texture': self._outline_tex,
 57                'opacity': 1.0,
 58                'absolute_scale': True,
 59                'attach': 'bottomCenter',
 60            },
 61        )
 62        self._name_text = bs.newnode(
 63            'text',
 64            owner=self.node,
 65            attrs={
 66                'text': bs.Lstr(value=player.getname()),
 67                'color': bs.safecolor(player.team.color),
 68                'h_align': 'center',
 69                'v_align': 'center',
 70                'vr_depth': 410,
 71                'maxwidth': name_maxwidth,
 72                'shadow': shadow,
 73                'flatness': flatness,
 74                'h_attach': 'center',
 75                'v_attach': 'bottom',
 76            },
 77        )
 78        if self._show_lives:
 79            self._lives_text = bs.newnode(
 80                'text',
 81                owner=self.node,
 82                attrs={
 83                    'text': 'x0',
 84                    'color': (1, 1, 0.5),
 85                    'h_align': 'left',
 86                    'vr_depth': 430,
 87                    'shadow': 1.0,
 88                    'flatness': 1.0,
 89                    'h_attach': 'center',
 90                    'v_attach': 'bottom',
 91                },
 92            )
 93        self.set_position_and_scale(position, scale)
 94
 95    def set_position_and_scale(
 96        self, position: tuple[float, float], scale: float
 97    ) -> None:
 98        """(Re)position the icon."""
 99        assert self.node
100        self.node.position = position
101        self.node.scale = [70.0 * scale]
102        self._name_text.position = (position[0], position[1] + scale * 52.0)
103        self._name_text.scale = 1.0 * scale * self._name_scale
104        if self._show_lives:
105            self._lives_text.position = (
106                position[0] + scale * 10.0,
107                position[1] - scale * 43.0,
108            )
109            self._lives_text.scale = 1.0 * scale
110
111    def update_for_lives(self) -> None:
112        """Update for the target player's current lives."""
113        if self._player:
114            lives = self._player.lives
115        else:
116            lives = 0
117        if self._show_lives:
118            if lives > 0:
119                self._lives_text.text = 'x' + str(lives - 1)
120            else:
121                self._lives_text.text = ''
122        if lives == 0:
123            self._name_text.opacity = 0.2
124            assert self.node
125            self.node.color = (0.7, 0.3, 0.3)
126            self.node.opacity = 0.2
127
128    def handle_player_spawned(self) -> None:
129        """Our player spawned; hooray!"""
130        if not self.node:
131            return
132        self.node.opacity = 1.0
133        self.update_for_lives()
134
135    def handle_player_died(self) -> None:
136        """Well poo; our player died."""
137        if not self.node:
138            return
139        if self._show_death:
140            bs.animate(
141                self.node,
142                'opacity',
143                {
144                    0.00: 1.0,
145                    0.05: 0.0,
146                    0.10: 1.0,
147                    0.15: 0.0,
148                    0.20: 1.0,
149                    0.25: 0.0,
150                    0.30: 1.0,
151                    0.35: 0.0,
152                    0.40: 1.0,
153                    0.45: 0.0,
154                    0.50: 1.0,
155                    0.55: 0.2,
156                },
157            )
158            lives = self._player.lives
159            if lives == 0:
160                bs.timer(0.6, self.update_for_lives)
161
162    @override
163    def handlemessage(self, msg: Any) -> Any:
164        if isinstance(msg, bs.DieMessage):
165            self.node.delete()
166            return None
167        return super().handlemessage(msg)
168
169
170class Player(bs.Player['Team']):
171    """Our player type for this game."""
172
173    def __init__(self) -> None:
174        self.lives = 0
175        self.icons: list[Icon] = []
176
177
178class Team(bs.Team[Player]):
179    """Our team type for this game."""
180
181    def __init__(self) -> None:
182        self.survival_seconds: int | None = None
183        self.spawn_order: list[Player] = []
184
185
186# ba_meta export bascenev1.GameActivity
187class EliminationGame(bs.TeamGameActivity[Player, Team]):
188    """Game type where last player(s) left alive win."""
189
190    name = 'Elimination'
191    description = 'Last remaining alive wins.'
192    scoreconfig = bs.ScoreConfig(
193        label='Survived', scoretype=bs.ScoreType.SECONDS, none_is_winner=True
194    )
195    # Show messages when players die since it's meaningful here.
196    announce_player_deaths = True
197
198    allow_mid_activity_joins = False
199
200    @override
201    @classmethod
202    def get_available_settings(
203        cls, sessiontype: type[bs.Session]
204    ) -> list[bs.Setting]:
205        settings = [
206            bs.IntSetting(
207                'Lives Per Player',
208                default=1,
209                min_value=1,
210                max_value=10,
211                increment=1,
212            ),
213            bs.IntChoiceSetting(
214                'Time Limit',
215                choices=[
216                    ('None', 0),
217                    ('1 Minute', 60),
218                    ('2 Minutes', 120),
219                    ('5 Minutes', 300),
220                    ('10 Minutes', 600),
221                    ('20 Minutes', 1200),
222                ],
223                default=0,
224            ),
225            bs.FloatChoiceSetting(
226                'Respawn Times',
227                choices=[
228                    ('Shorter', 0.25),
229                    ('Short', 0.5),
230                    ('Normal', 1.0),
231                    ('Long', 2.0),
232                    ('Longer', 4.0),
233                ],
234                default=1.0,
235            ),
236            bs.BoolSetting('Epic Mode', default=False),
237        ]
238        if issubclass(sessiontype, bs.DualTeamSession):
239            settings.append(bs.BoolSetting('Solo Mode', default=False))
240            settings.append(
241                bs.BoolSetting('Balance Total Lives', default=False)
242            )
243        return settings
244
245    @override
246    @classmethod
247    def supports_session_type(cls, sessiontype: type[bs.Session]) -> bool:
248        return issubclass(sessiontype, bs.DualTeamSession) or issubclass(
249            sessiontype, bs.FreeForAllSession
250        )
251
252    @override
253    @classmethod
254    def get_supported_maps(cls, sessiontype: type[bs.Session]) -> list[str]:
255        assert bs.app.classic is not None
256        return bs.app.classic.getmaps('melee')
257
258    def __init__(self, settings: dict):
259        super().__init__(settings)
260        self._scoreboard = Scoreboard()
261        self._start_time: float | None = None
262        self._vs_text: bs.Actor | None = None
263        self._round_end_timer: bs.Timer | None = None
264        self._epic_mode = bool(settings['Epic Mode'])
265        self._lives_per_player = int(settings['Lives Per Player'])
266        self._time_limit = float(settings['Time Limit'])
267        self._balance_total_lives = bool(
268            settings.get('Balance Total Lives', False)
269        )
270        self._solo_mode = bool(settings.get('Solo Mode', False))
271
272        # Base class overrides:
273        self.slow_motion = self._epic_mode
274        self.default_music = (
275            bs.MusicType.EPIC if self._epic_mode else bs.MusicType.SURVIVAL
276        )
277
278    @override
279    def get_instance_description(self) -> str | Sequence:
280        return (
281            'Last team standing wins.'
282            if isinstance(self.session, bs.DualTeamSession)
283            else 'Last one standing wins.'
284        )
285
286    @override
287    def get_instance_description_short(self) -> str | Sequence:
288        return (
289            'last team standing wins'
290            if isinstance(self.session, bs.DualTeamSession)
291            else 'last one standing wins'
292        )
293
294    @override
295    def on_player_join(self, player: Player) -> None:
296        player.lives = self._lives_per_player
297
298        if self._solo_mode:
299            player.team.spawn_order.append(player)
300            self._update_solo_mode()
301        else:
302            # Create our icon and spawn.
303            player.icons = [Icon(player, position=(0, 50), scale=0.8)]
304            if player.lives > 0:
305                self.spawn_player(player)
306
307        # Don't waste time doing this until begin.
308        if self.has_begun():
309            self._update_icons()
310
311    @override
312    def on_begin(self) -> None:
313        super().on_begin()
314        self._start_time = bs.time()
315        self.setup_standard_time_limit(self._time_limit)
316        self.setup_standard_powerup_drops()
317        if self._solo_mode:
318            self._vs_text = bs.NodeActor(
319                bs.newnode(
320                    'text',
321                    attrs={
322                        'position': (0, 105),
323                        'h_attach': 'center',
324                        'h_align': 'center',
325                        'maxwidth': 200,
326                        'shadow': 0.5,
327                        'vr_depth': 390,
328                        'scale': 0.6,
329                        'v_attach': 'bottom',
330                        'color': (0.8, 0.8, 0.3, 1.0),
331                        'text': bs.Lstr(resource='vsText'),
332                    },
333                )
334            )
335
336        # If balance-team-lives is on, add lives to the smaller team until
337        # total lives match.
338        if (
339            isinstance(self.session, bs.DualTeamSession)
340            and self._balance_total_lives
341            and self.teams[0].players
342            and self.teams[1].players
343        ):
344            if self._get_total_team_lives(
345                self.teams[0]
346            ) < self._get_total_team_lives(self.teams[1]):
347                lesser_team = self.teams[0]
348                greater_team = self.teams[1]
349            else:
350                lesser_team = self.teams[1]
351                greater_team = self.teams[0]
352            add_index = 0
353            while self._get_total_team_lives(
354                lesser_team
355            ) < self._get_total_team_lives(greater_team):
356                lesser_team.players[add_index].lives += 1
357                add_index = (add_index + 1) % len(lesser_team.players)
358
359        self._update_icons()
360
361        # We could check game-over conditions at explicit trigger points,
362        # but lets just do the simple thing and poll it.
363        bs.timer(1.0, self._update, repeat=True)
364
365    def _update_solo_mode(self) -> None:
366        # For both teams, find the first player on the spawn order list with
367        # lives remaining and spawn them if they're not alive.
368        for team in self.teams:
369            # Prune dead players from the spawn order.
370            team.spawn_order = [p for p in team.spawn_order if p]
371            for player in team.spawn_order:
372                assert isinstance(player, Player)
373                if player.lives > 0:
374                    if not player.is_alive():
375                        self.spawn_player(player)
376                    break
377
378    def _update_icons(self) -> None:
379        # pylint: disable=too-many-branches
380
381        # In free-for-all mode, everyone is just lined up along the bottom.
382        if isinstance(self.session, bs.FreeForAllSession):
383            count = len(self.teams)
384            x_offs = 85
385            xval = x_offs * (count - 1) * -0.5
386            for team in self.teams:
387                if len(team.players) == 1:
388                    player = team.players[0]
389                    for icon in player.icons:
390                        icon.set_position_and_scale((xval, 30), 0.7)
391                        icon.update_for_lives()
392                    xval += x_offs
393
394        # In teams mode we split up teams.
395        else:
396            if self._solo_mode:
397                # First off, clear out all icons.
398                for player in self.players:
399                    player.icons = []
400
401                # Now for each team, cycle through our available players
402                # adding icons.
403                for team in self.teams:
404                    if team.id == 0:
405                        xval = -60
406                        x_offs = -78
407                    else:
408                        xval = 60
409                        x_offs = 78
410                    is_first = True
411                    test_lives = 1
412                    while True:
413                        players_with_lives = [
414                            p
415                            for p in team.spawn_order
416                            if p and p.lives >= test_lives
417                        ]
418                        if not players_with_lives:
419                            break
420                        for player in players_with_lives:
421                            player.icons.append(
422                                Icon(
423                                    player,
424                                    position=(xval, (40 if is_first else 25)),
425                                    scale=1.0 if is_first else 0.5,
426                                    name_maxwidth=130 if is_first else 75,
427                                    name_scale=0.8 if is_first else 1.0,
428                                    flatness=0.0 if is_first else 1.0,
429                                    shadow=0.5 if is_first else 1.0,
430                                    show_death=is_first,
431                                    show_lives=False,
432                                )
433                            )
434                            xval += x_offs * (0.8 if is_first else 0.56)
435                            is_first = False
436                        test_lives += 1
437            # Non-solo mode.
438            else:
439                for team in self.teams:
440                    if team.id == 0:
441                        xval = -50
442                        x_offs = -85
443                    else:
444                        xval = 50
445                        x_offs = 85
446                    for player in team.players:
447                        for icon in player.icons:
448                            icon.set_position_and_scale((xval, 30), 0.7)
449                            icon.update_for_lives()
450                        xval += x_offs
451
452    def _get_spawn_point(self, player: Player) -> bs.Vec3 | None:
453        del player  # Unused.
454
455        # In solo-mode, if there's an existing live player on the map, spawn at
456        # whichever spot is farthest from them (keeps the action spread out).
457        if self._solo_mode:
458            living_player = None
459            living_player_pos = None
460            for team in self.teams:
461                for tplayer in team.players:
462                    if tplayer.is_alive():
463                        assert tplayer.node
464                        ppos = tplayer.node.position
465                        living_player = tplayer
466                        living_player_pos = ppos
467                        break
468            if living_player:
469                assert living_player_pos is not None
470                player_pos = bs.Vec3(living_player_pos)
471                points: list[tuple[float, bs.Vec3]] = []
472                for team in self.teams:
473                    start_pos = bs.Vec3(self.map.get_start_position(team.id))
474                    points.append(
475                        ((start_pos - player_pos).length(), start_pos)
476                    )
477                # Hmm.. we need to sort vectors too?
478                points.sort(key=lambda x: x[0])
479                return points[-1][1]
480        return None
481
482    @override
483    def spawn_player(self, player: Player) -> bs.Actor:
484        actor = self.spawn_player_spaz(player, self._get_spawn_point(player))
485        if not self._solo_mode:
486            bs.timer(0.3, bs.Call(self._print_lives, player))
487
488        # If we have any icons, update their state.
489        for icon in player.icons:
490            icon.handle_player_spawned()
491        return actor
492
493    def _print_lives(self, player: Player) -> None:
494        from bascenev1lib.actor import popuptext
495
496        # We get called in a timer so it's possible our player has left/etc.
497        if not player or not player.is_alive() or not player.node:
498            return
499
500        popuptext.PopupText(
501            'x' + str(player.lives - 1),
502            color=(1, 1, 0, 1),
503            offset=(0, -0.8, 0),
504            random_offset=0.0,
505            scale=1.8,
506            position=player.node.position,
507        ).autoretain()
508
509    @override
510    def on_player_leave(self, player: Player) -> None:
511        super().on_player_leave(player)
512        player.icons = []
513
514        # Remove us from spawn-order.
515        if self._solo_mode:
516            if player in player.team.spawn_order:
517                player.team.spawn_order.remove(player)
518
519        # Update icons in a moment since our team will be gone from the
520        # list then.
521        bs.timer(0, self._update_icons)
522
523        # If the player to leave was the last in spawn order and had
524        # their final turn currently in-progress, mark the survival time
525        # for their team.
526        if self._get_total_team_lives(player.team) == 0:
527            assert self._start_time is not None
528            player.team.survival_seconds = int(bs.time() - self._start_time)
529
530    def _get_total_team_lives(self, team: Team) -> int:
531        return sum(player.lives for player in team.players)
532
533    @override
534    def handlemessage(self, msg: Any) -> Any:
535        if isinstance(msg, bs.PlayerDiedMessage):
536            # Augment standard behavior.
537            super().handlemessage(msg)
538            player: Player = msg.getplayer(Player)
539
540            player.lives -= 1
541            if player.lives < 0:
542                logging.exception(
543                    "Got lives < 0 in Elim; this shouldn't happen. solo: %s",
544                    self._solo_mode,
545                )
546                player.lives = 0
547
548            # If we have any icons, update their state.
549            for icon in player.icons:
550                icon.handle_player_died()
551
552            # Play big death sound on our last death
553            # or for every one in solo mode.
554            if self._solo_mode or player.lives == 0:
555                SpazFactory.get().single_player_death_sound.play()
556
557            # If we hit zero lives, we're dead (and our team might be too).
558            if player.lives == 0:
559                # If the whole team is now dead, mark their survival time.
560                if self._get_total_team_lives(player.team) == 0:
561                    assert self._start_time is not None
562                    player.team.survival_seconds = int(
563                        bs.time() - self._start_time
564                    )
565            else:
566                # Otherwise, in regular mode, respawn.
567                if not self._solo_mode:
568                    self.respawn_player(player)
569
570            # In solo, put ourself at the back of the spawn order.
571            if self._solo_mode:
572                player.team.spawn_order.remove(player)
573                player.team.spawn_order.append(player)
574
575    def _update(self) -> None:
576        if self._solo_mode:
577            # For both teams, find the first player on the spawn order
578            # list with lives remaining and spawn them if they're not alive.
579            for team in self.teams:
580                # Prune dead players from the spawn order.
581                team.spawn_order = [p for p in team.spawn_order if p]
582                for player in team.spawn_order:
583                    assert isinstance(player, Player)
584                    if player.lives > 0:
585                        if not player.is_alive():
586                            self.spawn_player(player)
587                            self._update_icons()
588                        break
589
590        # If we're down to 1 or fewer living teams, start a timer to end
591        # the game (allows the dust to settle and draws to occur if deaths
592        # are close enough).
593        if len(self._get_living_teams()) < 2:
594            self._round_end_timer = bs.Timer(0.5, self.end_game)
595
596    def _get_living_teams(self) -> list[Team]:
597        return [
598            team
599            for team in self.teams
600            if len(team.players) > 0
601            and any(player.lives > 0 for player in team.players)
602        ]
603
604    @override
605    def end_game(self) -> None:
606        if self.has_ended():
607            return
608        results = bs.GameResults()
609        self._vs_text = None  # Kill our 'vs' if its there.
610        for team in self.teams:
611            results.set_team_score(team, team.survival_seconds)
612        self.end(results=results)