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