bauiv1lib.gather.privatetab

   1# Released under the MIT License. See LICENSE for details.
   2#
   3# pylint: disable=too-many-lines
   4"""Defines the Private tab in the gather UI."""
   5
   6from __future__ import annotations
   7
   8import os
   9import copy
  10import time
  11import logging
  12from enum import Enum
  13from dataclasses import dataclass
  14from typing import TYPE_CHECKING, cast, override
  15
  16from efro.error import CommunicationError
  17from efro.dataclassio import dataclass_from_dict, dataclass_to_dict
  18import bacommon.cloud
  19from bacommon.net import (
  20    PrivateHostingState,
  21    PrivateHostingConfig,
  22    PrivatePartyConnectResult,
  23)
  24from bauiv1lib.gather import GatherTab
  25
  26from bauiv1lib.gettokens import GetTokensWindow, show_get_tokens_prompt
  27import bascenev1 as bs
  28import bauiv1 as bui
  29
  30if TYPE_CHECKING:
  31    from typing import Any
  32
  33    from bauiv1lib.gather import GatherWindow
  34
  35
  36# Print a bit of info about queries, etc.
  37DEBUG_SERVER_COMMUNICATION = os.environ.get('BA_DEBUG_PPTABCOM') == '1'
  38
  39
  40class SubTabType(Enum):
  41    """Available sub-tabs."""
  42
  43    JOIN = 'join'
  44    HOST = 'host'
  45
  46
  47@dataclass
  48class State:
  49    """Our core state that persists while the app is running."""
  50
  51    sub_tab: SubTabType = SubTabType.JOIN
  52
  53
  54class PrivateGatherTab(GatherTab):
  55    """The private tab in the gather UI"""
  56
  57    def __init__(self, window: GatherWindow) -> None:
  58        super().__init__(window)
  59        self._container: bui.Widget | None = None
  60        self._state: State = State()
  61        self._last_datacode_refresh_time: float | None = None
  62        self._hostingstate = PrivateHostingState()
  63        self._v2state: bacommon.cloud.BSPrivatePartyResponse | None = None
  64        self._join_sub_tab_text: bui.Widget | None = None
  65        self._host_sub_tab_text: bui.Widget | None = None
  66        self._update_timer: bui.AppTimer | None = None
  67        self._join_party_code_text: bui.Widget | None = None
  68        self._c_width: float = 0.0
  69        self._c_height: float = 0.0
  70        self._last_hosting_state_query_time: float | None = None
  71        self._last_v2_state_query_time: float | None = None
  72        self._waiting_for_initial_state = True
  73        self._waiting_for_start_stop_response = True
  74        self._host_playlist_button: bui.Widget | None = None
  75        self._host_copy_button: bui.Widget | None = None
  76        self._host_connect_button: bui.Widget | None = None
  77        self._host_start_stop_button: bui.Widget | None = None
  78        self._get_tokens_button: bui.Widget | None = None
  79        self._token_count_text: bui.Widget | None = None
  80        self._showing_not_signed_in_screen = False
  81        self._create_time = time.time()
  82        self._last_action_send_time: float | None = None
  83        self._connect_press_time: float | None = None
  84        try:
  85            self._hostingconfig = self._build_hosting_config()
  86        except Exception:
  87            logging.exception('Error building hosting config.')
  88            self._hostingconfig = PrivateHostingConfig()
  89
  90    @override
  91    def on_activate(
  92        self,
  93        parent_widget: bui.Widget,
  94        tab_button: bui.Widget,
  95        region_width: float,
  96        region_height: float,
  97        region_left: float,
  98        region_bottom: float,
  99    ) -> bui.Widget:
 100        self._c_width = region_width
 101        self._c_height = region_height - 20
 102        self._container = bui.containerwidget(
 103            parent=parent_widget,
 104            position=(
 105                region_left,
 106                region_bottom + (region_height - self._c_height) * 0.5,
 107            ),
 108            size=(self._c_width, self._c_height),
 109            background=False,
 110            selection_loops_to_parent=True,
 111        )
 112        v = self._c_height - 30.0
 113        self._join_sub_tab_text = bui.textwidget(
 114            parent=self._container,
 115            position=(self._c_width * 0.5 - 245, v - 13),
 116            color=(0.6, 1.0, 0.6),
 117            scale=1.3,
 118            size=(200, 30),
 119            maxwidth=250,
 120            h_align='left',
 121            v_align='center',
 122            click_activate=True,
 123            selectable=True,
 124            autoselect=True,
 125            on_activate_call=lambda: self._set_sub_tab(
 126                SubTabType.JOIN,
 127                playsound=True,
 128            ),
 129            text=bui.Lstr(resource='gatherWindow.privatePartyJoinText'),
 130            glow_type='uniform',
 131        )
 132        self._host_sub_tab_text = bui.textwidget(
 133            parent=self._container,
 134            position=(self._c_width * 0.5 + 45, v - 13),
 135            color=(0.6, 1.0, 0.6),
 136            scale=1.3,
 137            size=(200, 30),
 138            maxwidth=250,
 139            h_align='left',
 140            v_align='center',
 141            click_activate=True,
 142            selectable=True,
 143            autoselect=True,
 144            on_activate_call=lambda: self._set_sub_tab(
 145                SubTabType.HOST,
 146                playsound=True,
 147            ),
 148            text=bui.Lstr(resource='gatherWindow.privatePartyHostText'),
 149            glow_type='uniform',
 150        )
 151        bui.widget(edit=self._join_sub_tab_text, up_widget=tab_button)
 152        bui.widget(
 153            edit=self._host_sub_tab_text,
 154            left_widget=self._join_sub_tab_text,
 155            up_widget=tab_button,
 156        )
 157        bui.widget(
 158            edit=self._join_sub_tab_text, right_widget=self._host_sub_tab_text
 159        )
 160
 161        self._update_timer = bui.AppTimer(
 162            1.0, bui.WeakCall(self._update), repeat=True
 163        )
 164
 165        # Prevent taking any action until we've updated our state.
 166        self._waiting_for_initial_state = True
 167
 168        # Force some immediate refreshes.
 169        self._last_datacode_refresh_time = None
 170        self._last_v2_state_query_time = None
 171        self._last_action_send_time = None  # Ensure we don't ignore response.
 172        self._last_hosting_state_query_time = None
 173        self._update()
 174
 175        self._set_sub_tab(self._state.sub_tab)
 176
 177        return self._container
 178
 179    def _build_hosting_config(self) -> PrivateHostingConfig:
 180        # pylint: disable=too-many-branches
 181        # pylint: disable=too-many-locals
 182        from bauiv1lib.playlist import PlaylistTypeVars
 183        from bascenev1 import filter_playlist
 184
 185        hcfg = PrivateHostingConfig()
 186        cfg = bui.app.config
 187        sessiontypestr = cfg.get('Private Party Host Session Type', 'ffa')
 188        if not isinstance(sessiontypestr, str):
 189            raise RuntimeError(f'Invalid sessiontype {sessiontypestr}')
 190        hcfg.session_type = sessiontypestr
 191
 192        sessiontype: type[bs.Session]
 193        if hcfg.session_type == 'ffa':
 194            sessiontype = bs.FreeForAllSession
 195        elif hcfg.session_type == 'teams':
 196            sessiontype = bs.DualTeamSession
 197        else:
 198            raise RuntimeError(f'Invalid sessiontype: {hcfg.session_type}')
 199        pvars = PlaylistTypeVars(sessiontype)
 200
 201        playlist_name = bui.app.config.get(
 202            f'{pvars.config_name} Playlist Selection'
 203        )
 204        if not isinstance(playlist_name, str):
 205            playlist_name = '__default__'
 206        hcfg.playlist_name = (
 207            pvars.default_list_name.evaluate()
 208            if playlist_name == '__default__'
 209            else playlist_name
 210        )
 211
 212        playlist: list[dict[str, Any]] | None = None
 213        if playlist_name != '__default__':
 214            playlist = cfg.get(f'{pvars.config_name} Playlists', {}).get(
 215                playlist_name
 216            )
 217        if playlist is None:
 218            playlist = pvars.get_default_list_call()
 219
 220        hcfg.playlist = filter_playlist(
 221            playlist, sessiontype, name=playlist_name
 222        )
 223
 224        randomize = cfg.get(f'{pvars.config_name} Playlist Randomize')
 225        if not isinstance(randomize, bool):
 226            randomize = False
 227        hcfg.randomize = randomize
 228
 229        tutorial = cfg.get('Show Tutorial')
 230        if not isinstance(tutorial, bool):
 231            tutorial = True
 232        hcfg.tutorial = tutorial
 233
 234        if hcfg.session_type == 'teams':
 235            ctn: list[str] | None = cfg.get('Custom Team Names')
 236            if ctn is not None:
 237                ctn_any: Any = ctn  # Actual value may not match type checker.
 238                if (
 239                    isinstance(ctn_any, (list, tuple))
 240                    and len(ctn) == 2
 241                    and all(isinstance(x, str) for x in ctn)
 242                ):
 243                    hcfg.custom_team_names = (ctn[0], ctn[1])
 244                else:
 245                    print(f'Found invalid custom-team-names data: {ctn}')
 246
 247            ctc: list[list[float]] | None = cfg.get('Custom Team Colors')
 248            if ctc is not None:
 249                ctc_any: Any = ctc  # Actual value may not match type checker.
 250                if (
 251                    isinstance(ctc_any, (list, tuple))
 252                    and len(ctc) == 2
 253                    and all(isinstance(x, (list, tuple)) for x in ctc)
 254                    and all(len(x) == 3 for x in ctc)
 255                ):
 256                    hcfg.custom_team_colors = (
 257                        (ctc[0][0], ctc[0][1], ctc[0][2]),
 258                        (ctc[1][0], ctc[1][1], ctc[1][2]),
 259                    )
 260                else:
 261                    print(f'Found invalid custom-team-colors data: {ctc}')
 262
 263        return hcfg
 264
 265    @override
 266    def on_deactivate(self) -> None:
 267        self._update_timer = None
 268
 269    def _update_currency_ui(self) -> None:
 270        # Keep currency count up to date if applicable.
 271        plus = bui.app.plus
 272        assert plus is not None
 273
 274        if self._v2state is not None:
 275            t_str = str(self._v2state.tokens)
 276        else:
 277            t_str = '-'
 278
 279        if self._get_tokens_button:
 280            bui.buttonwidget(
 281                edit=self._get_tokens_button,
 282                label=bui.charstr(bui.SpecialChar.TOKEN) + t_str,
 283            )
 284        if self._token_count_text:
 285            bui.textwidget(
 286                edit=self._token_count_text,
 287                text=bui.charstr(bui.SpecialChar.TOKEN) + t_str,
 288            )
 289
 290    def _update(self) -> None:
 291        """Periodic updating."""
 292
 293        plus = bui.app.plus
 294        assert plus is not None
 295
 296        now = bui.apptime()
 297
 298        self._update_currency_ui()
 299
 300        if self._state.sub_tab is SubTabType.HOST:
 301            # If we're not signed in, just refresh to show that.
 302            if (
 303                plus.get_v1_account_state() != 'signed_in'
 304                or plus.accounts.primary is None
 305            ) and not self._showing_not_signed_in_screen:
 306                self._refresh_sub_tab()
 307            else:
 308                # Query an updated v1 state periodically.
 309                if (
 310                    self._last_hosting_state_query_time is None
 311                    or now - self._last_hosting_state_query_time > 15.0
 312                ):
 313                    self._debug_server_comm('querying private party state')
 314                    if plus.get_v1_account_state() == 'signed_in':
 315                        plus.add_v1_account_transaction(
 316                            {
 317                                'type': 'PRIVATE_PARTY_QUERY',
 318                                'expire_time': time.time() + 20,
 319                            },
 320                            callback=bui.WeakCall(
 321                                self._idle_hosting_state_response
 322                            ),
 323                        )
 324                        plus.run_v1_account_transactions()
 325                    else:
 326                        self._idle_hosting_state_response(None)
 327                    self._last_hosting_state_query_time = now
 328
 329                # Query an updated v2 state periodically.
 330                if (
 331                    self._last_v2_state_query_time is None
 332                    or now - self._last_v2_state_query_time > 12.0
 333                ):
 334                    self._debug_server_comm('querying pp v2 state')
 335
 336                    if plus.accounts.primary is not None:
 337                        with plus.accounts.primary:
 338                            plus.cloud.send_message_cb(
 339                                bacommon.cloud.BSPrivatePartyMessage(
 340                                    need_datacode=(
 341                                        self._last_datacode_refresh_time is None
 342                                        or time.monotonic()
 343                                        - self._last_datacode_refresh_time
 344                                        > 30.0
 345                                    )
 346                                ),
 347                                on_response=bui.WeakCall(
 348                                    self._on_private_party_query_response
 349                                ),
 350                            )
 351
 352                    self._last_v2_state_query_time = now
 353
 354    def _on_private_party_query_response(
 355        self, response: bacommon.cloud.BSPrivatePartyResponse | Exception
 356    ) -> None:
 357        if isinstance(response, Exception):
 358            self._debug_server_comm('got pp v2 state response (err)')
 359            # We expect comm errors sometimes. Make noise on anything else.
 360            if not isinstance(response, CommunicationError):
 361                logging.exception('Error on private-party-query-response')
 362            return
 363
 364        # Ignore if something went wrong server-side.
 365        if not response.success:
 366            self._debug_server_comm('got pp v2 state response (serverside err)')
 367            return
 368
 369        self._debug_server_comm('got pp v2 state response')
 370
 371        existing_datacode = (
 372            None if self._v2state is None else self._v2state.datacode
 373        )
 374
 375        self._v2state = response
 376        if self._v2state.datacode is None:
 377            # We don't fetch datacode each time; preserve our existing
 378            # if we didn't.
 379            self._v2state.datacode = existing_datacode
 380        else:
 381            # If we *did* fetch it, note the time.
 382            self._last_datacode_refresh_time = time.monotonic()
 383
 384    def _idle_hosting_state_response(
 385        self, result: dict[str, Any] | None
 386    ) -> None:
 387        # This simply passes through to our standard response handler.
 388        # The one exception is if we've recently sent an action to the
 389        # server (start/stop hosting/etc.) In that case we want to
 390        # ignore idle background updates and wait for the response to
 391        # our action. (this keeps the button showing 'one moment...'
 392        # until the change takes effect, etc.)
 393        if (
 394            self._last_action_send_time is not None
 395            and time.time() - self._last_action_send_time < 5.0
 396        ):
 397            self._debug_server_comm(
 398                'ignoring private party state response due to recent action'
 399            )
 400            return
 401        self._hosting_state_response(result)
 402
 403    def _hosting_state_response(self, result: dict[str, Any] | None) -> None:
 404        # Its possible for this to come back to us after our UI is dead;
 405        # ignore in that case.
 406        if not self._container:
 407            return
 408
 409        state: PrivateHostingState | None = None
 410        if result is not None:
 411            self._debug_server_comm('got private party state response')
 412            try:
 413                state = dataclass_from_dict(
 414                    PrivateHostingState, result, discard_unknown_attrs=True
 415                )
 416            except Exception:
 417                logging.exception('Got invalid PrivateHostingState data')
 418        else:
 419            self._debug_server_comm('private party state response errored')
 420
 421        # Hmm I guess let's just ignore failed responses?... Or should
 422        # we show some sort of error state to the user?...
 423        if result is None or state is None:
 424            return
 425
 426        self._waiting_for_initial_state = False
 427        self._waiting_for_start_stop_response = False
 428        self._hostingstate = state
 429        self._refresh_sub_tab()
 430
 431    def _set_sub_tab(self, value: SubTabType, playsound: bool = False) -> None:
 432        assert self._container
 433        if playsound:
 434            bui.getsound('click01').play()
 435
 436        # If switching from join to host, force some refreshes.
 437        if self._state.sub_tab is SubTabType.JOIN and value is SubTabType.HOST:
 438            # Prevent taking any action until we've gotten a fresh
 439            # state.
 440            self._waiting_for_initial_state = True
 441
 442            # Get some refreshes going immediately.
 443            self._last_hosting_state_query_time = None
 444            self._last_action_send_time = None  # So we don't ignore response.
 445            self._last_datacode_refresh_time = None
 446            self._last_v2_state_query_time = None
 447            self._update()
 448
 449        self._state.sub_tab = value
 450        active_color = (0.6, 1.0, 0.6)
 451        inactive_color = (0.5, 0.4, 0.5)
 452        bui.textwidget(
 453            edit=self._join_sub_tab_text,
 454            color=active_color if value is SubTabType.JOIN else inactive_color,
 455        )
 456        bui.textwidget(
 457            edit=self._host_sub_tab_text,
 458            color=active_color if value is SubTabType.HOST else inactive_color,
 459        )
 460
 461        self._refresh_sub_tab()
 462
 463        # Kick off an update to get any needed messages sent/etc.
 464        bui.pushcall(self._update)
 465
 466    def _selwidgets(self) -> list[bui.Widget | None]:
 467        """An indexed list of widgets we can use for saving/restoring sel."""
 468        return [
 469            self._host_playlist_button,
 470            self._host_copy_button,
 471            self._host_connect_button,
 472            self._host_start_stop_button,
 473            self._get_tokens_button,
 474        ]
 475
 476    def _refresh_sub_tab(self) -> None:
 477        assert self._container
 478
 479        # Store an index for our current selection so we can reselect
 480        # the equivalent recreated widget if possible.
 481        selindex: int | None = None
 482        selchild = self._container.get_selected_child()
 483        if selchild is not None:
 484            try:
 485                selindex = self._selwidgets().index(selchild)
 486            except ValueError:
 487                pass
 488
 489        # Clear anything existing in the old sub-tab.
 490        for widget in self._container.get_children():
 491            if widget and widget not in {
 492                self._host_sub_tab_text,
 493                self._join_sub_tab_text,
 494            }:
 495                widget.delete()
 496
 497        if self._state.sub_tab is SubTabType.JOIN:
 498            self._build_join_tab()
 499        elif self._state.sub_tab is SubTabType.HOST:
 500            self._build_host_tab()
 501        else:
 502            raise RuntimeError('Invalid state.')
 503
 504        # Select the new equivalent widget if there is one.
 505        if selindex is not None:
 506            selwidget = self._selwidgets()[selindex]
 507            if selwidget:
 508                bui.containerwidget(
 509                    edit=self._container, selected_child=selwidget
 510                )
 511
 512    def _build_join_tab(self) -> None:
 513        bui.textwidget(
 514            parent=self._container,
 515            position=(self._c_width * 0.5, self._c_height - 140),
 516            color=(0.5, 0.46, 0.5),
 517            scale=1.5,
 518            size=(0, 0),
 519            maxwidth=250,
 520            h_align='center',
 521            v_align='center',
 522            text=bui.Lstr(resource='gatherWindow.partyCodeText'),
 523        )
 524
 525        self._join_party_code_text = bui.textwidget(
 526            parent=self._container,
 527            position=(self._c_width * 0.5 - 150, self._c_height - 250),
 528            flatness=1.0,
 529            scale=1.5,
 530            size=(300, 50),
 531            editable=True,
 532            max_chars=20,
 533            description=bui.Lstr(resource='gatherWindow.partyCodeText'),
 534            autoselect=True,
 535            h_align='left',
 536            v_align='center',
 537            text='',
 538        )
 539        btn = bui.buttonwidget(
 540            parent=self._container,
 541            size=(300, 70),
 542            label=bui.Lstr(resource='gatherWindow.' 'manualConnectText'),
 543            position=(self._c_width * 0.5 - 150, self._c_height - 350),
 544            on_activate_call=self._join_connect_press,
 545            autoselect=True,
 546        )
 547        bui.textwidget(
 548            edit=self._join_party_code_text, on_return_press_call=btn.activate
 549        )
 550
 551    def _on_get_tokens_press(self) -> None:
 552        if self._waiting_for_start_stop_response:
 553            return
 554
 555        # Bring up get-tickets window and then kill ourself (we're on
 556        # the overlay layer so we'd show up above it).
 557        GetTokensWindow(origin_widget=self._get_tokens_button)
 558
 559    def _build_host_tab(self) -> None:
 560        # pylint: disable=too-many-branches
 561        # pylint: disable=too-many-statements
 562        assert bui.app.classic is not None
 563
 564        plus = bui.app.plus
 565        assert plus is not None
 566
 567        hostingstate = self._hostingstate
 568
 569        havegoldpass = self._v2state is not None and self._v2state.gold_pass
 570
 571        # We use both v1 and v2 account functionality here (sigh). So
 572        # make sure we're signed in on both ends.
 573
 574        # Make sure the V1 side is good to go.
 575        if plus.get_v1_account_state() != 'signed_in':
 576            bui.textwidget(
 577                parent=self._container,
 578                size=(0, 0),
 579                h_align='center',
 580                v_align='center',
 581                maxwidth=self._c_width * 0.8,
 582                scale=0.8,
 583                color=(0.6, 0.56, 0.6),
 584                position=(self._c_width * 0.5, self._c_height * 0.5),
 585                text=bui.Lstr(resource='notSignedInErrorText'),
 586            )
 587            self._showing_not_signed_in_screen = True
 588            return
 589
 590        # Make sure the V2 side is good to go.
 591        if plus.accounts.primary is None:
 592            bui.textwidget(
 593                parent=self._container,
 594                size=(0, 0),
 595                h_align='center',
 596                v_align='center',
 597                maxwidth=self._c_width * 0.8,
 598                scale=0.8,
 599                color=(0.6, 0.56, 0.6),
 600                position=(self._c_width * 0.5, self._c_height * 0.5),
 601                text=bui.Lstr(resource='v2AccountRequiredText'),
 602            )
 603            self._showing_not_signed_in_screen = True
 604            return
 605
 606        self._showing_not_signed_in_screen = False
 607
 608        # At first we don't want to show anything until we've gotten a
 609        # state. Update: In this situation we now simply show our
 610        # existing state but give the start/stop button a loading
 611        # message and disallow its use. This keeps things a lot less
 612        # jumpy looking and allows selecting playlists/etc without
 613        # having to wait for the server each time back to the ui.
 614        if self._waiting_for_initial_state and bool(False):
 615            bui.textwidget(
 616                parent=self._container,
 617                size=(0, 0),
 618                h_align='center',
 619                v_align='center',
 620                maxwidth=200,
 621                scale=0.8,
 622                color=(0.6, 0.56, 0.6),
 623                position=(self._c_width * 0.5, self._c_height * 0.5),
 624                text=bui.Lstr(
 625                    value='${A}...',
 626                    subs=[('${A}', bui.Lstr(resource='store.loadingText'))],
 627                ),
 628            )
 629            return
 630
 631        # If we're not currently hosting and hosting requires tokens,
 632        # Show our count (possibly with a link to purchase more).
 633        if (
 634            not self._waiting_for_initial_state
 635            and hostingstate.party_code is None
 636            and hostingstate.tickets_to_host_now != 0
 637            and not havegoldpass
 638        ):
 639            if not bui.app.ui_v1.use_toolbars:
 640
 641                # Currently have no allow_token_purchases value like
 642                # we had with tickets; just assuming we always allow.
 643                if bool(True):
 644                    # if bui.app.classic.allow_ticket_purchases:
 645                    self._get_tokens_button = bui.buttonwidget(
 646                        parent=self._container,
 647                        position=(
 648                            self._c_width - 210 + 125,
 649                            self._c_height - 44,
 650                        ),
 651                        autoselect=True,
 652                        scale=0.6,
 653                        size=(120, 60),
 654                        textcolor=(1.0, 0.6, 0.0),
 655                        label=bui.charstr(bui.SpecialChar.TOKEN),
 656                        color=(0.65, 0.5, 0.8),
 657                        on_activate_call=self._on_get_tokens_press,
 658                    )
 659                else:
 660                    self._token_count_text = bui.textwidget(
 661                        parent=self._container,
 662                        scale=0.6,
 663                        position=(
 664                            self._c_width - 210 + 125,
 665                            self._c_height - 44,
 666                        ),
 667                        color=(1.0, 0.6, 0.0),
 668                        h_align='center',
 669                        v_align='center',
 670                    )
 671
 672                # Set initial token count.
 673                self._update_currency_ui()
 674
 675        v = self._c_height - 90
 676        if hostingstate.party_code is None:
 677            bui.textwidget(
 678                parent=self._container,
 679                size=(0, 0),
 680                h_align='center',
 681                v_align='center',
 682                maxwidth=self._c_width * 0.9,
 683                scale=0.7,
 684                flatness=1.0,
 685                color=(0.5, 0.46, 0.5),
 686                position=(self._c_width * 0.5, v),
 687                text=bui.Lstr(
 688                    resource='gatherWindow.privatePartyCloudDescriptionText'
 689                ),
 690            )
 691
 692        v -= 100
 693        if hostingstate.party_code is None:
 694            # We've got no current party running; show options to set
 695            # one up.
 696            bui.textwidget(
 697                parent=self._container,
 698                size=(0, 0),
 699                h_align='right',
 700                v_align='center',
 701                maxwidth=200,
 702                scale=0.8,
 703                color=(0.6, 0.56, 0.6),
 704                position=(self._c_width * 0.5 - 210, v),
 705                text=bui.Lstr(resource='playlistText'),
 706            )
 707            self._host_playlist_button = bui.buttonwidget(
 708                parent=self._container,
 709                size=(400, 70),
 710                color=(0.6, 0.5, 0.6),
 711                textcolor=(0.8, 0.75, 0.8),
 712                label=self._hostingconfig.playlist_name,
 713                on_activate_call=self._playlist_press,
 714                position=(self._c_width * 0.5 - 200, v - 35),
 715                up_widget=self._host_sub_tab_text,
 716                autoselect=True,
 717            )
 718
 719            # If it appears we're coming back from playlist selection,
 720            # re-select our playlist button.
 721            if bui.app.ui_v1.selecting_private_party_playlist:
 722                bui.containerwidget(
 723                    edit=self._container,
 724                    selected_child=self._host_playlist_button,
 725                )
 726                bui.app.ui_v1.selecting_private_party_playlist = False
 727        else:
 728            # We've got a current party; show its info.
 729            bui.textwidget(
 730                parent=self._container,
 731                size=(0, 0),
 732                h_align='center',
 733                v_align='center',
 734                maxwidth=600,
 735                scale=0.9,
 736                color=(0.7, 0.64, 0.7),
 737                position=(self._c_width * 0.5, v + 90),
 738                text=bui.Lstr(resource='gatherWindow.partyServerRunningText'),
 739            )
 740            bui.textwidget(
 741                parent=self._container,
 742                size=(0, 0),
 743                h_align='center',
 744                v_align='center',
 745                maxwidth=600,
 746                scale=0.7,
 747                color=(0.7, 0.64, 0.7),
 748                position=(self._c_width * 0.5, v + 50),
 749                text=bui.Lstr(resource='gatherWindow.partyCodeText'),
 750            )
 751            bui.textwidget(
 752                parent=self._container,
 753                size=(0, 0),
 754                h_align='center',
 755                v_align='center',
 756                scale=2.0,
 757                color=(0.0, 1.0, 0.0),
 758                position=(self._c_width * 0.5, v + 10),
 759                text=hostingstate.party_code,
 760            )
 761
 762            # Also action buttons to copy it and connect to it.
 763            if bui.clipboard_is_supported():
 764                cbtnoffs = 10
 765                self._host_copy_button = bui.buttonwidget(
 766                    parent=self._container,
 767                    size=(140, 40),
 768                    color=(0.6, 0.5, 0.6),
 769                    textcolor=(0.8, 0.75, 0.8),
 770                    label=bui.Lstr(resource='gatherWindow.copyCodeText'),
 771                    on_activate_call=self._host_copy_press,
 772                    position=(self._c_width * 0.5 - 150, v - 70),
 773                    autoselect=True,
 774                )
 775            else:
 776                cbtnoffs = -70
 777            self._host_connect_button = bui.buttonwidget(
 778                parent=self._container,
 779                size=(140, 40),
 780                color=(0.6, 0.5, 0.6),
 781                textcolor=(0.8, 0.75, 0.8),
 782                label=bui.Lstr(resource='gatherWindow.manualConnectText'),
 783                on_activate_call=self._host_connect_press,
 784                position=(self._c_width * 0.5 + cbtnoffs, v - 70),
 785                autoselect=True,
 786            )
 787
 788        v -= 120
 789
 790        # Line above the main action button:
 791
 792        # If we don't want to show anything until we get a state:
 793        if self._waiting_for_initial_state:
 794            pass
 795        elif hostingstate.unavailable_error is not None:
 796            # If hosting is unavailable, show the associated reason.
 797            bui.textwidget(
 798                parent=self._container,
 799                size=(0, 0),
 800                h_align='center',
 801                v_align='center',
 802                maxwidth=self._c_width * 0.9,
 803                scale=0.7,
 804                flatness=1.0,
 805                color=(1.0, 0.0, 0.0),
 806                position=(self._c_width * 0.5, v),
 807                text=bui.Lstr(
 808                    translate=(
 809                        'serverResponses',
 810                        hostingstate.unavailable_error,
 811                    )
 812                ),
 813            )
 814        elif havegoldpass:
 815            # If we have a gold pass, none of the
 816            # timing/free-server-availability info below is relevant to
 817            # us.
 818            pass
 819        elif hostingstate.free_host_minutes_remaining is not None:
 820            # If we've been pre-approved to start/stop for free, show
 821            # that.
 822            bui.textwidget(
 823                parent=self._container,
 824                size=(0, 0),
 825                h_align='center',
 826                v_align='center',
 827                maxwidth=self._c_width * 0.9,
 828                scale=0.7,
 829                flatness=1.0,
 830                color=(
 831                    (0.7, 0.64, 0.7)
 832                    if hostingstate.party_code
 833                    else (0.0, 1.0, 0.0)
 834                ),
 835                position=(self._c_width * 0.5, v),
 836                text=bui.Lstr(
 837                    resource='gatherWindow.startStopHostingMinutesText',
 838                    subs=[
 839                        (
 840                            '${MINUTES}',
 841                            f'{hostingstate.free_host_minutes_remaining:.0f}',
 842                        )
 843                    ],
 844                ),
 845            )
 846        else:
 847            # Otherwise tell whether the free cloud server is available
 848            # or will be at some point.
 849            if hostingstate.party_code is None:
 850                if hostingstate.tickets_to_host_now == 0:
 851                    bui.textwidget(
 852                        parent=self._container,
 853                        size=(0, 0),
 854                        h_align='center',
 855                        v_align='center',
 856                        maxwidth=self._c_width * 0.9,
 857                        scale=0.7,
 858                        flatness=1.0,
 859                        color=(0.0, 1.0, 0.0),
 860                        position=(self._c_width * 0.5, v),
 861                        text=bui.Lstr(
 862                            resource=(
 863                                'gatherWindow.freeCloudServerAvailableNowText'
 864                            )
 865                        ),
 866                    )
 867                else:
 868                    if hostingstate.minutes_until_free_host is None:
 869                        bui.textwidget(
 870                            parent=self._container,
 871                            size=(0, 0),
 872                            h_align='center',
 873                            v_align='center',
 874                            maxwidth=self._c_width * 0.9,
 875                            scale=0.7,
 876                            flatness=1.0,
 877                            color=(1.0, 0.6, 0.0),
 878                            position=(self._c_width * 0.5, v),
 879                            text=bui.Lstr(
 880                                resource=(
 881                                    'gatherWindow'
 882                                    '.freeCloudServerNotAvailableText'
 883                                )
 884                            ),
 885                        )
 886                    else:
 887                        availmins = hostingstate.minutes_until_free_host
 888                        bui.textwidget(
 889                            parent=self._container,
 890                            size=(0, 0),
 891                            h_align='center',
 892                            v_align='center',
 893                            maxwidth=self._c_width * 0.9,
 894                            scale=0.7,
 895                            flatness=1.0,
 896                            color=(1.0, 0.6, 0.0),
 897                            position=(self._c_width * 0.5, v),
 898                            text=bui.Lstr(
 899                                resource='gatherWindow.'
 900                                'freeCloudServerAvailableMinutesText',
 901                                subs=[('${MINUTES}', f'{availmins:.0f}')],
 902                            ),
 903                        )
 904
 905        v -= 100
 906
 907        if (
 908            self._waiting_for_start_stop_response
 909            or self._waiting_for_initial_state
 910        ):
 911            btnlabel = bui.Lstr(resource='oneMomentText')
 912        else:
 913            if hostingstate.unavailable_error is not None:
 914                btnlabel = bui.Lstr(
 915                    resource='gatherWindow.hostingUnavailableText'
 916                )
 917            elif hostingstate.party_code is None:
 918                ticon = bui.charstr(bui.SpecialChar.TOKEN)
 919                nowtokens = hostingstate.tokens_to_host_now
 920                if nowtokens > 0 and not havegoldpass:
 921                    btnlabel = bui.Lstr(
 922                        resource='gatherWindow.startHostingPaidText',
 923                        subs=[('${COST}', f'{ticon}{nowtokens}')],
 924                    )
 925                else:
 926                    btnlabel = bui.Lstr(
 927                        resource='gatherWindow.startHostingText'
 928                    )
 929            else:
 930                btnlabel = bui.Lstr(resource='gatherWindow.stopHostingText')
 931
 932        disabled = (
 933            hostingstate.unavailable_error is not None
 934            or self._waiting_for_initial_state
 935        )
 936        waiting = self._waiting_for_start_stop_response
 937        self._host_start_stop_button = bui.buttonwidget(
 938            parent=self._container,
 939            size=(400, 80),
 940            color=(
 941                (0.6, 0.6, 0.6)
 942                if disabled
 943                else (0.5, 1.0, 0.5) if waiting else None
 944            ),
 945            enable_sound=False,
 946            label=btnlabel,
 947            textcolor=((0.7, 0.7, 0.7) if disabled else None),
 948            position=(self._c_width * 0.5 - 200, v),
 949            on_activate_call=self._start_stop_button_press,
 950            autoselect=True,
 951        )
 952
 953    def _playlist_press(self) -> None:
 954        assert self._host_playlist_button is not None
 955        self.window.playlist_select(origin_widget=self._host_playlist_button)
 956
 957    def _host_copy_press(self) -> None:
 958        assert self._hostingstate.party_code is not None
 959        bui.clipboard_set_text(self._hostingstate.party_code)
 960        bui.screenmessage(bui.Lstr(resource='gatherWindow.copyCodeConfirmText'))
 961
 962    def _host_connect_press(self) -> None:
 963        assert self._hostingstate.party_code is not None
 964        self._connect_to_party_code(self._hostingstate.party_code)
 965
 966    def _debug_server_comm(self, msg: str) -> None:
 967        if DEBUG_SERVER_COMMUNICATION:
 968            print(
 969                f'PPTABCOM: {msg} at time '
 970                f'{time.time()-self._create_time:.2f}'
 971            )
 972
 973    def _connect_to_party_code(self, code: str) -> None:
 974        # Ignore attempted followup sends for a few seconds. (this will
 975        # reset if we get a response)
 976        plus = bui.app.plus
 977        assert plus is not None
 978
 979        now = time.time()
 980        if (
 981            self._connect_press_time is not None
 982            and now - self._connect_press_time < 5.0
 983        ):
 984            self._debug_server_comm(
 985                'not sending private party connect (too soon)'
 986            )
 987            return
 988        self._connect_press_time = now
 989
 990        self._debug_server_comm('sending private party connect')
 991        plus.add_v1_account_transaction(
 992            {
 993                'type': 'PRIVATE_PARTY_CONNECT',
 994                'expire_time': time.time() + 20,
 995                'code': code,
 996            },
 997            callback=bui.WeakCall(self._connect_response),
 998        )
 999        plus.run_v1_account_transactions()
1000
1001    def _start_stop_button_press(self) -> None:
1002        plus = bui.app.plus
1003        assert plus is not None
1004        if (
1005            self._waiting_for_start_stop_response
1006            or self._waiting_for_initial_state
1007        ):
1008            return
1009
1010        if plus.get_v1_account_state() != 'signed_in':
1011            bui.screenmessage(bui.Lstr(resource='notSignedInErrorText'))
1012            bui.getsound('error').play()
1013            self._refresh_sub_tab()
1014            return
1015
1016        if self._hostingstate.unavailable_error is not None:
1017            bui.getsound('error').play()
1018            return
1019
1020        bui.getsound('click01').play()
1021
1022        # We need our v2 info for this.
1023        if self._v2state is None or self._v2state.datacode is None:
1024            bui.screenmessage(
1025                bui.Lstr(resource='internal.unavailableNoConnectionText'),
1026                color=(1, 0, 0),
1027            )
1028            bui.getsound('error').play()
1029            return
1030
1031        # If we're not hosting, start.
1032        if self._hostingstate.party_code is None:
1033            # If there's a token cost, make sure we have enough tokens
1034            # or a gold pass.
1035            if self._hostingstate.tokens_to_host_now > 0:
1036
1037                if (
1038                    not self._v2state.gold_pass
1039                    and self._v2state.tokens
1040                    < self._hostingstate.tokens_to_host_now
1041                ):
1042                    show_get_tokens_prompt()
1043                    bui.getsound('error').play()
1044                    return
1045
1046            self._last_action_send_time = time.time()
1047            plus.add_v1_account_transaction(
1048                {
1049                    'type': 'PRIVATE_PARTY_START',
1050                    'config': dataclass_to_dict(self._hostingconfig),
1051                    'region_pings': bui.app.net.zone_pings,
1052                    'expire_time': time.time() + 20,
1053                    'datacode': self._v2state.datacode,
1054                },
1055                callback=bui.WeakCall(self._hosting_state_response),
1056            )
1057            plus.run_v1_account_transactions()
1058
1059        else:
1060            self._last_action_send_time = time.time()
1061            plus.add_v1_account_transaction(
1062                {
1063                    'type': 'PRIVATE_PARTY_STOP',
1064                    'expire_time': time.time() + 20,
1065                },
1066                callback=bui.WeakCall(self._hosting_state_response),
1067            )
1068            plus.run_v1_account_transactions()
1069        bui.getsound('click01').play()
1070
1071        self._waiting_for_start_stop_response = True
1072        self._refresh_sub_tab()
1073
1074    def _join_connect_press(self) -> None:
1075        # Error immediately if its an empty code.
1076        code: str | None = None
1077        if self._join_party_code_text:
1078            code = cast(str, bui.textwidget(query=self._join_party_code_text))
1079        if not code:
1080            bui.screenmessage(
1081                bui.Lstr(translate=('serverResponses', 'Invalid code.')),
1082                color=(1, 0, 0),
1083            )
1084            bui.getsound('error').play()
1085            return
1086
1087        self._connect_to_party_code(code)
1088
1089    def _connect_response(self, result: dict[str, Any] | None) -> None:
1090        try:
1091            self._connect_press_time = None
1092            if result is None:
1093                raise RuntimeError()
1094            cresult = dataclass_from_dict(
1095                PrivatePartyConnectResult, result, discard_unknown_attrs=True
1096            )
1097            if cresult.error is not None:
1098                self._debug_server_comm('got error connect response')
1099                bui.screenmessage(
1100                    bui.Lstr(translate=('serverResponses', cresult.error)),
1101                    (1, 0, 0),
1102                )
1103                bui.getsound('error').play()
1104                return
1105            self._debug_server_comm('got valid connect response')
1106            assert cresult.address4 is not None and cresult.port is not None
1107            bs.connect_to_party(cresult.address4, port=cresult.port)
1108        except Exception:
1109            self._debug_server_comm('got connect response error')
1110            bui.getsound('error').play()
1111
1112    @override
1113    def save_state(self) -> None:
1114        assert bui.app.classic is not None
1115        bui.app.ui_v1.window_states[type(self)] = copy.deepcopy(self._state)
1116
1117    @override
1118    def restore_state(self) -> None:
1119        assert bui.app.classic is not None
1120        state = bui.app.ui_v1.window_states.get(type(self))
1121        if state is None:
1122            state = State()
1123        assert isinstance(state, State)
1124        self._state = state