bauiv1lib.coop.browser

   1# Released under the MIT License. See LICENSE for details.
   2#
   3"""UI for browsing available co-op levels/games/etc."""
   4# FIXME: Break this up.
   5# pylint: disable=too-many-lines
   6
   7from __future__ import annotations
   8
   9import logging
  10from typing import TYPE_CHECKING, override
  11
  12
  13import bauiv1 as bui
  14
  15if TYPE_CHECKING:
  16    from typing import Any
  17
  18    from bauiv1lib.coop.tournamentbutton import TournamentButton
  19
  20HARD_REQUIRES_PRO = False
  21
  22
  23class CoopBrowserWindow(bui.MainWindow):
  24    """Window for browsing co-op levels/games/etc."""
  25
  26    def __init__(
  27        self,
  28        transition: str | None = 'in_right',
  29        origin_widget: bui.Widget | None = None,
  30    ):
  31        # pylint: disable=too-many-statements
  32        # pylint: disable=too-many-locals
  33        # pylint: disable=cyclic-import
  34
  35        plus = bui.app.plus
  36        assert plus is not None
  37
  38        # Preload some modules we use in a background thread so we won't
  39        # have a visual hitch when the user taps them.
  40        bui.app.threadpool.submit_no_wait(self._preload_modules)
  41
  42        bui.set_analytics_screen('Coop Window')
  43
  44        app = bui.app
  45        classic = app.classic
  46        assert classic is not None
  47        cfg = app.config
  48
  49        # Quick note to players that tourneys won't work in ballistica
  50        # core builds. (need to split the word so it won't get subbed
  51        # out)
  52        if 'ballistica' + 'kit' == bui.appname() and bui.do_once():
  53            bui.apptimer(
  54                1.0,
  55                lambda: bui.screenmessage(
  56                    bui.Lstr(resource='noTournamentsInTestBuildText'),
  57                    color=(1, 1, 0),
  58                ),
  59            )
  60
  61        # Try to recreate the same number of buttons we had last time so our
  62        # re-selection code works.
  63        self._tournament_button_count = app.config.get('Tournament Rows', 0)
  64        assert isinstance(self._tournament_button_count, int)
  65
  66        self.star_tex = bui.gettexture('star')
  67        self.lsbt = bui.getmesh('level_select_button_transparent')
  68        self.lsbo = bui.getmesh('level_select_button_opaque')
  69        self.a_outline_tex = bui.gettexture('achievementOutline')
  70        self.a_outline_mesh = bui.getmesh('achievementOutline')
  71        self._campaign_sub_container: bui.Widget | None = None
  72        self._tournament_info_button: bui.Widget | None = None
  73        self._easy_button: bui.Widget | None = None
  74        self._hard_button: bui.Widget | None = None
  75        self._hard_button_lock_image: bui.Widget | None = None
  76        self._campaign_percent_text: bui.Widget | None = None
  77
  78        uiscale = app.ui_v1.uiscale
  79        self._width = 1600 if uiscale is bui.UIScale.SMALL else 1120
  80        self._height = (
  81            1200
  82            if uiscale is bui.UIScale.SMALL
  83            else 730 if uiscale is bui.UIScale.MEDIUM else 800
  84        )
  85        self._r = 'coopSelectWindow'
  86        top_extra = 0 if uiscale is bui.UIScale.SMALL else 0
  87
  88        self._tourney_data_up_to_date = False
  89
  90        self._campaign_difficulty = plus.get_v1_account_misc_val(
  91            'campaignDifficulty', 'easy'
  92        )
  93
  94        if (
  95            self._campaign_difficulty == 'hard'
  96            and HARD_REQUIRES_PRO
  97            and not classic.accounts.have_pro_options()
  98        ):
  99            plus.add_v1_account_transaction(
 100                {
 101                    'type': 'SET_MISC_VAL',
 102                    'name': 'campaignDifficulty',
 103                    'value': 'easy',
 104                }
 105            )
 106            self._campaign_difficulty = 'easy'
 107
 108        # Do some fancy math to fill all available screen area up to the
 109        # size of our backing container. This lets us fit to the exact
 110        # screen shape at small ui scale.
 111        screensize = bui.get_virtual_screen_size()
 112        scale = (
 113            1.5
 114            if uiscale is bui.UIScale.SMALL
 115            else 0.8 if uiscale is bui.UIScale.MEDIUM else 0.75
 116        )
 117        # Calc screen size in our local container space and clamp to a
 118        # bit smaller than our container size.
 119        target_width = min(self._width - 120, screensize[0] / scale)
 120        target_height = min(self._height - 120, screensize[1] / scale)
 121
 122        # To get top/left coords, go to the center of our window and
 123        # offset by half the width/height of our target area.
 124        yoffs = 0.5 * self._height + 0.5 * target_height + 30.0
 125
 126        self._scroll_width = target_width
 127        self._scroll_height = target_height - 40
 128        self._scroll_bottom = yoffs - 70 - self._scroll_height
 129
 130        super().__init__(
 131            root_widget=bui.containerwidget(
 132                size=(self._width, self._height + top_extra),
 133                toolbar_visibility='menu_full',
 134                scale=scale,
 135            ),
 136            transition=transition,
 137            origin_widget=origin_widget,
 138            # We're affected by screen size only at small ui-scale.
 139            refresh_on_screen_size_changes=uiscale is bui.UIScale.SMALL,
 140        )
 141
 142        if uiscale is bui.UIScale.SMALL:
 143            self._back_button = bui.get_special_widget('back_button')
 144            bui.containerwidget(
 145                edit=self._root_widget, on_cancel_call=self.main_window_back
 146            )
 147        else:
 148            self._back_button = bui.buttonwidget(
 149                parent=self._root_widget,
 150                position=(75, yoffs - 48.0),
 151                size=(60, 50),
 152                scale=1.2,
 153                autoselect=True,
 154                label=bui.charstr(bui.SpecialChar.BACK),
 155                button_type='backSmall',
 156                on_activate_call=self.main_window_back,
 157            )
 158            bui.containerwidget(
 159                edit=self._root_widget, cancel_button=self._back_button
 160            )
 161
 162        self._last_tournament_query_time: float | None = None
 163        self._last_tournament_query_response_time: float | None = None
 164        self._doing_tournament_query = False
 165
 166        self._selected_campaign_level = cfg.get(
 167            'Selected Coop Campaign Level', None
 168        )
 169        self._selected_custom_level = cfg.get(
 170            'Selected Coop Custom Level', None
 171        )
 172
 173        if uiscale is bui.UIScale.SMALL:
 174            tmaxw = 130 if bui.get_virtual_screen_size()[0] < 1320 else 175
 175        else:
 176            tmaxw = 300
 177
 178        # Don't want initial construction affecting our last-selected.
 179        self._do_selection_callbacks = False
 180        bui.textwidget(
 181            parent=self._root_widget,
 182            position=(
 183                self._width * 0.5,
 184                yoffs - (50 if uiscale is bui.UIScale.SMALL else 24),
 185            ),
 186            size=(0, 0),
 187            text=bui.Lstr(
 188                resource='playModes.singlePlayerCoopText',
 189                fallback_resource='playModes.coopText',
 190            ),
 191            h_align='center',
 192            color=app.ui_v1.title_color,
 193            scale=0.85 if uiscale is bui.UIScale.SMALL else 1.5,
 194            maxwidth=tmaxw,
 195            v_align='center',
 196        )
 197
 198        self._selected_row = cfg.get('Selected Coop Row', None)
 199
 200        self._subcontainerwidth = 800.0
 201        self._subcontainerheight = 1400.0
 202
 203        self._scrollwidget = bui.scrollwidget(
 204            parent=self._root_widget,
 205            highlight=False,
 206            size=(self._scroll_width, self._scroll_height),
 207            position=(
 208                self._width * 0.5 - self._scroll_width * 0.5,
 209                self._scroll_bottom,
 210            ),
 211            simple_culling_v=10.0,
 212            claims_left_right=True,
 213            selection_loops_to_parent=True,
 214            border_opacity=0.4,
 215        )
 216
 217        if uiscale is bui.UIScale.SMALL:
 218            blotchwidth = 500.0
 219            blotchheight = 200.0
 220            bimg = bui.imagewidget(
 221                parent=self._root_widget,
 222                texture=bui.gettexture('uiAtlas'),
 223                mesh_transparent=bui.getmesh('windowBGBlotch'),
 224                position=(
 225                    self._width * 0.5
 226                    - self._scroll_width * 0.5
 227                    + 60.0
 228                    - blotchwidth * 0.5,
 229                    self._scroll_bottom - blotchheight * 0.5,
 230                ),
 231                size=(blotchwidth, blotchheight),
 232                color=(0.4, 0.37, 0.49),
 233                # color=(1, 0, 0),
 234            )
 235            bui.widget(edit=bimg, depth_range=(0.9, 1.0))
 236            bimg = bui.imagewidget(
 237                parent=self._root_widget,
 238                texture=bui.gettexture('uiAtlas'),
 239                mesh_transparent=bui.getmesh('windowBGBlotch'),
 240                position=(
 241                    self._width * 0.5
 242                    + self._scroll_width * 0.5
 243                    - 60.0
 244                    - blotchwidth * 0.5,
 245                    self._scroll_bottom - blotchheight * 0.5,
 246                ),
 247                size=(blotchwidth, blotchheight),
 248                color=(0.4, 0.37, 0.49),
 249                # color=(1, 0, 0),
 250            )
 251            bui.widget(edit=bimg, depth_range=(0.9, 1.0))
 252
 253        self._subcontainer: bui.Widget | None = None
 254
 255        # Take note of our account state; we'll refresh later if this changes.
 256        self._account_state_num = plus.get_v1_account_state_num()
 257
 258        # Same for fg/bg state.
 259        self._fg_state = app.fg_state
 260
 261        self._refresh()
 262        self._restore_state()
 263
 264        # Even though we might display cached tournament data immediately, we
 265        # don't consider it valid until we've pinged.
 266        # the server for an update
 267        self._tourney_data_up_to_date = False
 268
 269        # If we've got a cached tournament list for our account and info for
 270        # each one of those tournaments, go ahead and display it as a
 271        # starting point.
 272        if (
 273            classic.accounts.account_tournament_list is not None
 274            and classic.accounts.account_tournament_list[0]
 275            == plus.get_v1_account_state_num()
 276            and all(
 277                t_id in classic.accounts.tournament_info
 278                for t_id in classic.accounts.account_tournament_list[1]
 279            )
 280        ):
 281            tourney_data = [
 282                classic.accounts.tournament_info[t_id]
 283                for t_id in classic.accounts.account_tournament_list[1]
 284            ]
 285            self._update_for_data(tourney_data)
 286
 287        # This will pull new data periodically, update timers, etc.
 288        self._update_timer = bui.AppTimer(
 289            1.0, bui.WeakCall(self._update), repeat=True
 290        )
 291        self._update()
 292
 293    @override
 294    def get_main_window_state(self) -> bui.MainWindowState:
 295        # Support recreating our window for back/refresh purposes.
 296        cls = type(self)
 297        return bui.BasicMainWindowState(
 298            create_call=lambda transition, origin_widget: cls(
 299                transition=transition, origin_widget=origin_widget
 300            )
 301        )
 302
 303    @override
 304    def on_main_window_close(self) -> None:
 305        self._save_state()
 306
 307    @staticmethod
 308    def _preload_modules() -> None:
 309        """Preload modules we use; avoids hitches (called in bg thread)."""
 310        # pylint: disable=cyclic-import
 311        import bauiv1lib.purchase as _unused1
 312        import bauiv1lib.coop.gamebutton as _unused2
 313        import bauiv1lib.confirm as _unused3
 314        import bauiv1lib.account as _unused4
 315        import bauiv1lib.league.rankwindow as _unused5
 316        import bauiv1lib.store.browser as _unused6
 317        import bauiv1lib.account.viewer as _unused7
 318        import bauiv1lib.tournamentscores as _unused8
 319        import bauiv1lib.tournamententry as _unused9
 320        import bauiv1lib.play as _unused10
 321        import bauiv1lib.coop.tournamentbutton as _unused11
 322
 323    def _update(self) -> None:
 324        plus = bui.app.plus
 325        assert plus is not None
 326
 327        # Do nothing if we've somehow outlived our actual UI.
 328        if not self._root_widget:
 329            return
 330
 331        cur_time = bui.apptime()
 332
 333        # If its been a while since we got a tournament update, consider
 334        # the data invalid (prevents us from joining tournaments if our
 335        # internet connection goes down for a while).
 336        if (
 337            self._last_tournament_query_response_time is None
 338            or bui.apptime() - self._last_tournament_query_response_time
 339            > 60.0 * 2
 340        ):
 341            self._tourney_data_up_to_date = False
 342
 343        # If our account login state has changed, do a
 344        # full request.
 345        account_state_num = plus.get_v1_account_state_num()
 346
 347        if account_state_num != self._account_state_num:
 348            self._account_state_num = account_state_num
 349            self._save_state()
 350            self._refresh()
 351
 352            # Also encourage a new tournament query since this will clear out
 353            # our current results.
 354            if not self._doing_tournament_query:
 355                self._last_tournament_query_time = None
 356
 357        # If we've been backgrounded/foregrounded, invalidate our
 358        # tournament entries (they will be refreshed below asap).
 359        if self._fg_state != bui.app.fg_state:
 360            self._tourney_data_up_to_date = False
 361
 362        # Send off a new tournament query if its been long enough or whatnot.
 363        if not self._doing_tournament_query and (
 364            self._last_tournament_query_time is None
 365            or cur_time - self._last_tournament_query_time > 30.0
 366            or self._fg_state != bui.app.fg_state
 367        ):
 368            self._fg_state = bui.app.fg_state
 369            self._last_tournament_query_time = cur_time
 370            self._doing_tournament_query = True
 371            plus.tournament_query(
 372                args={'source': 'coop window refresh', 'numScores': 1},
 373                callback=bui.WeakCall(self._on_tournament_query_response),
 374            )
 375
 376        # Decrement time on our tournament buttons.
 377        ads_enabled = plus.have_incentivized_ad()
 378        for tbtn in self._tournament_buttons:
 379            tbtn.time_remaining = max(0, tbtn.time_remaining - 1)
 380            if tbtn.time_remaining_value_text is not None:
 381                bui.textwidget(
 382                    edit=tbtn.time_remaining_value_text,
 383                    text=(
 384                        bui.timestring(tbtn.time_remaining, centi=False)
 385                        if (
 386                            tbtn.has_time_remaining
 387                            and self._tourney_data_up_to_date
 388                        )
 389                        else '-'
 390                    ),
 391                )
 392
 393            # Also adjust the ad icon visibility.
 394            if tbtn.allow_ads and plus.has_video_ads():
 395                bui.imagewidget(
 396                    edit=tbtn.entry_fee_ad_image,
 397                    opacity=1.0 if ads_enabled else 0.25,
 398                )
 399                bui.textwidget(
 400                    edit=tbtn.entry_fee_text_remaining,
 401                    color=(0.6, 0.6, 0.6, 1 if ads_enabled else 0.2),
 402                )
 403
 404        self._update_hard_mode_lock_image()
 405
 406    def _update_hard_mode_lock_image(self) -> None:
 407        assert bui.app.classic is not None
 408        try:
 409            bui.imagewidget(
 410                edit=self._hard_button_lock_image,
 411                opacity=(
 412                    0.0
 413                    if (
 414                        (not HARD_REQUIRES_PRO)
 415                        or bui.app.classic.accounts.have_pro_options()
 416                    )
 417                    else 1.0
 418                ),
 419            )
 420        except Exception:
 421            logging.exception('Error updating campaign lock.')
 422
 423    def _update_for_data(self, data: list[dict[str, Any]] | None) -> None:
 424
 425        # If the number of tournaments or challenges in the data differs
 426        # from our current arrangement, refresh with the new number.
 427        if (data is None and self._tournament_button_count != 0) or (
 428            data is not None and (len(data) != self._tournament_button_count)
 429        ):
 430            self._tournament_button_count = len(data) if data is not None else 0
 431            bui.app.config['Tournament Rows'] = self._tournament_button_count
 432            self._refresh()
 433
 434        # Update all of our tourney buttons based on whats in data.
 435        for i, tbtn in enumerate(self._tournament_buttons):
 436            assert data is not None
 437            tbtn.update_for_data(data[i])
 438
 439    def _on_tournament_query_response(
 440        self, data: dict[str, Any] | None
 441    ) -> None:
 442        plus = bui.app.plus
 443        assert plus is not None
 444
 445        assert bui.app.classic is not None
 446        accounts = bui.app.classic.accounts
 447        if data is not None:
 448            tournament_data = data['t']  # This used to be the whole payload.
 449            self._last_tournament_query_response_time = bui.apptime()
 450        else:
 451            tournament_data = None
 452
 453        # Keep our cached tourney info up to date.
 454        if data is not None:
 455            self._tourney_data_up_to_date = True
 456            accounts.cache_tournament_info(tournament_data)
 457
 458            # Also cache the current tourney list/order for this account.
 459            accounts.account_tournament_list = (
 460                plus.get_v1_account_state_num(),
 461                [e['tournamentID'] for e in tournament_data],
 462            )
 463
 464        self._doing_tournament_query = False
 465        self._update_for_data(tournament_data)
 466
 467    def _set_campaign_difficulty(self, difficulty: str) -> None:
 468        # pylint: disable=cyclic-import
 469        from bauiv1lib.purchase import PurchaseWindow
 470
 471        plus = bui.app.plus
 472        assert plus is not None
 473
 474        assert bui.app.classic is not None
 475        if difficulty != self._campaign_difficulty:
 476            if (
 477                difficulty == 'hard'
 478                and HARD_REQUIRES_PRO
 479                and not bui.app.classic.accounts.have_pro_options()
 480            ):
 481                PurchaseWindow(items=['pro'])
 482                return
 483            bui.getsound('gunCocking').play()
 484            if difficulty not in ('easy', 'hard'):
 485                print('ERROR: invalid campaign difficulty:', difficulty)
 486                difficulty = 'easy'
 487            self._campaign_difficulty = difficulty
 488            plus.add_v1_account_transaction(
 489                {
 490                    'type': 'SET_MISC_VAL',
 491                    'name': 'campaignDifficulty',
 492                    'value': difficulty,
 493                }
 494            )
 495            self._refresh_campaign_row()
 496        else:
 497            bui.getsound('click01').play()
 498
 499    def _refresh_campaign_row(self) -> None:
 500        # pylint: disable=too-many-locals
 501        # pylint: disable=too-many-statements
 502        # pylint: disable=cyclic-import
 503        from bauiv1lib.coop.gamebutton import GameButton
 504
 505        parent_widget = self._campaign_sub_container
 506
 507        # Clear out anything in the parent widget already.
 508        assert parent_widget is not None
 509        for child in parent_widget.get_children():
 510            child.delete()
 511
 512        next_widget_down = self._tournament_info_button
 513
 514        h = 0
 515        v2 = -2
 516        sel_color = (0.75, 0.85, 0.5)
 517        sel_color_hard = (0.4, 0.7, 0.2)
 518        un_sel_color = (0.5, 0.5, 0.5)
 519        sel_textcolor = (2, 2, 0.8)
 520        un_sel_textcolor = (0.6, 0.6, 0.6)
 521        self._easy_button = bui.buttonwidget(
 522            parent=parent_widget,
 523            position=(h + 30, v2 + 105),
 524            size=(120, 70),
 525            label=bui.Lstr(resource='difficultyEasyText'),
 526            button_type='square',
 527            autoselect=True,
 528            enable_sound=False,
 529            on_activate_call=bui.Call(self._set_campaign_difficulty, 'easy'),
 530            on_select_call=bui.Call(self.sel_change, 'campaign', 'easyButton'),
 531            color=(
 532                sel_color
 533                if self._campaign_difficulty == 'easy'
 534                else un_sel_color
 535            ),
 536            textcolor=(
 537                sel_textcolor
 538                if self._campaign_difficulty == 'easy'
 539                else un_sel_textcolor
 540            ),
 541        )
 542        bui.widget(edit=self._easy_button, show_buffer_left=100)
 543        if self._selected_campaign_level == 'easyButton':
 544            bui.containerwidget(
 545                edit=parent_widget,
 546                selected_child=self._easy_button,
 547                visible_child=self._easy_button,
 548            )
 549        lock_tex = bui.gettexture('lock')
 550
 551        self._hard_button = bui.buttonwidget(
 552            parent=parent_widget,
 553            position=(h + 30, v2 + 32),
 554            size=(120, 70),
 555            label=bui.Lstr(resource='difficultyHardText'),
 556            button_type='square',
 557            autoselect=True,
 558            enable_sound=False,
 559            on_activate_call=bui.Call(self._set_campaign_difficulty, 'hard'),
 560            on_select_call=bui.Call(self.sel_change, 'campaign', 'hardButton'),
 561            color=(
 562                sel_color_hard
 563                if self._campaign_difficulty == 'hard'
 564                else un_sel_color
 565            ),
 566            textcolor=(
 567                sel_textcolor
 568                if self._campaign_difficulty == 'hard'
 569                else un_sel_textcolor
 570            ),
 571        )
 572        self._hard_button_lock_image = bui.imagewidget(
 573            parent=parent_widget,
 574            size=(30, 30),
 575            draw_controller=self._hard_button,
 576            position=(h + 30 - 10, v2 + 32 + 70 - 35),
 577            texture=lock_tex,
 578        )
 579        self._update_hard_mode_lock_image()
 580        bui.widget(edit=self._hard_button, show_buffer_left=100)
 581        if self._selected_campaign_level == 'hardButton':
 582            bui.containerwidget(
 583                edit=parent_widget,
 584                selected_child=self._hard_button,
 585                visible_child=self._hard_button,
 586            )
 587
 588        bui.widget(edit=self._hard_button, down_widget=next_widget_down)
 589        h_spacing = 200
 590        campaign_buttons = []
 591        if self._campaign_difficulty == 'easy':
 592            campaignname = 'Easy'
 593        else:
 594            campaignname = 'Default'
 595        items = [
 596            campaignname + ':Onslaught Training',
 597            campaignname + ':Rookie Onslaught',
 598            campaignname + ':Rookie Football',
 599            campaignname + ':Pro Onslaught',
 600            campaignname + ':Pro Football',
 601            campaignname + ':Pro Runaround',
 602            campaignname + ':Uber Onslaught',
 603            campaignname + ':Uber Football',
 604            campaignname + ':Uber Runaround',
 605        ]
 606        items += [campaignname + ':The Last Stand']
 607        if self._selected_campaign_level is None:
 608            self._selected_campaign_level = items[0]
 609        h = 150
 610        for i in items:
 611            is_last_sel = i == self._selected_campaign_level
 612            campaign_buttons.append(
 613                GameButton(
 614                    self, parent_widget, i, h, v2, is_last_sel, 'campaign'
 615                ).get_button()
 616            )
 617            h += h_spacing
 618
 619        bui.widget(edit=campaign_buttons[0], left_widget=self._easy_button)
 620
 621        bui.widget(
 622            edit=self._easy_button,
 623            left_widget=self._back_button,
 624            up_widget=self._back_button,
 625        )
 626        bui.widget(edit=self._hard_button, left_widget=self._back_button)
 627        for btn in campaign_buttons:
 628            bui.widget(
 629                edit=btn,
 630                up_widget=self._back_button,
 631            )
 632        for btn in campaign_buttons:
 633            bui.widget(edit=btn, down_widget=next_widget_down)
 634
 635        # Update our existing percent-complete text.
 636        assert bui.app.classic is not None
 637        campaign = bui.app.classic.getcampaign(campaignname)
 638        levels = campaign.levels
 639        levels_complete = sum((1 if l.complete else 0) for l in levels)
 640
 641        # Last level cant be completed; hence the -1.
 642        progress = min(1.0, float(levels_complete) / (len(levels) - 1))
 643        p_str = str(int(progress * 100.0)) + '%'
 644
 645        self._campaign_percent_text = bui.textwidget(
 646            edit=self._campaign_percent_text,
 647            text=bui.Lstr(
 648                value='${C} (${P})',
 649                subs=[
 650                    ('${C}', bui.Lstr(resource=f'{self._r}.campaignText')),
 651                    ('${P}', p_str),
 652                ],
 653            ),
 654        )
 655
 656    def _on_tournament_info_press(self) -> None:
 657        # pylint: disable=cyclic-import
 658        from bauiv1lib.confirm import ConfirmWindow
 659
 660        txt = bui.Lstr(resource=f'{self._r}.tournamentInfoText')
 661        ConfirmWindow(
 662            txt,
 663            cancel_button=False,
 664            width=550,
 665            height=260,
 666            origin_widget=self._tournament_info_button,
 667        )
 668
 669    def _refresh(self) -> None:
 670        # pylint: disable=too-many-statements
 671        # pylint: disable=too-many-branches
 672        # pylint: disable=too-many-locals
 673        # pylint: disable=cyclic-import
 674        from bauiv1lib.coop.gamebutton import GameButton
 675        from bauiv1lib.coop.tournamentbutton import TournamentButton
 676
 677        plus = bui.app.plus
 678        assert plus is not None
 679        assert bui.app.classic is not None
 680
 681        # (Re)create the sub-container if need be.
 682        if self._subcontainer is not None:
 683            self._subcontainer.delete()
 684
 685        tourney_row_height = 200
 686        self._subcontainerheight = (
 687            700 + self._tournament_button_count * tourney_row_height
 688        )
 689
 690        self._subcontainer = bui.containerwidget(
 691            parent=self._scrollwidget,
 692            size=(self._subcontainerwidth, self._subcontainerheight),
 693            background=False,
 694            claims_left_right=True,
 695            selection_loops_to_parent=True,
 696        )
 697
 698        bui.containerwidget(
 699            edit=self._root_widget, selected_child=self._scrollwidget
 700        )
 701
 702        w_parent = self._subcontainer
 703        h_base = 6
 704
 705        v = self._subcontainerheight - 90
 706
 707        self._campaign_percent_text = bui.textwidget(
 708            parent=w_parent,
 709            position=(h_base + 27, v + 30),
 710            size=(0, 0),
 711            text='',
 712            h_align='left',
 713            v_align='center',
 714            color=bui.app.ui_v1.title_color,
 715            scale=1.1,
 716        )
 717
 718        row_v_show_buffer = 80
 719        v -= 198
 720
 721        h_scroll = bui.hscrollwidget(
 722            parent=w_parent,
 723            size=(self._scroll_width, 205),
 724            position=(-5, v),
 725            simple_culling_h=70,
 726            highlight=False,
 727            border_opacity=0.0,
 728            color=(0.45, 0.4, 0.5),
 729            on_select_call=lambda: self._on_row_selected('campaign'),
 730        )
 731        self._campaign_h_scroll = h_scroll
 732        bui.widget(
 733            edit=h_scroll,
 734            show_buffer_top=row_v_show_buffer,
 735            show_buffer_bottom=row_v_show_buffer,
 736            autoselect=True,
 737        )
 738        if self._selected_row == 'campaign':
 739            bui.containerwidget(
 740                edit=w_parent, selected_child=h_scroll, visible_child=h_scroll
 741            )
 742        bui.containerwidget(edit=h_scroll, claims_left_right=True)
 743        self._campaign_sub_container = bui.containerwidget(
 744            parent=h_scroll, size=(180 + 200 * 10, 200), background=False
 745        )
 746
 747        # Tournaments
 748
 749        self._tournament_buttons: list[TournamentButton] = []
 750
 751        v -= 53
 752        # FIXME shouldn't use hard-coded strings here.
 753        txt = bui.Lstr(
 754            resource='tournamentsText', fallback_resource='tournamentText'
 755        ).evaluate()
 756        t_width = bui.get_string_width(txt, suppress_warning=True)
 757        bui.textwidget(
 758            parent=w_parent,
 759            position=(h_base + 27, v + 30),
 760            size=(0, 0),
 761            text=txt,
 762            h_align='left',
 763            v_align='center',
 764            color=bui.app.ui_v1.title_color,
 765            scale=1.1,
 766        )
 767        self._tournament_info_button = bui.buttonwidget(
 768            parent=w_parent,
 769            label='?',
 770            size=(20, 20),
 771            text_scale=0.6,
 772            position=(h_base + 27 + t_width * 1.1 + 15, v + 18),
 773            button_type='square',
 774            color=(0.6, 0.5, 0.65),
 775            textcolor=(0.7, 0.6, 0.75),
 776            autoselect=True,
 777            up_widget=self._campaign_h_scroll,
 778            left_widget=self._back_button,
 779            on_activate_call=self._on_tournament_info_press,
 780        )
 781        bui.widget(
 782            edit=self._tournament_info_button,
 783            right_widget=self._tournament_info_button,
 784        )
 785
 786        # Say 'unavailable' if there are zero tournaments, and if we're
 787        # not signed in add that as well (that's probably why we see no
 788        # tournaments).
 789        if self._tournament_button_count == 0:
 790            unavailable_text = bui.Lstr(resource='unavailableText')
 791            if plus.get_v1_account_state() != 'signed_in':
 792                unavailable_text = bui.Lstr(
 793                    value='${A} (${B})',
 794                    subs=[
 795                        ('${A}', unavailable_text),
 796                        ('${B}', bui.Lstr(resource='notSignedInText')),
 797                    ],
 798                )
 799            bui.textwidget(
 800                parent=w_parent,
 801                position=(h_base + 47, v),
 802                size=(0, 0),
 803                text=unavailable_text,
 804                h_align='left',
 805                v_align='center',
 806                color=bui.app.ui_v1.title_color,
 807                scale=0.9,
 808            )
 809            v -= 40
 810        v -= 198
 811
 812        tournament_h_scroll = None
 813        if self._tournament_button_count > 0:
 814            for i in range(self._tournament_button_count):
 815                tournament_h_scroll = h_scroll = bui.hscrollwidget(
 816                    parent=w_parent,
 817                    size=(self._scroll_width, 205),
 818                    position=(-5, v),
 819                    highlight=False,
 820                    border_opacity=0.0,
 821                    color=(0.45, 0.4, 0.5),
 822                    on_select_call=bui.Call(
 823                        self._on_row_selected, 'tournament' + str(i + 1)
 824                    ),
 825                )
 826                bui.widget(
 827                    edit=h_scroll,
 828                    show_buffer_top=row_v_show_buffer,
 829                    show_buffer_bottom=row_v_show_buffer,
 830                    autoselect=True,
 831                )
 832                if self._selected_row == 'tournament' + str(i + 1):
 833                    bui.containerwidget(
 834                        edit=w_parent,
 835                        selected_child=h_scroll,
 836                        visible_child=h_scroll,
 837                    )
 838                bui.containerwidget(edit=h_scroll, claims_left_right=True)
 839                sc2 = bui.containerwidget(
 840                    parent=h_scroll,
 841                    size=(self._scroll_width - 24, 200),
 842                    background=False,
 843                )
 844                h = 0
 845                v2 = -2
 846                is_last_sel = True
 847                self._tournament_buttons.append(
 848                    TournamentButton(
 849                        sc2,
 850                        h,
 851                        v2,
 852                        is_last_sel,
 853                        on_pressed=bui.WeakCall(self.run_tournament),
 854                    )
 855                )
 856                v -= 200
 857
 858        # Custom Games. (called 'Practice' in UI these days).
 859        v -= 50
 860        bui.textwidget(
 861            parent=w_parent,
 862            position=(h_base + 27, v + 30 + 198),
 863            size=(0, 0),
 864            text=bui.Lstr(
 865                resource='practiceText',
 866                fallback_resource='coopSelectWindow.customText',
 867            ),
 868            h_align='left',
 869            v_align='center',
 870            color=bui.app.ui_v1.title_color,
 871            scale=1.1,
 872        )
 873
 874        items = [
 875            'Challenges:Infinite Onslaught',
 876            'Challenges:Infinite Runaround',
 877            'Challenges:Ninja Fight',
 878            'Challenges:Pro Ninja Fight',
 879            'Challenges:Meteor Shower',
 880            'Challenges:Target Practice B',
 881            'Challenges:Target Practice',
 882        ]
 883
 884        # Show easter-egg-hunt either if its easter or we own it.
 885        if plus.get_v1_account_misc_read_val(
 886            'easter', False
 887        ) or plus.get_v1_account_product_purchased('games.easter_egg_hunt'):
 888            items = [
 889                'Challenges:Easter Egg Hunt',
 890                'Challenges:Pro Easter Egg Hunt',
 891            ] + items
 892
 893        # If we've defined custom games, put them at the beginning.
 894        if bui.app.classic.custom_coop_practice_games:
 895            items = bui.app.classic.custom_coop_practice_games + items
 896
 897        self._custom_h_scroll = custom_h_scroll = h_scroll = bui.hscrollwidget(
 898            parent=w_parent,
 899            size=(self._scroll_width, 205),
 900            position=(-5, v),
 901            highlight=False,
 902            border_opacity=0.0,
 903            color=(0.45, 0.4, 0.5),
 904            on_select_call=bui.Call(self._on_row_selected, 'custom'),
 905        )
 906        bui.widget(
 907            edit=h_scroll,
 908            show_buffer_top=row_v_show_buffer,
 909            show_buffer_bottom=1.5 * row_v_show_buffer,
 910            autoselect=True,
 911        )
 912        if self._selected_row == 'custom':
 913            bui.containerwidget(
 914                edit=w_parent, selected_child=h_scroll, visible_child=h_scroll
 915            )
 916        bui.containerwidget(edit=h_scroll, claims_left_right=True)
 917        sc2 = bui.containerwidget(
 918            parent=h_scroll,
 919            size=(max(self._scroll_width - 24, 30 + 200 * len(items)), 200),
 920            background=False,
 921        )
 922        h_spacing = 200
 923        self._custom_buttons: list[GameButton] = []
 924        h = 0
 925        v2 = -2
 926        for item in items:
 927            is_last_sel = item == self._selected_custom_level
 928            self._custom_buttons.append(
 929                GameButton(self, sc2, item, h, v2, is_last_sel, 'custom')
 930            )
 931            h += h_spacing
 932
 933        # We can't fill in our campaign row until tourney buttons are in place.
 934        # (for wiring up)
 935        self._refresh_campaign_row()
 936
 937        for i, tbutton in enumerate(self._tournament_buttons):
 938            bui.widget(
 939                edit=tbutton.button,
 940                up_widget=(
 941                    self._tournament_info_button
 942                    if i == 0
 943                    else self._tournament_buttons[i - 1].button
 944                ),
 945                down_widget=(
 946                    self._tournament_buttons[(i + 1)].button
 947                    if i + 1 < len(self._tournament_buttons)
 948                    else custom_h_scroll
 949                ),
 950                left_widget=self._back_button,
 951            )
 952            bui.widget(
 953                edit=tbutton.more_scores_button,
 954                down_widget=(
 955                    self._tournament_buttons[(i + 1)].current_leader_name_text
 956                    if i + 1 < len(self._tournament_buttons)
 957                    else custom_h_scroll
 958                ),
 959            )
 960            bui.widget(
 961                edit=tbutton.current_leader_name_text,
 962                up_widget=(
 963                    self._tournament_info_button
 964                    if i == 0
 965                    else self._tournament_buttons[i - 1].more_scores_button
 966                ),
 967            )
 968
 969        for i, btn in enumerate(self._custom_buttons):
 970            try:
 971                bui.widget(
 972                    edit=btn.get_button(),
 973                    up_widget=(
 974                        tournament_h_scroll
 975                        if self._tournament_buttons
 976                        else self._tournament_info_button
 977                    ),
 978                )
 979                if i == 0:
 980                    bui.widget(
 981                        edit=btn.get_button(), left_widget=self._back_button
 982                    )
 983
 984            except Exception:
 985                logging.exception('Error wiring up custom buttons.')
 986
 987        # There's probably several 'onSelected' callbacks pushed onto the
 988        # event queue.. we need to push ours too so we're enabled *after* them.
 989        bui.pushcall(self._enable_selectable_callback)
 990
 991    def _on_row_selected(self, row: str) -> None:
 992        if self._do_selection_callbacks:
 993            if self._selected_row != row:
 994                self._selected_row = row
 995
 996    def _enable_selectable_callback(self) -> None:
 997        self._do_selection_callbacks = True
 998
 999    def is_tourney_data_up_to_date(self) -> bool:
1000        """Return whether our tourney data is up to date."""
1001        return self._tourney_data_up_to_date
1002
1003    def run_game(
1004        self, game: str, origin_widget: bui.Widget | None = None
1005    ) -> None:
1006        """Run the provided game."""
1007        from efro.util import strict_partial
1008        from bauiv1lib.confirm import ConfirmWindow
1009
1010        classic = bui.app.classic
1011        assert classic is not None
1012
1013        if classic.chest_dock_full:
1014            ConfirmWindow(
1015                bui.Lstr(resource='chests.slotsFullWarningText'),
1016                width=550,
1017                height=140,
1018                ok_text=bui.Lstr(resource='continueText'),
1019                origin_widget=origin_widget,
1020                action=strict_partial(
1021                    self._run_game, game=game, origin_widget=origin_widget
1022                ),
1023            )
1024        else:
1025            self._run_game(game=game, origin_widget=origin_widget)
1026
1027    def _run_game(
1028        self, game: str, origin_widget: bui.Widget | None = None
1029    ) -> None:
1030        """Run the provided game."""
1031        # pylint: disable=cyclic-import
1032        from bauiv1lib.confirm import ConfirmWindow
1033        from bauiv1lib.purchase import PurchaseWindow
1034        from bauiv1lib.account.signin import show_sign_in_prompt
1035
1036        plus = bui.app.plus
1037        assert plus is not None
1038
1039        assert bui.app.classic is not None
1040
1041        args: dict[str, Any] = {}
1042
1043        if game == 'Easy:The Last Stand':
1044            ConfirmWindow(
1045                bui.Lstr(
1046                    resource='difficultyHardUnlockOnlyText',
1047                    fallback_resource='difficultyHardOnlyText',
1048                ),
1049                cancel_button=False,
1050                width=460,
1051                height=130,
1052            )
1053            return
1054
1055        required_purchases = bui.app.classic.required_purchases_for_game(game)
1056
1057        # Show pop-up to allow purchasing any required stuff we don't have.
1058        for purchase in required_purchases:
1059            if not plus.get_v1_account_product_purchased(purchase):
1060                if plus.get_v1_account_state() != 'signed_in':
1061                    show_sign_in_prompt()
1062                else:
1063                    PurchaseWindow(
1064                        items=[purchase], origin_widget=origin_widget
1065                    )
1066                return
1067
1068        self._save_state()
1069
1070        if bui.app.classic.launch_coop_game(game, args=args):
1071            bui.containerwidget(edit=self._root_widget, transition='out_left')
1072
1073    def run_tournament(self, tournament_button: TournamentButton) -> None:
1074        """Run the provided tournament game."""
1075        # pylint: disable=too-many-return-statements
1076
1077        from bauiv1lib.purchase import PurchaseWindow
1078        from bauiv1lib.account.signin import show_sign_in_prompt
1079        from bauiv1lib.tournamententry import TournamentEntryWindow
1080
1081        plus = bui.app.plus
1082        assert plus is not None
1083
1084        classic = bui.app.classic
1085        assert classic is not None
1086
1087        if plus.get_v1_account_state() != 'signed_in':
1088            show_sign_in_prompt()
1089            return
1090
1091        if bui.workspaces_in_use():
1092            bui.screenmessage(
1093                bui.Lstr(resource='tournamentsDisabledWorkspaceText'),
1094                color=(1, 0, 0),
1095            )
1096            bui.getsound('error').play()
1097            return
1098
1099        if not self._tourney_data_up_to_date:
1100            bui.screenmessage(
1101                bui.Lstr(resource='tournamentCheckingStateText'),
1102                color=(1, 1, 0),
1103            )
1104            bui.getsound('error').play()
1105            return
1106
1107        if tournament_button.tournament_id is None:
1108            bui.screenmessage(
1109                bui.Lstr(resource='internal.unavailableNoConnectionText'),
1110                color=(1, 0, 0),
1111            )
1112            bui.getsound('error').play()
1113            return
1114
1115        if tournament_button.required_league is not None:
1116            bui.screenmessage(
1117                bui.Lstr(
1118                    resource='league.tournamentLeagueText',
1119                    subs=[
1120                        (
1121                            '${NAME}',
1122                            bui.Lstr(
1123                                translate=(
1124                                    'leagueNames',
1125                                    tournament_button.required_league,
1126                                )
1127                            ),
1128                        )
1129                    ],
1130                ),
1131                color=(1, 0, 0),
1132            )
1133            bui.getsound('error').play()
1134            return
1135
1136        if tournament_button.game is not None and not classic.is_game_unlocked(
1137            tournament_button.game
1138        ):
1139            required_purchases = classic.required_purchases_for_game(
1140                tournament_button.game
1141            )
1142            # We gotta be missing *something* if its locked.
1143            assert required_purchases
1144
1145            for purchase in required_purchases:
1146                if not plus.get_v1_account_product_purchased(purchase):
1147                    if plus.get_v1_account_state() != 'signed_in':
1148                        show_sign_in_prompt()
1149                    else:
1150                        PurchaseWindow(
1151                            items=[purchase],
1152                            origin_widget=tournament_button.button,
1153                        )
1154                    return
1155
1156            # assert required_purchases
1157            # if plus.get_v1_account_state() != 'signed_in':
1158            #     show_sign_in_prompt()
1159            # else:
1160            #     # Hmm; just show the first requirement. They can come
1161            #     # back to see more after they purchase the first.
1162            #     PurchaseWindow(
1163            #         items=[required_purchases[0]],
1164            #         origin_widget=tournament_button.button,
1165            #     )
1166            # return
1167
1168        if tournament_button.time_remaining <= 0:
1169            bui.screenmessage(
1170                bui.Lstr(resource='tournamentEndedText'), color=(1, 0, 0)
1171            )
1172            bui.getsound('error').play()
1173            return
1174
1175        self._save_state()
1176
1177        assert tournament_button.tournament_id is not None
1178        TournamentEntryWindow(
1179            tournament_id=tournament_button.tournament_id,
1180            position=tournament_button.button.get_screen_space_center(),
1181        )
1182
1183    def _save_state(self) -> None:
1184        cfg = bui.app.config
1185        try:
1186            sel = self._root_widget.get_selected_child()
1187            if sel == self._back_button:
1188                sel_name = 'Back'
1189            elif sel == self._scrollwidget:
1190                sel_name = 'Scroll'
1191            else:
1192                raise ValueError('unrecognized selection')
1193            assert bui.app.classic is not None
1194            bui.app.ui_v1.window_states[type(self)] = {'sel_name': sel_name}
1195        except Exception:
1196            logging.exception('Error saving state for %s.', self)
1197
1198        cfg['Selected Coop Row'] = self._selected_row
1199        cfg['Selected Coop Custom Level'] = self._selected_custom_level
1200        cfg['Selected Coop Campaign Level'] = self._selected_campaign_level
1201        cfg.commit()
1202
1203    def _restore_state(self) -> None:
1204        try:
1205            assert bui.app.classic is not None
1206            sel_name = bui.app.ui_v1.window_states.get(type(self), {}).get(
1207                'sel_name'
1208            )
1209            if sel_name == 'Back':
1210                sel = self._back_button
1211            elif sel_name == 'Scroll':
1212                sel = self._scrollwidget
1213            else:
1214                sel = self._scrollwidget
1215            bui.containerwidget(edit=self._root_widget, selected_child=sel)
1216        except Exception:
1217            logging.exception('Error restoring state for %s.', self)
1218
1219    def sel_change(self, row: str, game: str) -> None:
1220        """(internal)"""
1221        if self._do_selection_callbacks:
1222            if row == 'custom':
1223                self._selected_custom_level = game
1224            elif row == 'campaign':
1225                self._selected_campaign_level = game