bascenev1lib.activity.coopscore

   1# Released under the MIT License. See LICENSE for details.
   2#
   3"""Provides a score screen for coop games."""
   4# pylint: disable=too-many-lines
   5
   6from __future__ import annotations
   7
   8import random
   9import logging
  10from typing import TYPE_CHECKING, override
  11
  12from bacommon.login import LoginType
  13import bascenev1 as bs
  14import bauiv1 as bui
  15
  16from bascenev1lib.actor.text import Text
  17from bascenev1lib.actor.zoomtext import ZoomText
  18
  19if TYPE_CHECKING:
  20    from typing import Any, Sequence
  21
  22    from bauiv1lib.store.button import StoreButton
  23    from bauiv1lib.league.rankbutton import LeagueRankButton
  24
  25
  26class CoopScoreScreen(bs.Activity[bs.Player, bs.Team]):
  27    """Score screen showing the results of a cooperative game."""
  28
  29    def __init__(self, settings: dict):
  30        # pylint: disable=too-many-statements
  31        super().__init__(settings)
  32
  33        plus = bs.app.plus
  34        assert plus is not None
  35
  36        # Keep prev activity alive while we fade in
  37        self.transition_time = 0.5
  38        self.inherits_tint = True
  39        self.inherits_vr_camera_offset = True
  40        self.inherits_music = True
  41        self.use_fixed_vr_overlay = True
  42
  43        self._do_new_rating: bool = self.session.tournament_id is not None
  44
  45        self._score_display_sound = bs.getsound('scoreHit01')
  46        self._score_display_sound_small = bs.getsound('scoreHit02')
  47        self.drum_roll_sound = bs.getsound('drumRoll')
  48        self.cymbal_sound = bs.getsound('cymbal')
  49
  50        self._replay_icon_texture = bui.gettexture('replayIcon')
  51        self._menu_icon_texture = bui.gettexture('menuIcon')
  52        self._next_level_icon_texture = bui.gettexture('nextLevelIcon')
  53
  54        self._campaign: bs.Campaign = settings['campaign']
  55
  56        self._have_achievements = (
  57            bs.app.classic is not None
  58            and bs.app.classic.ach.achievements_for_coop_level(
  59                self._campaign.name + ':' + settings['level']
  60            )
  61        )
  62
  63        self._game_service_icon_color: Sequence[float] | None
  64        self._game_service_achievements_texture: bui.Texture | None
  65        self._game_service_leaderboards_texture: bui.Texture | None
  66
  67        # Tie in to specific game services if they are active.
  68        adapter = plus.accounts.login_adapters.get(LoginType.GPGS)
  69        gpgs_active = adapter is not None and adapter.is_back_end_active()
  70        adapter = plus.accounts.login_adapters.get(LoginType.GAME_CENTER)
  71        game_center_active = (
  72            adapter is not None and adapter.is_back_end_active()
  73        )
  74
  75        if game_center_active:
  76            self._game_service_icon_color = (1.0, 1.0, 1.0)
  77            icon = bui.gettexture('gameCenterIcon')
  78            self._game_service_achievements_texture = icon
  79            self._game_service_leaderboards_texture = icon
  80            self._account_has_achievements = True
  81        elif gpgs_active:
  82            self._game_service_icon_color = (0.8, 1.0, 0.6)
  83            self._game_service_achievements_texture = bui.gettexture(
  84                'googlePlayAchievementsIcon'
  85            )
  86            self._game_service_leaderboards_texture = bui.gettexture(
  87                'googlePlayLeaderboardsIcon'
  88            )
  89            self._account_has_achievements = True
  90        else:
  91            self._game_service_icon_color = None
  92            self._game_service_achievements_texture = None
  93            self._game_service_leaderboards_texture = None
  94            self._account_has_achievements = False
  95
  96        self._cashregistersound = bs.getsound('cashRegister')
  97        self._gun_cocking_sound = bs.getsound('gunCocking')
  98        self._dingsound = bs.getsound('ding')
  99        self._score_link: str | None = None
 100        self._root_ui: bui.Widget | None = None
 101        self._background: bs.Actor | None = None
 102        self._old_best_rank = 0.0
 103        self._game_name_str: str | None = None
 104        self._game_config_str: str | None = None
 105
 106        # Ui bits.
 107        self._corner_button_offs: tuple[float, float] | None = None
 108        self._league_rank_button: LeagueRankButton | None = None
 109        self._store_button_instance: StoreButton | None = None
 110        self._restart_button: bui.Widget | None = None
 111        self._update_corner_button_positions_timer: bui.AppTimer | None = None
 112        self._next_level_error: bs.Actor | None = None
 113
 114        # Score/gameplay bits.
 115        self._was_complete: bool | None = None
 116        self._is_complete: bool | None = None
 117        self._newly_complete: bool | None = None
 118        self._is_more_levels: bool | None = None
 119        self._next_level_name: str | None = None
 120        self._show_info: dict[str, Any] | None = None
 121        self._name_str: str | None = None
 122        self._friends_loading_status: bs.Actor | None = None
 123        self._score_loading_status: bs.Actor | None = None
 124        self._tournament_time_remaining: float | None = None
 125        self._tournament_time_remaining_text: Text | None = None
 126        self._tournament_time_remaining_text_timer: bs.BaseTimer | None = None
 127        self._submit_score = self.session.submit_score
 128
 129        # Stuff for activity skip by pressing button
 130        self._birth_time = bs.time()
 131        self._min_view_time = 5.0
 132        self._allow_server_transition = False
 133        self._server_transitioning: bool | None = None
 134
 135        self._playerinfos: list[bs.PlayerInfo] = settings['playerinfos']
 136        assert isinstance(self._playerinfos, list)
 137        assert all(isinstance(i, bs.PlayerInfo) for i in self._playerinfos)
 138
 139        self._score: int | None = settings['score']
 140        assert isinstance(self._score, (int, type(None)))
 141
 142        self._fail_message: bs.Lstr | None = settings['fail_message']
 143        assert isinstance(self._fail_message, (bs.Lstr, type(None)))
 144
 145        self._begin_time: float | None = None
 146
 147        self._score_order: str
 148        if 'score_order' in settings:
 149            if not settings['score_order'] in ['increasing', 'decreasing']:
 150                raise ValueError(
 151                    'Invalid score order: ' + settings['score_order']
 152                )
 153            self._score_order = settings['score_order']
 154        else:
 155            self._score_order = 'increasing'
 156        assert isinstance(self._score_order, str)
 157
 158        self._score_type: str
 159        if 'score_type' in settings:
 160            if not settings['score_type'] in ['points', 'time']:
 161                raise ValueError(
 162                    'Invalid score type: ' + settings['score_type']
 163                )
 164            self._score_type = settings['score_type']
 165        else:
 166            self._score_type = 'points'
 167        assert isinstance(self._score_type, str)
 168
 169        self._level_name: str = settings['level']
 170        assert isinstance(self._level_name, str)
 171
 172        self._game_name_str = self._campaign.name + ':' + self._level_name
 173        self._game_config_str = (
 174            str(len(self._playerinfos))
 175            + 'p'
 176            + self._campaign.getlevel(self._level_name)
 177            .get_score_version_string()
 178            .replace(' ', '_')
 179        )
 180
 181        try:
 182            self._old_best_rank = self._campaign.getlevel(
 183                self._level_name
 184            ).rating
 185        except Exception:
 186            self._old_best_rank = 0.0
 187
 188        self._victory: bool = settings['outcome'] == 'victory'
 189
 190    @override
 191    def __del__(self) -> None:
 192        super().__del__()
 193
 194        # If our UI is still up, kill it.
 195        if self._root_ui and not self._root_ui.transitioning_out:
 196            with bui.ContextRef.empty():
 197                bui.containerwidget(edit=self._root_ui, transition='out_left')
 198
 199    @override
 200    def on_transition_in(self) -> None:
 201        from bascenev1lib.actor import background  # FIXME NO BSSTD
 202
 203        bs.set_analytics_screen('Coop Score Screen')
 204        super().on_transition_in()
 205        self._background = background.Background(
 206            fade_time=0.45, start_faded=False, show_logo=True
 207        )
 208
 209    def _ui_menu(self) -> None:
 210        # from bauiv1lib import specialoffer
 211
 212        # if specialoffer.show_offer():
 213        #     return
 214
 215        bui.containerwidget(edit=self._root_ui, transition='out_left')
 216        with self.context:
 217            bs.timer(0.1, bs.Call(bs.WeakCall(self.session.end)))
 218
 219    def _ui_restart(self) -> None:
 220        from bauiv1lib.tournamententry import TournamentEntryWindow
 221
 222        # from bauiv1lib import specialoffer
 223
 224        # if specialoffer.show_offer():
 225        #     return
 226
 227        # If we're in a tournament and it looks like there's no time left,
 228        # disallow.
 229        if self.session.tournament_id is not None:
 230            if self._tournament_time_remaining is None:
 231                bui.screenmessage(
 232                    bui.Lstr(resource='tournamentCheckingStateText'),
 233                    color=(1, 0, 0),
 234                )
 235                bui.getsound('error').play()
 236                return
 237            if self._tournament_time_remaining <= 0:
 238                bui.screenmessage(
 239                    bui.Lstr(resource='tournamentEndedText'), color=(1, 0, 0)
 240                )
 241                bui.getsound('error').play()
 242                return
 243
 244        # If there are currently fewer players than our session min,
 245        # don't allow.
 246        if len(self.players) < self.session.min_players:
 247            bui.screenmessage(
 248                bui.Lstr(resource='notEnoughPlayersRemainingText'),
 249                color=(1, 0, 0),
 250            )
 251            bui.getsound('error').play()
 252            return
 253
 254        self._campaign.set_selected_level(self._level_name)
 255
 256        # If this is a tournament, go back to the tournament-entry UI
 257        # otherwise just hop back in.
 258        tournament_id = self.session.tournament_id
 259        if tournament_id is not None:
 260            assert self._restart_button is not None
 261            TournamentEntryWindow(
 262                tournament_id=tournament_id,
 263                tournament_activity=self,
 264                position=self._restart_button.get_screen_space_center(),
 265            )
 266        else:
 267            bui.containerwidget(edit=self._root_ui, transition='out_left')
 268            self.can_show_ad_on_death = True
 269            with self.context:
 270                self.end({'outcome': 'restart'})
 271
 272    def _ui_next(self) -> None:
 273        # from bauiv1lib.specialoffer import show_offer
 274
 275        # if show_offer():
 276        #     return
 277
 278        # If we didn't just complete this level but are choosing to play the
 279        # next one, set it as current (this won't happen otherwise).
 280        if (
 281            self._is_complete
 282            and self._is_more_levels
 283            and not self._newly_complete
 284        ):
 285            assert self._next_level_name is not None
 286            self._campaign.set_selected_level(self._next_level_name)
 287        bui.containerwidget(edit=self._root_ui, transition='out_left')
 288        with self.context:
 289            self.end({'outcome': 'next_level'})
 290
 291    def _ui_gc(self) -> None:
 292        if bs.app.plus is not None:
 293            bs.app.plus.show_game_service_ui(
 294                'leaderboard',
 295                game=self._game_name_str,
 296                game_version=self._game_config_str,
 297            )
 298        else:
 299            logging.warning('show_game_service_ui requires plus feature-set')
 300
 301    def _ui_show_achievements(self) -> None:
 302        if bs.app.plus is not None:
 303            bs.app.plus.show_game_service_ui('achievements')
 304        else:
 305            logging.warning('show_game_service_ui requires plus feature-set')
 306
 307    def _ui_worlds_best(self) -> None:
 308        if self._score_link is None:
 309            bui.getsound('error').play()
 310            bui.screenmessage(
 311                bui.Lstr(resource='scoreListUnavailableText'), color=(1, 0.5, 0)
 312            )
 313        else:
 314            bui.open_url(self._score_link)
 315
 316    def _ui_error(self) -> None:
 317        with self.context:
 318            self._next_level_error = Text(
 319                bs.Lstr(resource='completeThisLevelToProceedText'),
 320                flash=True,
 321                maxwidth=360,
 322                scale=0.54,
 323                h_align=Text.HAlign.CENTER,
 324                color=(0.5, 0.7, 0.5, 1),
 325                position=(300, -235),
 326            )
 327            bui.getsound('error').play()
 328            bs.timer(
 329                2.0,
 330                bs.WeakCall(
 331                    self._next_level_error.handlemessage, bs.DieMessage()
 332                ),
 333            )
 334
 335    def _should_show_worlds_best_button(self) -> bool:
 336        # Link is too complicated to display with no browser.
 337        return bui.is_browser_likely_available()
 338
 339    def request_ui(self) -> None:
 340        """Set up a callback to show our UI at the next opportune time."""
 341        classic = bui.app.classic
 342        assert classic is not None
 343        # We don't want to just show our UI in case the user already has the
 344        # main menu up, so instead we add a callback for when the menu
 345        # closes; if we're still alive, we'll come up then.
 346        # If there's no main menu this gets called immediately.
 347        classic.add_main_menu_close_callback(bui.WeakCall(self.show_ui))
 348
 349    def show_ui(self) -> None:
 350        """Show the UI for restarting, playing the next Level, etc."""
 351        # pylint: disable=too-many-locals
 352        from bauiv1lib.store.button import StoreButton
 353        from bauiv1lib.league.rankbutton import LeagueRankButton
 354
 355        assert bui.app.classic is not None
 356
 357        env = bui.app.env
 358
 359        delay = 0.7 if (self._score is not None) else 0.0
 360
 361        # If there's no players left in the game, lets not show the UI
 362        # (that would allow restarting the game with zero players, etc).
 363        if not self.players:
 364            return
 365
 366        rootc = self._root_ui = bui.containerwidget(
 367            size=(0, 0), transition='in_right'
 368        )
 369
 370        h_offs = 7.0
 371        v_offs = -280.0
 372
 373        # We wanna prevent controllers users from popping up browsers
 374        # or game-center widgets in cases where they can't easily get back
 375        # to the game (like on mac).
 376        can_select_extra_buttons = bui.app.classic.platform == 'android'
 377
 378        bui.set_ui_input_device(None)  # Menu is up for grabs.
 379
 380        if self._have_achievements and self._account_has_achievements:
 381            bui.buttonwidget(
 382                parent=rootc,
 383                color=(0.45, 0.4, 0.5),
 384                position=(h_offs - 520, v_offs + 450 - 235 + 40),
 385                size=(300, 60),
 386                label=bui.Lstr(resource='achievementsText'),
 387                on_activate_call=bui.WeakCall(self._ui_show_achievements),
 388                transition_delay=delay + 1.5,
 389                icon=self._game_service_achievements_texture,
 390                icon_color=self._game_service_icon_color,
 391                autoselect=True,
 392                selectable=can_select_extra_buttons,
 393            )
 394
 395        if self._should_show_worlds_best_button():
 396            bui.buttonwidget(
 397                parent=rootc,
 398                color=(0.45, 0.4, 0.5),
 399                position=(160, v_offs + 439),
 400                size=(350, 62),
 401                label=(
 402                    bui.Lstr(resource='tournamentStandingsText')
 403                    if self.session.tournament_id is not None
 404                    else (
 405                        bui.Lstr(resource='worldsBestScoresText')
 406                        if self._score_type == 'points'
 407                        else bui.Lstr(resource='worldsBestTimesText')
 408                    )
 409                ),
 410                autoselect=True,
 411                on_activate_call=bui.WeakCall(self._ui_worlds_best),
 412                transition_delay=delay + 1.9,
 413                selectable=can_select_extra_buttons,
 414            )
 415        else:
 416            pass
 417
 418        show_next_button = self._is_more_levels and not (env.demo or env.arcade)
 419
 420        if not show_next_button:
 421            h_offs += 70
 422
 423        menu_button = bui.buttonwidget(
 424            parent=rootc,
 425            autoselect=True,
 426            position=(h_offs - 130 - 60, v_offs),
 427            size=(110, 85),
 428            label='',
 429            on_activate_call=bui.WeakCall(self._ui_menu),
 430        )
 431        bui.imagewidget(
 432            parent=rootc,
 433            draw_controller=menu_button,
 434            position=(h_offs - 130 - 60 + 22, v_offs + 14),
 435            size=(60, 60),
 436            texture=self._menu_icon_texture,
 437            opacity=0.8,
 438        )
 439        self._restart_button = restart_button = bui.buttonwidget(
 440            parent=rootc,
 441            autoselect=True,
 442            position=(h_offs - 60, v_offs),
 443            size=(110, 85),
 444            label='',
 445            on_activate_call=bui.WeakCall(self._ui_restart),
 446        )
 447        bui.imagewidget(
 448            parent=rootc,
 449            draw_controller=restart_button,
 450            position=(h_offs - 60 + 19, v_offs + 7),
 451            size=(70, 70),
 452            texture=self._replay_icon_texture,
 453            opacity=0.8,
 454        )
 455
 456        next_button: bui.Widget | None = None
 457
 458        # Our 'next' button is disabled if we haven't unlocked the next
 459        # level yet and invisible if there is none.
 460        if show_next_button:
 461            if self._is_complete:
 462                call = bui.WeakCall(self._ui_next)
 463                button_sound = True
 464                image_opacity = 0.8
 465                color = None
 466            else:
 467                call = bui.WeakCall(self._ui_error)
 468                button_sound = False
 469                image_opacity = 0.2
 470                color = (0.3, 0.3, 0.3)
 471            next_button = bui.buttonwidget(
 472                parent=rootc,
 473                autoselect=True,
 474                position=(h_offs + 130 - 60, v_offs),
 475                size=(110, 85),
 476                label='',
 477                on_activate_call=call,
 478                color=color,
 479                enable_sound=button_sound,
 480            )
 481            bui.imagewidget(
 482                parent=rootc,
 483                draw_controller=next_button,
 484                position=(h_offs + 130 - 60 + 12, v_offs + 5),
 485                size=(80, 80),
 486                texture=self._next_level_icon_texture,
 487                opacity=image_opacity,
 488            )
 489
 490        x_offs_extra = 0 if show_next_button else -100
 491        self._corner_button_offs = (
 492            h_offs + 300.0 + x_offs_extra,
 493            v_offs + 519.0,
 494        )
 495
 496        if env.demo or env.arcade:
 497            self._league_rank_button = None
 498            self._store_button_instance = None
 499        else:
 500            self._league_rank_button = LeagueRankButton(
 501                parent=rootc,
 502                position=(h_offs + 300 + x_offs_extra, v_offs + 519),
 503                size=(100, 60),
 504                scale=0.9,
 505                color=(0.4, 0.4, 0.9),
 506                textcolor=(0.9, 0.9, 2.0),
 507                transition_delay=0.0,
 508                smooth_update_delay=5.0,
 509            )
 510            self._store_button_instance = StoreButton(
 511                parent=rootc,
 512                position=(h_offs + 400 + x_offs_extra, v_offs + 519),
 513                show_tickets=True,
 514                sale_scale=0.85,
 515                size=(100, 60),
 516                scale=0.9,
 517                button_type='square',
 518                color=(0.35, 0.25, 0.45),
 519                textcolor=(0.9, 0.7, 1.0),
 520                transition_delay=0.0,
 521            )
 522
 523        bui.containerwidget(
 524            edit=rootc,
 525            selected_child=(
 526                next_button
 527                if (self._newly_complete and self._victory and show_next_button)
 528                else restart_button
 529            ),
 530            on_cancel_call=menu_button.activate,
 531        )
 532
 533        self._update_corner_button_positions()
 534        self._update_corner_button_positions_timer = bui.AppTimer(
 535            1.0, bui.WeakCall(self._update_corner_button_positions), repeat=True
 536        )
 537
 538    def _update_corner_button_positions(self) -> None:
 539        assert self._corner_button_offs is not None
 540        pos_x = self._corner_button_offs[0]
 541        pos_y = self._corner_button_offs[1]
 542        if self._league_rank_button is not None:
 543            self._league_rank_button.set_position((pos_x, pos_y))
 544        if self._store_button_instance is not None:
 545            self._store_button_instance.set_position((pos_x + 100, pos_y))
 546
 547    def _player_press(self) -> None:
 548        # (Only for headless builds).
 549
 550        # If this activity is a good 'end point', ask server-mode just once if
 551        # it wants to do anything special like switch sessions or kill the app.
 552        if (
 553            self._allow_server_transition
 554            and bs.app.classic is not None
 555            and bs.app.classic.server is not None
 556            and self._server_transitioning is None
 557        ):
 558            self._server_transitioning = (
 559                bs.app.classic.server.handle_transition()
 560            )
 561            assert isinstance(self._server_transitioning, bool)
 562
 563        # If server-mode is handling this, don't do anything ourself.
 564        if self._server_transitioning is True:
 565            return
 566
 567        # Otherwise restart current level.
 568        self._campaign.set_selected_level(self._level_name)
 569        with self.context:
 570            self.end({'outcome': 'restart'})
 571
 572    def _safe_assign(self, player: bs.Player) -> None:
 573        # (Only for headless builds).
 574
 575        # Just to be extra careful, don't assign if we're transitioning out.
 576        # (though theoretically that should be ok).
 577        if not self.is_transitioning_out() and player:
 578            player.assigninput(
 579                (
 580                    bs.InputType.JUMP_PRESS,
 581                    bs.InputType.PUNCH_PRESS,
 582                    bs.InputType.BOMB_PRESS,
 583                    bs.InputType.PICK_UP_PRESS,
 584                ),
 585                self._player_press,
 586            )
 587
 588    @override
 589    def on_player_join(self, player: bs.Player) -> None:
 590        super().on_player_join(player)
 591
 592        if bs.app.classic is not None and bs.app.classic.server is not None:
 593            # Host can't press retry button, so anyone can do it instead.
 594            time_till_assign = max(
 595                0, self._birth_time + self._min_view_time - bs.time()
 596            )
 597
 598            bs.timer(time_till_assign, bs.WeakCall(self._safe_assign, player))
 599
 600    @override
 601    def on_begin(self) -> None:
 602        # FIXME: Clean this up.
 603        # pylint: disable=too-many-statements
 604        # pylint: disable=too-many-branches
 605        # pylint: disable=too-many-locals
 606        super().on_begin()
 607
 608        app = bs.app
 609        env = app.env
 610        plus = app.plus
 611        assert plus is not None
 612
 613        self._begin_time = bs.time()
 614
 615        # Calc whether the level is complete and other stuff.
 616        levels = self._campaign.levels
 617        level = self._campaign.getlevel(self._level_name)
 618        self._was_complete = level.complete
 619        self._is_complete = self._was_complete or self._victory
 620        self._newly_complete = self._is_complete and not self._was_complete
 621        self._is_more_levels = (
 622            level.index < len(levels) - 1
 623        ) and self._campaign.sequential
 624
 625        # Any time we complete a level, set the next one as unlocked.
 626        if self._is_complete and self._is_more_levels:
 627            plus.add_v1_account_transaction(
 628                {
 629                    'type': 'COMPLETE_LEVEL',
 630                    'campaign': self._campaign.name,
 631                    'level': self._level_name,
 632                }
 633            )
 634            self._next_level_name = levels[level.index + 1].name
 635
 636            # If this is the first time we completed it, set the next one
 637            # as current.
 638            if self._newly_complete:
 639                cfg = app.config
 640                cfg['Selected Coop Game'] = (
 641                    self._campaign.name + ':' + self._next_level_name
 642                )
 643                cfg.commit()
 644                self._campaign.set_selected_level(self._next_level_name)
 645
 646        bs.timer(1.0, bs.WeakCall(self.request_ui))
 647
 648        if (
 649            self._is_complete
 650            and self._victory
 651            and self._is_more_levels
 652            and not (env.demo or env.arcade)
 653        ):
 654            Text(
 655                (
 656                    bs.Lstr(
 657                        value='${A}:\n',
 658                        subs=[('${A}', bs.Lstr(resource='levelUnlockedText'))],
 659                    )
 660                    if self._newly_complete
 661                    else bs.Lstr(
 662                        value='${A}:\n',
 663                        subs=[('${A}', bs.Lstr(resource='nextLevelText'))],
 664                    )
 665                ),
 666                transition=Text.Transition.IN_RIGHT,
 667                transition_delay=5.2,
 668                flash=self._newly_complete,
 669                scale=0.54,
 670                h_align=Text.HAlign.CENTER,
 671                maxwidth=270,
 672                color=(0.5, 0.7, 0.5, 1),
 673                position=(270, -235),
 674            ).autoretain()
 675            assert self._next_level_name is not None
 676            Text(
 677                bs.Lstr(translate=('coopLevelNames', self._next_level_name)),
 678                transition=Text.Transition.IN_RIGHT,
 679                transition_delay=5.2,
 680                flash=self._newly_complete,
 681                scale=0.7,
 682                h_align=Text.HAlign.CENTER,
 683                maxwidth=205,
 684                color=(0.5, 0.7, 0.5, 1),
 685                position=(270, -255),
 686            ).autoretain()
 687            if self._newly_complete:
 688                bs.timer(5.2, self._cashregistersound.play)
 689                bs.timer(5.2, self._dingsound.play)
 690
 691        offs_x = -195
 692        if len(self._playerinfos) > 1:
 693            pstr = bs.Lstr(
 694                value='- ${A} -',
 695                subs=[
 696                    (
 697                        '${A}',
 698                        bs.Lstr(
 699                            resource='multiPlayerCountText',
 700                            subs=[('${COUNT}', str(len(self._playerinfos)))],
 701                        ),
 702                    )
 703                ],
 704            )
 705        else:
 706            pstr = bs.Lstr(
 707                value='- ${A} -',
 708                subs=[('${A}', bs.Lstr(resource='singlePlayerCountText'))],
 709            )
 710        ZoomText(
 711            self._campaign.getlevel(self._level_name).displayname,
 712            maxwidth=800,
 713            flash=False,
 714            trail=False,
 715            color=(0.5, 1, 0.5, 1),
 716            h_align='center',
 717            scale=0.4,
 718            position=(0, 255),
 719            jitter=1.0,
 720        ).autoretain()
 721        Text(
 722            pstr,
 723            maxwidth=300,
 724            transition=Text.Transition.FADE_IN,
 725            scale=0.7,
 726            h_align=Text.HAlign.CENTER,
 727            v_align=Text.VAlign.CENTER,
 728            color=(0.5, 0.7, 0.5, 1),
 729            position=(0, 230),
 730        ).autoretain()
 731
 732        if app.classic is not None and app.classic.server is None:
 733            # If we're running in normal non-headless build, show this text
 734            # because only host can continue the game.
 735            adisp = plus.get_v1_account_display_string()
 736            txt = Text(
 737                bs.Lstr(
 738                    resource='waitingForHostText', subs=[('${HOST}', adisp)]
 739                ),
 740                maxwidth=300,
 741                transition=Text.Transition.FADE_IN,
 742                transition_delay=8.0,
 743                scale=0.85,
 744                h_align=Text.HAlign.CENTER,
 745                v_align=Text.VAlign.CENTER,
 746                color=(1, 1, 0, 1),
 747                position=(0, -230),
 748            ).autoretain()
 749            assert txt.node
 750            txt.node.client_only = True
 751        else:
 752            # In headless build, anyone can continue the game.
 753            sval = bs.Lstr(resource='pressAnyButtonPlayAgainText')
 754            Text(
 755                sval,
 756                v_attach=Text.VAttach.BOTTOM,
 757                h_align=Text.HAlign.CENTER,
 758                flash=True,
 759                vr_depth=50,
 760                position=(0, 60),
 761                scale=0.8,
 762                color=(0.5, 0.7, 0.5, 0.5),
 763                transition=Text.Transition.IN_BOTTOM_SLOW,
 764                transition_delay=self._min_view_time,
 765            ).autoretain()
 766
 767        if self._score is not None:
 768            bs.timer(0.35, self._score_display_sound_small.play)
 769
 770        # Vestigial remain; this stuff should just be instance vars.
 771        self._show_info = {}
 772
 773        if self._score is not None:
 774            bs.timer(0.8, bs.WeakCall(self._show_score_val, offs_x))
 775        else:
 776            bs.pushcall(bs.WeakCall(self._show_fail))
 777
 778        self._name_str = name_str = ', '.join(
 779            [p.name for p in self._playerinfos]
 780        )
 781
 782        self._score_loading_status = Text(
 783            bs.Lstr(
 784                value='${A}...',
 785                subs=[('${A}', bs.Lstr(resource='loadingText'))],
 786            ),
 787            position=(280, 150 + 30),
 788            color=(1, 1, 1, 0.4),
 789            transition=Text.Transition.FADE_IN,
 790            scale=0.7,
 791            transition_delay=2.0,
 792        )
 793
 794        if self._score is not None and self._submit_score:
 795            bs.timer(0.4, bs.WeakCall(self._play_drumroll))
 796
 797        # Add us to high scores, filter, and store.
 798        our_high_scores_all = self._campaign.getlevel(
 799            self._level_name
 800        ).get_high_scores()
 801
 802        our_high_scores = our_high_scores_all.setdefault(
 803            str(len(self._playerinfos)) + ' Player', []
 804        )
 805
 806        if self._score is not None:
 807            our_score: list | None = [
 808                self._score,
 809                {
 810                    'players': [
 811                        {'name': p.name, 'character': p.character}
 812                        for p in self._playerinfos
 813                    ]
 814                },
 815            ]
 816            our_high_scores.append(our_score)
 817        else:
 818            our_score = None
 819
 820        try:
 821            our_high_scores.sort(
 822                reverse=self._score_order == 'increasing', key=lambda x: x[0]
 823            )
 824        except Exception:
 825            logging.exception('Error sorting scores.')
 826            print(f'our_high_scores: {our_high_scores}')
 827
 828        del our_high_scores[10:]
 829
 830        if self._score is not None:
 831            sver = self._campaign.getlevel(
 832                self._level_name
 833            ).get_score_version_string()
 834            plus.add_v1_account_transaction(
 835                {
 836                    'type': 'SET_LEVEL_LOCAL_HIGH_SCORES',
 837                    'campaign': self._campaign.name,
 838                    'level': self._level_name,
 839                    'scoreVersion': sver,
 840                    'scores': our_high_scores_all,
 841                }
 842            )
 843        if plus.get_v1_account_state() != 'signed_in':
 844            # We expect this only in kiosk mode; complain otherwise.
 845            if not (env.demo or env.arcade):
 846                logging.error('got not-signed-in at score-submit; unexpected')
 847            bs.pushcall(bs.WeakCall(self._got_score_results, None))
 848        else:
 849            assert self._game_name_str is not None
 850            assert self._game_config_str is not None
 851            plus.submit_score(
 852                self._game_name_str,
 853                self._game_config_str,
 854                name_str,
 855                self._score,
 856                bs.WeakCall(self._got_score_results),
 857                order=self._score_order,
 858                tournament_id=self.session.tournament_id,
 859                score_type=self._score_type,
 860                campaign=self._campaign.name,
 861                level=self._level_name,
 862            )
 863
 864        # Apply the transactions we've been adding locally.
 865        plus.run_v1_account_transactions()
 866
 867        # If we're not doing the world's-best button, just show a title
 868        # instead.
 869        ts_height = 300
 870        ts_h_offs = 210
 871        v_offs = 40
 872        txt = Text(
 873            (
 874                bs.Lstr(resource='tournamentStandingsText')
 875                if self.session.tournament_id is not None
 876                else (
 877                    bs.Lstr(resource='worldsBestScoresText')
 878                    if self._score_type == 'points'
 879                    else bs.Lstr(resource='worldsBestTimesText')
 880                )
 881            ),
 882            maxwidth=210,
 883            position=(ts_h_offs - 10, ts_height / 2 + 25 + v_offs + 20),
 884            transition=Text.Transition.IN_LEFT,
 885            v_align=Text.VAlign.CENTER,
 886            scale=1.2,
 887            transition_delay=2.2,
 888        ).autoretain()
 889
 890        # If we've got a button on the server, only show this on clients.
 891        if self._should_show_worlds_best_button():
 892            assert txt.node
 893            txt.node.client_only = True
 894
 895        ts_height = 300
 896        ts_h_offs = -480
 897        v_offs = 40
 898        Text(
 899            (
 900                bs.Lstr(resource='yourBestScoresText')
 901                if self._score_type == 'points'
 902                else bs.Lstr(resource='yourBestTimesText')
 903            ),
 904            maxwidth=210,
 905            position=(ts_h_offs - 10, ts_height / 2 + 25 + v_offs + 20),
 906            transition=Text.Transition.IN_RIGHT,
 907            v_align=Text.VAlign.CENTER,
 908            scale=1.2,
 909            transition_delay=1.8,
 910        ).autoretain()
 911
 912        display_scores = list(our_high_scores)
 913        display_count = 5
 914
 915        while len(display_scores) < display_count:
 916            display_scores.append((0, None))
 917
 918        showed_ours = False
 919        h_offs_extra = 85 if self._score_type == 'points' else 130
 920        v_offs_extra = 20
 921        v_offs_names = 0
 922        scale = 1.0
 923        p_count = len(self._playerinfos)
 924        h_offs_extra -= 75
 925        if p_count > 1:
 926            h_offs_extra -= 20
 927        if p_count == 2:
 928            scale = 0.9
 929        elif p_count == 3:
 930            scale = 0.65
 931        elif p_count == 4:
 932            scale = 0.5
 933        times: list[tuple[float, float]] = []
 934        for i in range(display_count):
 935            times.insert(
 936                random.randrange(0, len(times) + 1),
 937                (1.9 + i * 0.05, 2.3 + i * 0.05),
 938            )
 939        for i in range(display_count):
 940            try:
 941                if display_scores[i][1] is None:
 942                    name_str = '-'
 943                else:
 944                    # noinspection PyUnresolvedReferences
 945                    name_str = ', '.join(
 946                        [p['name'] for p in display_scores[i][1]['players']]
 947                    )
 948            except Exception:
 949                logging.exception(
 950                    'Error calcing name_str for %s.', display_scores
 951                )
 952                name_str = '-'
 953            if display_scores[i] == our_score and not showed_ours:
 954                flash = True
 955                color0 = (0.6, 0.4, 0.1, 1.0)
 956                color1 = (0.6, 0.6, 0.6, 1.0)
 957                tdelay1 = 3.7
 958                tdelay2 = 3.7
 959                showed_ours = True
 960            else:
 961                flash = False
 962                color0 = (0.6, 0.4, 0.1, 1.0)
 963                color1 = (0.6, 0.6, 0.6, 1.0)
 964                tdelay1 = times[i][0]
 965                tdelay2 = times[i][1]
 966            Text(
 967                (
 968                    str(display_scores[i][0])
 969                    if self._score_type == 'points'
 970                    else bs.timestring((display_scores[i][0] * 10) / 1000.0)
 971                ),
 972                position=(
 973                    ts_h_offs + 20 + h_offs_extra,
 974                    v_offs_extra
 975                    + ts_height / 2
 976                    + -ts_height * (i + 1) / 10
 977                    + v_offs
 978                    + 11.0,
 979                ),
 980                h_align=Text.HAlign.RIGHT,
 981                v_align=Text.VAlign.CENTER,
 982                color=color0,
 983                flash=flash,
 984                transition=Text.Transition.IN_RIGHT,
 985                transition_delay=tdelay1,
 986            ).autoretain()
 987
 988            Text(
 989                bs.Lstr(value=name_str),
 990                position=(
 991                    ts_h_offs + 35 + h_offs_extra,
 992                    v_offs_extra
 993                    + ts_height / 2
 994                    + -ts_height * (i + 1) / 10
 995                    + v_offs_names
 996                    + v_offs
 997                    + 11.0,
 998                ),
 999                maxwidth=80.0 + 100.0 * len(self._playerinfos),
1000                v_align=Text.VAlign.CENTER,
1001                color=color1,
1002                flash=flash,
1003                scale=scale,
1004                transition=Text.Transition.IN_RIGHT,
1005                transition_delay=tdelay2,
1006            ).autoretain()
1007
1008        # Show achievements for this level.
1009        ts_height = -150
1010        ts_h_offs = -480
1011        v_offs = 40
1012
1013        # Only make this if we don't have the button
1014        # (never want clients to see it so no need for client-only
1015        # version, etc).
1016        if self._have_achievements:
1017            if not self._account_has_achievements:
1018                Text(
1019                    bs.Lstr(resource='achievementsText'),
1020                    position=(ts_h_offs - 10, ts_height / 2 + 25 + v_offs + 3),
1021                    maxwidth=210,
1022                    host_only=True,
1023                    transition=Text.Transition.IN_RIGHT,
1024                    v_align=Text.VAlign.CENTER,
1025                    scale=1.2,
1026                    transition_delay=2.8,
1027                ).autoretain()
1028
1029            assert self._game_name_str is not None
1030            assert bs.app.classic is not None
1031            achievements = bs.app.classic.ach.achievements_for_coop_level(
1032                self._game_name_str
1033            )
1034            hval = -455
1035            vval = -100
1036            tdelay = 0.0
1037            for ach in achievements:
1038                ach.create_display(hval, vval + v_offs, 3.0 + tdelay)
1039                vval -= 55
1040                tdelay += 0.250
1041
1042        bs.timer(5.0, bs.WeakCall(self._show_tips))
1043
1044    def _play_drumroll(self) -> None:
1045        bs.NodeActor(
1046            bs.newnode(
1047                'sound',
1048                attrs={
1049                    'sound': self.drum_roll_sound,
1050                    'positional': False,
1051                    'loop': False,
1052                },
1053            )
1054        ).autoretain()
1055
1056    def _got_friend_score_results(self, results: list[Any] | None) -> None:
1057        # FIXME: tidy this up
1058        # pylint: disable=too-many-locals
1059        # pylint: disable=too-many-branches
1060        # pylint: disable=too-many-statements
1061        from efro.util import asserttype
1062
1063        # delay a bit if results come in too fast
1064        assert self._begin_time is not None
1065        base_delay = max(0, 1.9 - (bs.time() - self._begin_time))
1066        ts_height = 300
1067        ts_h_offs = -550
1068        v_offs = 30
1069
1070        # Report in case of error.
1071        if results is None:
1072            self._friends_loading_status = Text(
1073                bs.Lstr(resource='friendScoresUnavailableText'),
1074                maxwidth=330,
1075                position=(-475, 150 + v_offs),
1076                color=(1, 1, 1, 0.4),
1077                transition=Text.Transition.FADE_IN,
1078                transition_delay=base_delay + 0.8,
1079                scale=0.7,
1080            )
1081            return
1082
1083        self._friends_loading_status = None
1084
1085        # Ok, it looks like we aren't able to reliably get a just-submitted
1086        # result returned in the score list, so we need to look for our score
1087        # in this list and replace it if ours is better or add ours otherwise.
1088        if self._score is not None:
1089            our_score_entry = [self._score, 'Me', True]
1090            for score in results:
1091                if score[2]:
1092                    if self._score_order == 'increasing':
1093                        our_score_entry[0] = max(score[0], self._score)
1094                    else:
1095                        our_score_entry[0] = min(score[0], self._score)
1096                    results.remove(score)
1097                    break
1098            results.append(our_score_entry)
1099            results.sort(
1100                reverse=self._score_order == 'increasing',
1101                key=lambda x: asserttype(x[0], int),
1102            )
1103
1104        # If we're not submitting our own score, we still want to change the
1105        # name of our own score to 'Me'.
1106        else:
1107            for score in results:
1108                if score[2]:
1109                    score[1] = 'Me'
1110                    break
1111        h_offs_extra = 80 if self._score_type == 'points' else 130
1112        v_offs_extra = 20
1113        v_offs_names = 0
1114        scale = 1.0
1115
1116        # Make sure there's at least 5.
1117        while len(results) < 5:
1118            results.append([0, '-', False])
1119        results = results[:5]
1120        times: list[tuple[float, float]] = []
1121        for i in range(len(results)):
1122            times.insert(
1123                random.randrange(0, len(times) + 1),
1124                (base_delay + i * 0.05, base_delay + 0.3 + i * 0.05),
1125            )
1126        for i, tval in enumerate(results):
1127            score = int(tval[0])
1128            name_str = tval[1]
1129            is_me = tval[2]
1130            if is_me and score == self._score:
1131                flash = True
1132                color0 = (0.6, 0.4, 0.1, 1.0)
1133                color1 = (0.6, 0.6, 0.6, 1.0)
1134                tdelay1 = base_delay + 1.0
1135                tdelay2 = base_delay + 1.0
1136            else:
1137                flash = False
1138                if is_me:
1139                    color0 = (0.6, 0.4, 0.1, 1.0)
1140                    color1 = (0.9, 1.0, 0.9, 1.0)
1141                else:
1142                    color0 = (0.6, 0.4, 0.1, 1.0)
1143                    color1 = (0.6, 0.6, 0.6, 1.0)
1144                tdelay1 = times[i][0]
1145                tdelay2 = times[i][1]
1146            if name_str != '-':
1147                Text(
1148                    (
1149                        str(score)
1150                        if self._score_type == 'points'
1151                        else bs.timestring((score * 10) / 1000.0)
1152                    ),
1153                    position=(
1154                        ts_h_offs + 20 + h_offs_extra,
1155                        v_offs_extra
1156                        + ts_height / 2
1157                        + -ts_height * (i + 1) / 10
1158                        + v_offs
1159                        + 11.0,
1160                    ),
1161                    h_align=Text.HAlign.RIGHT,
1162                    v_align=Text.VAlign.CENTER,
1163                    color=color0,
1164                    flash=flash,
1165                    transition=Text.Transition.IN_RIGHT,
1166                    transition_delay=tdelay1,
1167                ).autoretain()
1168            else:
1169                if is_me:
1170                    print('Error: got empty name_str on score result:', tval)
1171
1172            Text(
1173                bs.Lstr(value=name_str),
1174                position=(
1175                    ts_h_offs + 35 + h_offs_extra,
1176                    v_offs_extra
1177                    + ts_height / 2
1178                    + -ts_height * (i + 1) / 10
1179                    + v_offs_names
1180                    + v_offs
1181                    + 11.0,
1182                ),
1183                color=color1,
1184                maxwidth=160.0,
1185                v_align=Text.VAlign.CENTER,
1186                flash=flash,
1187                scale=scale,
1188                transition=Text.Transition.IN_RIGHT,
1189                transition_delay=tdelay2,
1190            ).autoretain()
1191
1192    def _got_score_results(self, results: dict[str, Any] | None) -> None:
1193        # FIXME: tidy this up
1194        # pylint: disable=too-many-locals
1195        # pylint: disable=too-many-branches
1196        # pylint: disable=too-many-statements
1197
1198        plus = bs.app.plus
1199        assert plus is not None
1200
1201        # We need to manually run this in the context of our activity
1202        # and only if we aren't shutting down.
1203        # (really should make the submit_score call handle that stuff itself)
1204        if self.expired:
1205            return
1206        with self.context:
1207            # Delay a bit if results come in too fast.
1208            assert self._begin_time is not None
1209            base_delay = max(0, 2.7 - (bs.time() - self._begin_time))
1210            v_offs = 20
1211            if results is None:
1212                self._score_loading_status = Text(
1213                    bs.Lstr(resource='worldScoresUnavailableText'),
1214                    position=(230, 150 + v_offs),
1215                    color=(1, 1, 1, 0.4),
1216                    transition=Text.Transition.FADE_IN,
1217                    transition_delay=base_delay + 0.3,
1218                    scale=0.7,
1219                )
1220            else:
1221                self._score_link = results['link']
1222                assert self._score_link is not None
1223                # Prepend our master-server addr if its a relative addr.
1224                if not self._score_link.startswith(
1225                    'http://'
1226                ) and not self._score_link.startswith('https://'):
1227                    self._score_link = (
1228                        plus.get_master_server_address()
1229                        + '/'
1230                        + self._score_link
1231                    )
1232                self._score_loading_status = None
1233                if 'tournamentSecondsRemaining' in results:
1234                    secs_remaining = results['tournamentSecondsRemaining']
1235                    assert isinstance(secs_remaining, int)
1236                    self._tournament_time_remaining = secs_remaining
1237                    self._tournament_time_remaining_text_timer = bs.BaseTimer(
1238                        1.0,
1239                        bs.WeakCall(
1240                            self._update_tournament_time_remaining_text
1241                        ),
1242                        repeat=True,
1243                    )
1244
1245            assert self._show_info is not None
1246            self._show_info['results'] = results
1247            if results is not None:
1248                if results['tops'] != '':
1249                    self._show_info['tops'] = results['tops']
1250                else:
1251                    self._show_info['tops'] = []
1252            offs_x = -195
1253            available = self._show_info['results'] is not None
1254            if self._score is not None:
1255                bs.basetimer(
1256                    (1.5 + base_delay),
1257                    bs.WeakCall(self._show_world_rank, offs_x),
1258                )
1259            ts_h_offs = 200
1260            ts_height = 300
1261
1262            # Show world tops.
1263            if available:
1264                # Show the number of games represented by this
1265                # list (except for in tournaments).
1266                if self.session.tournament_id is None:
1267                    Text(
1268                        bs.Lstr(
1269                            resource='lastGamesText',
1270                            subs=[
1271                                (
1272                                    '${COUNT}',
1273                                    str(self._show_info['results']['total']),
1274                                )
1275                            ],
1276                        ),
1277                        position=(
1278                            ts_h_offs - 35 + 95,
1279                            ts_height / 2 + 6 + v_offs - 41,
1280                        ),
1281                        color=(0.4, 0.4, 0.4, 1.0),
1282                        scale=0.7,
1283                        transition=Text.Transition.IN_RIGHT,
1284                        transition_delay=base_delay + 0.3,
1285                    ).autoretain()
1286                else:
1287                    v_offs += 20
1288
1289                h_offs_extra = 0
1290                v_offs_names = 0
1291                scale = 1.0
1292                p_count = len(self._playerinfos)
1293                if p_count > 1:
1294                    h_offs_extra -= 40
1295                if self._score_type != 'points':
1296                    h_offs_extra += 60
1297                if p_count == 2:
1298                    scale = 0.9
1299                elif p_count == 3:
1300                    scale = 0.65
1301                elif p_count == 4:
1302                    scale = 0.5
1303
1304                # Make sure there's at least 10.
1305                while len(self._show_info['tops']) < 10:
1306                    self._show_info['tops'].append([0, '-'])
1307
1308                times: list[tuple[float, float]] = []
1309                for i in range(len(self._show_info['tops'])):
1310                    times.insert(
1311                        random.randrange(0, len(times) + 1),
1312                        (base_delay + i * 0.05, base_delay + 0.4 + i * 0.05),
1313                    )
1314                for i, tval in enumerate(self._show_info['tops']):
1315                    score = int(tval[0])
1316                    name_str = tval[1]
1317                    if self._name_str == name_str and self._score == score:
1318                        flash = True
1319                        color0 = (0.6, 0.4, 0.1, 1.0)
1320                        color1 = (0.6, 0.6, 0.6, 1.0)
1321                        tdelay1 = base_delay + 1.0
1322                        tdelay2 = base_delay + 1.0
1323                    else:
1324                        flash = False
1325                        if self._name_str == name_str:
1326                            color0 = (0.6, 0.4, 0.1, 1.0)
1327                            color1 = (0.9, 1.0, 0.9, 1.0)
1328                        else:
1329                            color0 = (0.6, 0.4, 0.1, 1.0)
1330                            color1 = (0.6, 0.6, 0.6, 1.0)
1331                        tdelay1 = times[i][0]
1332                        tdelay2 = times[i][1]
1333
1334                    if name_str != '-':
1335                        Text(
1336                            (
1337                                str(score)
1338                                if self._score_type == 'points'
1339                                else bs.timestring((score * 10) / 1000.0)
1340                            ),
1341                            position=(
1342                                ts_h_offs + 20 + h_offs_extra,
1343                                ts_height / 2
1344                                + -ts_height * (i + 1) / 10
1345                                + v_offs
1346                                - 30.0,
1347                            ),
1348                            h_align=Text.HAlign.RIGHT,
1349                            v_align=Text.VAlign.CENTER,
1350                            color=color0,
1351                            flash=flash,
1352                            transition=Text.Transition.IN_LEFT,
1353                            transition_delay=tdelay1,
1354                        ).autoretain()
1355                    Text(
1356                        bs.Lstr(value=name_str),
1357                        position=(
1358                            ts_h_offs + 35 + h_offs_extra,
1359                            ts_height / 2
1360                            + -ts_height * (i + 1) / 10
1361                            + v_offs_names
1362                            + v_offs
1363                            - 30.0,
1364                        ),
1365                        maxwidth=80.0 + 100.0 * len(self._playerinfos),
1366                        v_align=Text.VAlign.CENTER,
1367                        color=color1,
1368                        flash=flash,
1369                        scale=scale,
1370                        transition=Text.Transition.IN_LEFT,
1371                        transition_delay=tdelay2,
1372                    ).autoretain()
1373
1374    def _show_tips(self) -> None:
1375        from bascenev1lib.actor.tipstext import TipsText
1376
1377        TipsText(offs_y=30).autoretain()
1378
1379    def _update_tournament_time_remaining_text(self) -> None:
1380        if self._tournament_time_remaining is None:
1381            return
1382        self._tournament_time_remaining = max(
1383            0, self._tournament_time_remaining - 1
1384        )
1385        if self._tournament_time_remaining_text is not None:
1386            val = bs.timestring(
1387                self._tournament_time_remaining,
1388                centi=False,
1389            )
1390            self._tournament_time_remaining_text.node.text = val
1391
1392    def _show_world_rank(self, offs_x: float) -> None:
1393        # FIXME: Tidy this up.
1394        # pylint: disable=too-many-locals
1395        # pylint: disable=too-many-branches
1396        # pylint: disable=too-many-statements
1397        assert bs.app.classic is not None
1398        assert self._show_info is not None
1399        available = self._show_info['results'] is not None
1400
1401        if available and self._submit_score:
1402            error = (
1403                self._show_info['results']['error']
1404                if 'error' in self._show_info['results']
1405                else None
1406            )
1407            rank = self._show_info['results']['rank']
1408            total = self._show_info['results']['total']
1409            rating = (
1410                10.0
1411                if total == 1
1412                else 10.0 * (1.0 - (float(rank - 1) / (total - 1)))
1413            )
1414            player_rank = self._show_info['results']['playerRank']
1415            best_player_rank = self._show_info['results']['bestPlayerRank']
1416        else:
1417            error = False
1418            rating = None
1419            player_rank = None
1420            best_player_rank = None
1421
1422        # If we've got tournament-seconds-remaining, show it.
1423        if self._tournament_time_remaining is not None:
1424            Text(
1425                bs.Lstr(resource='coopSelectWindow.timeRemainingText'),
1426                position=(-360, -70 - 100),
1427                color=(1, 1, 1, 0.7),
1428                h_align=Text.HAlign.CENTER,
1429                v_align=Text.VAlign.CENTER,
1430                transition=Text.Transition.FADE_IN,
1431                scale=0.8,
1432                maxwidth=300,
1433                transition_delay=2.0,
1434            ).autoretain()
1435            self._tournament_time_remaining_text = Text(
1436                '',
1437                position=(-360, -110 - 100),
1438                color=(1, 1, 1, 0.7),
1439                h_align=Text.HAlign.CENTER,
1440                v_align=Text.VAlign.CENTER,
1441                transition=Text.Transition.FADE_IN,
1442                scale=1.6,
1443                maxwidth=150,
1444                transition_delay=2.0,
1445            )
1446
1447        # If we're a tournament, show prizes.
1448        try:
1449            assert bs.app.classic is not None
1450            tournament_id = self.session.tournament_id
1451            if tournament_id is not None:
1452                if tournament_id in bs.app.classic.accounts.tournament_info:
1453                    tourney_info = bs.app.classic.accounts.tournament_info[
1454                        tournament_id
1455                    ]
1456                    # pylint: disable=useless-suppression
1457                    # pylint: disable=unbalanced-tuple-unpacking
1458                    (
1459                        pr1,
1460                        pv1,
1461                        pr2,
1462                        pv2,
1463                        pr3,
1464                        pv3,
1465                    ) = bs.app.classic.get_tournament_prize_strings(
1466                        tourney_info
1467                    )
1468                    # pylint: enable=unbalanced-tuple-unpacking
1469                    # pylint: enable=useless-suppression
1470
1471                    Text(
1472                        bs.Lstr(resource='coopSelectWindow.prizesText'),
1473                        position=(-360, -70 + 77),
1474                        color=(1, 1, 1, 0.7),
1475                        h_align=Text.HAlign.CENTER,
1476                        v_align=Text.VAlign.CENTER,
1477                        transition=Text.Transition.FADE_IN,
1478                        scale=1.0,
1479                        maxwidth=300,
1480                        transition_delay=2.0,
1481                    ).autoretain()
1482                    vval = -107 + 70
1483                    for rng, val in ((pr1, pv1), (pr2, pv2), (pr3, pv3)):
1484                        Text(
1485                            rng,
1486                            position=(-410 + 10, vval),
1487                            color=(1, 1, 1, 0.7),
1488                            h_align=Text.HAlign.RIGHT,
1489                            v_align=Text.VAlign.CENTER,
1490                            transition=Text.Transition.FADE_IN,
1491                            scale=0.6,
1492                            maxwidth=300,
1493                            transition_delay=2.0,
1494                        ).autoretain()
1495                        Text(
1496                            val,
1497                            position=(-390 + 10, vval),
1498                            color=(0.7, 0.7, 0.7, 1.0),
1499                            h_align=Text.HAlign.LEFT,
1500                            v_align=Text.VAlign.CENTER,
1501                            transition=Text.Transition.FADE_IN,
1502                            scale=0.8,
1503                            maxwidth=300,
1504                            transition_delay=2.0,
1505                        ).autoretain()
1506                        vval -= 35
1507        except Exception:
1508            logging.exception('Error showing prize ranges.')
1509
1510        if self._do_new_rating:
1511            if error:
1512                ZoomText(
1513                    bs.Lstr(resource='failText'),
1514                    flash=True,
1515                    trail=True,
1516                    scale=1.0 if available else 0.333,
1517                    tilt_translate=0.11,
1518                    h_align='center',
1519                    position=(190 + offs_x, -60),
1520                    maxwidth=200,
1521                    jitter=1.0,
1522                ).autoretain()
1523                Text(
1524                    bs.Lstr(translate=('serverResponses', error)),
1525                    position=(0, -140),
1526                    color=(1, 1, 1, 0.7),
1527                    h_align=Text.HAlign.CENTER,
1528                    v_align=Text.VAlign.CENTER,
1529                    transition=Text.Transition.FADE_IN,
1530                    scale=0.9,
1531                    maxwidth=400,
1532                    transition_delay=1.0,
1533                ).autoretain()
1534            elif self._submit_score:
1535                ZoomText(
1536                    (
1537                        ('#' + str(player_rank))
1538                        if player_rank is not None
1539                        else bs.Lstr(resource='unavailableText')
1540                    ),
1541                    flash=True,
1542                    trail=True,
1543                    scale=1.0 if available else 0.333,
1544                    tilt_translate=0.11,
1545                    h_align='center',
1546                    position=(190 + offs_x, -60),
1547                    maxwidth=200,
1548                    jitter=1.0,
1549                ).autoretain()
1550
1551                Text(
1552                    bs.Lstr(
1553                        value='${A}:',
1554                        subs=[('${A}', bs.Lstr(resource='rankText'))],
1555                    ),
1556                    position=(0, 36),
1557                    maxwidth=300,
1558                    transition=Text.Transition.FADE_IN,
1559                    h_align=Text.HAlign.CENTER,
1560                    v_align=Text.VAlign.CENTER,
1561                    transition_delay=0,
1562                ).autoretain()
1563                if best_player_rank is not None:
1564                    Text(
1565                        bs.Lstr(
1566                            resource='currentStandingText',
1567                            fallback_resource='bestRankText',
1568                            subs=[('${RANK}', str(best_player_rank))],
1569                        ),
1570                        position=(0, -155),
1571                        color=(1, 1, 1, 0.7),
1572                        h_align=Text.HAlign.CENTER,
1573                        transition=Text.Transition.FADE_IN,
1574                        scale=0.7,
1575                        transition_delay=1.0,
1576                    ).autoretain()
1577        else:
1578            assert rating is not None
1579            ZoomText(
1580                (
1581                    f'{rating:.1f}'
1582                    if available
1583                    else bs.Lstr(resource='unavailableText')
1584                ),
1585                flash=True,
1586                trail=True,
1587                scale=0.6 if available else 0.333,
1588                tilt_translate=0.11,
1589                h_align='center',
1590                position=(190 + offs_x, -94),
1591                maxwidth=200,
1592                jitter=1.0,
1593            ).autoretain()
1594
1595            if available:
1596                if rating >= 9.5:
1597                    stars = 3
1598                elif rating >= 7.5:
1599                    stars = 2
1600                elif rating > 0.0:
1601                    stars = 1
1602                else:
1603                    stars = 0
1604                star_tex = bs.gettexture('star')
1605                star_x = 135 + offs_x
1606                for _i in range(stars):
1607                    img = bs.NodeActor(
1608                        bs.newnode(
1609                            'image',
1610                            attrs={
1611                                'texture': star_tex,
1612                                'position': (star_x, -16),
1613                                'scale': (62, 62),
1614                                'opacity': 1.0,
1615                                'color': (2.2, 1.2, 0.3),
1616                                'absolute_scale': True,
1617                            },
1618                        )
1619                    ).autoretain()
1620
1621                    assert img.node
1622                    bs.animate(img.node, 'opacity', {0.15: 0, 0.4: 1})
1623                    star_x += 60
1624                for _i in range(3 - stars):
1625                    img = bs.NodeActor(
1626                        bs.newnode(
1627                            'image',
1628                            attrs={
1629                                'texture': star_tex,
1630                                'position': (star_x, -16),
1631                                'scale': (62, 62),
1632                                'opacity': 1.0,
1633                                'color': (0.3, 0.3, 0.3),
1634                                'absolute_scale': True,
1635                            },
1636                        )
1637                    ).autoretain()
1638                    assert img.node
1639                    bs.animate(img.node, 'opacity', {0.15: 0, 0.4: 1})
1640                    star_x += 60
1641
1642                def dostar(
1643                    count: int, xval: float, offs_y: float, score: str
1644                ) -> None:
1645                    Text(
1646                        score + ' =',
1647                        position=(xval, -64 + offs_y),
1648                        color=(0.6, 0.6, 0.6, 0.6),
1649                        h_align=Text.HAlign.CENTER,
1650                        v_align=Text.VAlign.CENTER,
1651                        transition=Text.Transition.FADE_IN,
1652                        scale=0.4,
1653                        transition_delay=1.0,
1654                    ).autoretain()
1655                    stx = xval + 20
1656                    for _i2 in range(count):
1657                        img2 = bs.NodeActor(
1658                            bs.newnode(
1659                                'image',
1660                                attrs={
1661                                    'texture': star_tex,
1662                                    'position': (stx, -64 + offs_y),
1663                                    'scale': (12, 12),
1664                                    'opacity': 0.7,
1665                                    'color': (2.2, 1.2, 0.3),
1666                                    'absolute_scale': True,
1667                                },
1668                            )
1669                        ).autoretain()
1670                        assert img2.node
1671                        bs.animate(img2.node, 'opacity', {1.0: 0.0, 1.5: 0.5})
1672                        stx += 13.0
1673
1674                dostar(1, -44 - 30, -112, '0.0')
1675                dostar(2, 10 - 30, -112, '7.5')
1676                dostar(3, 77 - 30, -112, '9.5')
1677            try:
1678                best_rank = self._campaign.getlevel(self._level_name).rating
1679            except Exception:
1680                best_rank = 0.0
1681
1682            if available:
1683                Text(
1684                    bs.Lstr(
1685                        resource='outOfText',
1686                        subs=[
1687                            (
1688                                '${RANK}',
1689                                str(int(self._show_info['results']['rank'])),
1690                            ),
1691                            (
1692                                '${ALL}',
1693                                str(self._show_info['results']['total']),
1694                            ),
1695                        ],
1696                    ),
1697                    position=(0, -155 if self._newly_complete else -145),
1698                    color=(1, 1, 1, 0.7),
1699                    h_align=Text.HAlign.CENTER,
1700                    transition=Text.Transition.FADE_IN,
1701                    scale=0.55,
1702                    transition_delay=1.0,
1703                ).autoretain()
1704
1705            new_best = best_rank > self._old_best_rank and best_rank > 0.0
1706            was_string = bs.Lstr(
1707                value=' ${A}',
1708                subs=[
1709                    ('${A}', bs.Lstr(resource='scoreWasText')),
1710                    ('${COUNT}', str(self._old_best_rank)),
1711                ],
1712            )
1713            if not self._newly_complete:
1714                Text(
1715                    (
1716                        bs.Lstr(
1717                            value='${A}${B}',
1718                            subs=[
1719                                (
1720                                    '${A}',
1721                                    bs.Lstr(resource='newPersonalBestText'),
1722                                ),
1723                                ('${B}', was_string),
1724                            ],
1725                        )
1726                        if new_best
1727                        else bs.Lstr(
1728                            resource='bestRatingText',
1729                            subs=[('${RATING}', str(best_rank))],
1730                        )
1731                    ),
1732                    position=(0, -165),
1733                    color=(1, 1, 1, 0.7),
1734                    flash=new_best,
1735                    h_align=Text.HAlign.CENTER,
1736                    transition=(
1737                        Text.Transition.IN_RIGHT
1738                        if new_best
1739                        else Text.Transition.FADE_IN
1740                    ),
1741                    scale=0.5,
1742                    transition_delay=1.0,
1743                ).autoretain()
1744
1745            Text(
1746                bs.Lstr(
1747                    value='${A}:',
1748                    subs=[('${A}', bs.Lstr(resource='ratingText'))],
1749                ),
1750                position=(0, 36),
1751                maxwidth=300,
1752                transition=Text.Transition.FADE_IN,
1753                h_align=Text.HAlign.CENTER,
1754                v_align=Text.VAlign.CENTER,
1755                transition_delay=0,
1756            ).autoretain()
1757
1758        if self._submit_score:
1759            bs.timer(0.35, self._score_display_sound.play)
1760            if not error:
1761                bs.timer(0.35, self.cymbal_sound.play)
1762
1763    def _show_fail(self) -> None:
1764        ZoomText(
1765            bs.Lstr(resource='failText'),
1766            maxwidth=300,
1767            flash=False,
1768            trail=True,
1769            h_align='center',
1770            tilt_translate=0.11,
1771            position=(0, 40),
1772            jitter=1.0,
1773        ).autoretain()
1774        if self._fail_message is not None:
1775            Text(
1776                self._fail_message,
1777                h_align=Text.HAlign.CENTER,
1778                position=(0, -130),
1779                maxwidth=300,
1780                color=(1, 1, 1, 0.5),
1781                transition=Text.Transition.FADE_IN,
1782                transition_delay=1.0,
1783            ).autoretain()
1784        bs.timer(0.35, self._score_display_sound.play)
1785
1786    def _show_score_val(self, offs_x: float) -> None:
1787        assert self._score_type is not None
1788        assert self._score is not None
1789        ZoomText(
1790            (
1791                str(self._score)
1792                if self._score_type == 'points'
1793                else bs.timestring((self._score * 10) / 1000.0)
1794            ),
1795            maxwidth=300,
1796            flash=True,
1797            trail=True,
1798            scale=1.0 if self._score_type == 'points' else 0.6,
1799            h_align='center',
1800            tilt_translate=0.11,
1801            position=(190 + offs_x, 115),
1802            jitter=1.0,
1803        ).autoretain()
1804        Text(
1805            (
1806                bs.Lstr(
1807                    value='${A}:',
1808                    subs=[('${A}', bs.Lstr(resource='finalScoreText'))],
1809                )
1810                if self._score_type == 'points'
1811                else bs.Lstr(
1812                    value='${A}:',
1813                    subs=[('${A}', bs.Lstr(resource='finalTimeText'))],
1814                )
1815            ),
1816            maxwidth=300,
1817            position=(0, 200),
1818            transition=Text.Transition.FADE_IN,
1819            h_align=Text.HAlign.CENTER,
1820            v_align=Text.VAlign.CENTER,
1821            transition_delay=0,
1822        ).autoretain()
1823        bs.timer(0.35, self._score_display_sound.play)