baclassic

 33class ClassicAppMode(AppMode):
 34    """AppMode for the classic BombSquad experience."""
 35
 36    def __init__(self) -> None:
 37        self._on_primary_account_changed_callback: (
 38            CallbackRegistration | None
 39        ) = None
 40        self._test_sub: CloudSubscription | None = None
 41
 42    @override
 43    @classmethod
 44    def get_app_experience(cls) -> AppExperience:
 45        return AppExperience.MELEE
 46
 47    @override
 48    @classmethod
 49    def _supports_intent(cls, intent: AppIntent) -> bool:
 50        # We support default and exec intents currently.
 51        return isinstance(intent, AppIntentExec | AppIntentDefault)
 52
 53    @override
 54    def handle_intent(self, intent: AppIntent) -> None:
 55        if isinstance(intent, AppIntentExec):
 56            _baclassic.classic_app_mode_handle_app_intent_exec(intent.code)
 57            return
 58        assert isinstance(intent, AppIntentDefault)
 59        _baclassic.classic_app_mode_handle_app_intent_default()
 60
 61    @override
 62    def on_activate(self) -> None:
 63
 64        # Let the native layer do its thing.
 65        _baclassic.classic_app_mode_activate()
 66
 67        assert app.plus is not None
 68
 69        # Wire up the root ui to do what we want.
 70        ui = app.ui_v1
 71        ui.root_ui_calls[ui.RootUIElement.ACCOUNT_BUTTON] = (
 72            self._root_ui_account_press
 73        )
 74        ui.root_ui_calls[ui.RootUIElement.MENU_BUTTON] = (
 75            self._root_ui_menu_press
 76        )
 77        ui.root_ui_calls[ui.RootUIElement.SQUAD_BUTTON] = (
 78            self._root_ui_squad_press
 79        )
 80        ui.root_ui_calls[ui.RootUIElement.SETTINGS_BUTTON] = (
 81            self._root_ui_settings_press
 82        )
 83        ui.root_ui_calls[ui.RootUIElement.STORE_BUTTON] = (
 84            self._root_ui_store_press
 85        )
 86        ui.root_ui_calls[ui.RootUIElement.INVENTORY_BUTTON] = (
 87            self._root_ui_inventory_press
 88        )
 89        ui.root_ui_calls[ui.RootUIElement.GET_TOKENS_BUTTON] = (
 90            self._root_ui_get_tokens_press
 91        )
 92        ui.root_ui_calls[ui.RootUIElement.INBOX_BUTTON] = (
 93            self._root_ui_inbox_press
 94        )
 95        ui.root_ui_calls[ui.RootUIElement.TICKETS_METER] = (
 96            self._root_ui_tickets_meter_press
 97        )
 98        ui.root_ui_calls[ui.RootUIElement.TOKENS_METER] = (
 99            self._root_ui_tokens_meter_press
100        )
101        ui.root_ui_calls[ui.RootUIElement.TROPHY_METER] = (
102            self._root_ui_trophy_meter_press
103        )
104        ui.root_ui_calls[ui.RootUIElement.LEVEL_METER] = (
105            self._root_ui_level_meter_press
106        )
107        ui.root_ui_calls[ui.RootUIElement.ACHIEVEMENTS_BUTTON] = (
108            self._root_ui_achievements_press
109        )
110        ui.root_ui_calls[ui.RootUIElement.CHEST_SLOT_1] = partial(
111            self._root_ui_chest_slot_pressed, 1
112        )
113        ui.root_ui_calls[ui.RootUIElement.CHEST_SLOT_2] = partial(
114            self._root_ui_chest_slot_pressed, 2
115        )
116        ui.root_ui_calls[ui.RootUIElement.CHEST_SLOT_3] = partial(
117            self._root_ui_chest_slot_pressed, 3
118        )
119        ui.root_ui_calls[ui.RootUIElement.CHEST_SLOT_4] = partial(
120            self._root_ui_chest_slot_pressed, 4
121        )
122
123        # We want to be informed when primary account changes.
124        self._on_primary_account_changed_callback = (
125            app.plus.accounts.on_primary_account_changed_callbacks.add(
126                self.update_for_primary_account
127            )
128        )
129        # Establish subscriptions/etc. for any current primary account.
130        self.update_for_primary_account(app.plus.accounts.primary)
131
132    @override
133    def on_deactivate(self) -> None:
134
135        # Stop being informed of account changes.
136        self._on_primary_account_changed_callback = None
137
138        # Remove any listeners for any current primary account.
139        self.update_for_primary_account(None)
140
141        # Save where we were in the UI so we return there next time.
142        if app.classic is not None:
143            app.classic.save_ui_state()
144
145        # Let the native layer do its thing.
146        _baclassic.classic_app_mode_deactivate()
147
148    @override
149    def on_app_active_changed(self) -> None:
150        # If we've gone inactive, bring up the main menu, which has the
151        # side effect of pausing the action (when possible).
152        if not app.active:
153            invoke_main_menu()
154
155    def update_for_primary_account(
156        self, account: AccountV2Handle | None
157    ) -> None:
158        """Update subscriptions/etc. for a new primary account state."""
159        assert in_logic_thread()
160
161        # Test subscription.
162        if bool(False):
163            assert app.plus is not None
164            if account is None:
165                self._test_sub = None
166            else:
167                with account:
168                    self._test_sub = app.plus.cloud.subscribe_test(
169                        self._on_sub_test_update
170                    )
171        else:
172            self._test_sub = None
173
174    def _on_sub_test_update(self, val: int | None) -> None:
175        print(f'GOT SUB TEST UPDATE: {val}')
176
177    def _root_ui_menu_press(self) -> None:
178        from babase import push_back_press
179
180        ui = app.ui_v1
181
182        # If *any* main-window is up, kill it and resume play.
183        old_window = ui.get_main_window()
184        if old_window is not None:
185
186            classic = app.classic
187
188            assert classic is not None
189            classic.resume()
190
191            ui.clear_main_window()
192            return
193
194        push_back_press()
195
196    def _root_ui_account_press(self) -> None:
197        import bauiv1
198        from bauiv1lib.account.settings import AccountSettingsWindow
199
200        self._auxiliary_window_nav(
201            win_type=AccountSettingsWindow,
202            win_create_call=lambda: AccountSettingsWindow(
203                origin_widget=bauiv1.get_special_widget('account_button')
204            ),
205        )
206
207    def _root_ui_squad_press(self) -> None:
208        import bauiv1
209
210        btn = bauiv1.get_special_widget('squad_button')
211        center = btn.get_screen_space_center()
212        if bauiv1.app.classic is not None:
213            bauiv1.app.classic.party_icon_activate(center)
214        else:
215            logging.warning('party_icon_activate: no classic.')
216
217    def _root_ui_settings_press(self) -> None:
218        import bauiv1
219        from bauiv1lib.settings.allsettings import AllSettingsWindow
220
221        self._auxiliary_window_nav(
222            win_type=AllSettingsWindow,
223            win_create_call=lambda: AllSettingsWindow(
224                origin_widget=bauiv1.get_special_widget('settings_button')
225            ),
226        )
227
228    def _auxiliary_window_nav(
229        self,
230        win_type: type[MainWindow],
231        win_create_call: Callable[[], MainWindow],
232    ) -> None:
233        """Navigate to or away from a particular type of Auxiliary window."""
234        # pylint: disable=unidiomatic-typecheck
235
236        ui = app.ui_v1
237
238        current_main_window = ui.get_main_window()
239
240        # Scan our ancestors for auxiliary states matching our type as
241        # well as auxiliary states in general.
242        aux_matching_state: MainWindowState | None = None
243        aux_state: MainWindowState | None = None
244
245        if current_main_window is None:
246            raise RuntimeError(
247                'Not currently handling no-top-level-window case.'
248            )
249
250        state = current_main_window.main_window_back_state
251        while state is not None:
252            assert state.window_type is not None
253            if state.is_auxiliary:
254                if state.window_type is win_type:
255                    aux_matching_state = state
256                else:
257                    aux_state = state
258
259            state = state.parent
260
261        # If there's an ancestor auxiliary window-state matching our
262        # type, back out past it (example: poking settings, navigating
263        # down a level or two, and then poking settings again should
264        # back out of settings).
265        if aux_matching_state is not None:
266            current_main_window.main_window_back_state = (
267                aux_matching_state.parent
268            )
269            current_main_window.main_window_back()
270            return
271
272        # If there's an ancestory auxiliary state *not* matching our
273        # type, crop the state and swap in our new auxiliary UI
274        # (example: poking settings, then poking account, then poking
275        # back should end up where things were before the settings
276        # poke).
277        if aux_state is not None:
278            # Blow away the window stack and build a fresh one.
279            ui.clear_main_window()
280            ui.set_main_window(
281                win_create_call(),
282                from_window=False,  # Disable from-check.
283                back_state=aux_state.parent,
284                suppress_warning=True,
285                is_auxiliary=True,
286            )
287            return
288
289        # Ok, no auxiliary states found. Now if current window is auxiliary
290        # and the type matches, simply do a back.
291        if (
292            current_main_window.main_window_is_auxiliary
293            and type(current_main_window) is win_type
294        ):
295            current_main_window.main_window_back()
296            return
297
298        # If current window is auxiliary but type doesn't match,
299        # swap it out for our new auxiliary UI.
300        if current_main_window.main_window_is_auxiliary:
301            ui.clear_main_window()
302            ui.set_main_window(
303                win_create_call(),
304                from_window=False,  # Disable from-check.
305                back_state=current_main_window.main_window_back_state,
306                suppress_warning=True,
307                is_auxiliary=True,
308            )
309            return
310
311        # Ok, no existing auxiliary stuff was found period. Just
312        # navigate forward to this UI.
313        current_main_window.main_window_replace(
314            win_create_call(), is_auxiliary=True
315        )
316
317    def _root_ui_achievements_press(self) -> None:
318        import bauiv1
319        from bauiv1lib.achievements import AchievementsWindow
320
321        self._auxiliary_window_nav(
322            win_type=AchievementsWindow,
323            win_create_call=lambda: AchievementsWindow(
324                origin_widget=bauiv1.get_special_widget('achievements_button')
325            ),
326        )
327
328    def _root_ui_inbox_press(self) -> None:
329        import bauiv1
330        from bauiv1lib.inbox import InboxWindow
331
332        self._auxiliary_window_nav(
333            win_type=InboxWindow,
334            win_create_call=lambda: InboxWindow(
335                origin_widget=bauiv1.get_special_widget('inbox_button')
336            ),
337        )
338
339    def _root_ui_store_press(self) -> None:
340        import bauiv1
341        from bauiv1lib.store.browser import StoreBrowserWindow
342
343        self._auxiliary_window_nav(
344            win_type=StoreBrowserWindow,
345            win_create_call=lambda: StoreBrowserWindow(
346                origin_widget=bauiv1.get_special_widget('store_button')
347            ),
348        )
349
350    def _root_ui_tickets_meter_press(self) -> None:
351        import bauiv1
352        from bauiv1lib.resourcetypeinfo import ResourceTypeInfoWindow
353
354        ResourceTypeInfoWindow(
355            'tickets', origin_widget=bauiv1.get_special_widget('tickets_meter')
356        )
357
358    def _root_ui_tokens_meter_press(self) -> None:
359        import bauiv1
360        from bauiv1lib.resourcetypeinfo import ResourceTypeInfoWindow
361
362        ResourceTypeInfoWindow(
363            'tokens', origin_widget=bauiv1.get_special_widget('tokens_meter')
364        )
365
366    def _root_ui_trophy_meter_press(self) -> None:
367        import bauiv1
368        from bauiv1lib.account import show_sign_in_prompt
369        from bauiv1lib.league.rankwindow import LeagueRankWindow
370
371        plus = bauiv1.app.plus
372        assert plus is not None
373        if plus.get_v1_account_state() != 'signed_in':
374            show_sign_in_prompt()
375            return
376
377        self._auxiliary_window_nav(
378            win_type=LeagueRankWindow,
379            win_create_call=lambda: LeagueRankWindow(
380                origin_widget=bauiv1.get_special_widget('trophy_meter')
381            ),
382        )
383
384    def _root_ui_level_meter_press(self) -> None:
385        import bauiv1
386        from bauiv1lib.resourcetypeinfo import ResourceTypeInfoWindow
387
388        ResourceTypeInfoWindow(
389            'xp', origin_widget=bauiv1.get_special_widget('level_meter')
390        )
391
392    def _root_ui_inventory_press(self) -> None:
393        import bauiv1
394        from bauiv1lib.inventory import InventoryWindow
395
396        self._auxiliary_window_nav(
397            win_type=InventoryWindow,
398            win_create_call=lambda: InventoryWindow(
399                origin_widget=bauiv1.get_special_widget('inventory_button')
400            ),
401        )
402
403    def _root_ui_get_tokens_press(self) -> None:
404        import bauiv1
405        from bauiv1lib.gettokens import GetTokensWindow
406
407        self._auxiliary_window_nav(
408            win_type=GetTokensWindow,
409            win_create_call=lambda: GetTokensWindow(
410                origin_widget=bauiv1.get_special_widget('get_tokens_button')
411            ),
412        )
413
414    def _root_ui_chest_slot_pressed(self, index: int) -> None:
415        print(f'CHEST {index} PRESSED')
416        screenmessage('UNDER CONSTRUCTION.')

 37class ClassicAppSubsystem(babase.AppSubsystem):
 38    """Subsystem for classic functionality in the app.
 39
 40    The single shared instance of this app can be accessed at
 41    babase.app.classic. Note that it is possible for babase.app.classic to
 42    be None if the classic package is not present, and code should handle
 43    that case gracefully.
 44    """
 45
 46    # pylint: disable=too-many-public-methods
 47
 48    # noinspection PyUnresolvedReferences
 49    from baclassic._music import MusicPlayMode
 50
 51    def __init__(self) -> None:
 52        super().__init__()
 53        self._env = babase.env()
 54
 55        self.accounts = AccountV1Subsystem()
 56        self.ads = AdsSubsystem()
 57        self.ach = AchievementSubsystem()
 58        self.store = StoreSubsystem()
 59        self.music = MusicSubsystem()
 60
 61        # Co-op Campaigns.
 62        self.campaigns: dict[str, bascenev1.Campaign] = {}
 63        self.custom_coop_practice_games: list[str] = []
 64
 65        # Lobby.
 66        self.lobby_random_profile_index: int = 1
 67        self.lobby_random_char_index_offset = random.randrange(1000)
 68        self.lobby_account_profile_device_id: int | None = None
 69
 70        # Misc.
 71        self.tips: list[str] = []
 72        self.stress_test_update_timer: babase.AppTimer | None = None
 73        self.stress_test_update_timer_2: babase.AppTimer | None = None
 74        self.value_test_defaults: dict = {}
 75        self.special_offer: dict | None = None
 76        self.ping_thread_count = 0
 77        self.allow_ticket_purchases: bool = True
 78
 79        # Main Menu.
 80        self.main_menu_did_initial_transition = False
 81        self.main_menu_last_news_fetch_time: float | None = None
 82
 83        # Spaz.
 84        self.spaz_appearances: dict[str, spazappearance.Appearance] = {}
 85        self.last_spaz_turbo_warn_time = babase.AppTime(-99999.0)
 86
 87        # Server Mode.
 88        self.server: ServerController | None = None
 89
 90        self.log_have_new = False
 91        self.log_upload_timer_started = False
 92        self.printed_live_object_warning = False
 93
 94        # We include this extra hash with shared input-mapping names so
 95        # that we don't share mappings between differently-configured
 96        # systems. For instance, different android devices may give different
 97        # key values for the same controller type so we keep their mappings
 98        # distinct.
 99        self.input_map_hash: str | None = None
100
101        # Maps.
102        self.maps: dict[str, type[bascenev1.Map]] = {}
103
104        # Gameplay.
105        self.teams_series_length = 7  # deprecated, left for old mods
106        self.ffa_series_length = 24  # deprecated, left for old mods
107        self.coop_session_args: dict = {}
108
109        # UI.
110        self.first_main_menu = True  # FIXME: Move to mainmenu class.
111        self.did_menu_intro = False  # FIXME: Move to mainmenu class.
112        self.main_menu_window_refresh_check_count = 0  # FIXME: Mv to mainmenu.
113        self.invite_confirm_windows: list[Any] = []  # FIXME: Don't use Any.
114        self.party_window: weakref.ref[PartyWindow] | None = None
115        self.main_menu_resume_callbacks: list = []
116        self.saved_ui_state: bauiv1.MainWindowState | None = None
117
118        # Store.
119        self.store_layout: dict[str, list[dict[str, Any]]] | None = None
120        self.store_items: dict[str, dict] | None = None
121        self.pro_sale_start_time: int | None = None
122        self.pro_sale_start_val: int | None = None
123
124    def add_main_menu_close_callback(self, call: Callable[[], Any]) -> None:
125        """(internal)"""
126
127        # If there's no main window up, just call immediately.
128        if not babase.app.ui_v1.has_main_window():
129            with babase.ContextRef.empty():
130                call()
131        else:
132            self.main_menu_resume_callbacks.append(call)
133
134    @property
135    def platform(self) -> str:
136        """Name of the current platform.
137
138        Examples are: 'mac', 'windows', android'.
139        """
140        assert isinstance(self._env['platform'], str)
141        return self._env['platform']
142
143    def scene_v1_protocol_version(self) -> int:
144        """(internal)"""
145        return bascenev1.protocol_version()
146
147    @property
148    def subplatform(self) -> str:
149        """String for subplatform.
150
151        Can be empty. For the 'android' platform, subplatform may
152        be 'google', 'amazon', etc.
153        """
154        assert isinstance(self._env['subplatform'], str)
155        return self._env['subplatform']
156
157    @property
158    def legacy_user_agent_string(self) -> str:
159        """String containing various bits of info about OS/device/etc."""
160        assert isinstance(self._env['legacy_user_agent_string'], str)
161        return self._env['legacy_user_agent_string']
162
163    @override
164    def on_app_loading(self) -> None:
165        from bascenev1lib.actor import spazappearance
166        from bascenev1lib import maps as stdmaps
167
168        plus = babase.app.plus
169        assert plus is not None
170
171        env = babase.app.env
172        cfg = babase.app.config
173
174        self.music.on_app_loading()
175
176        # Non-test, non-debug builds should generally be blessed; warn if not.
177        # (so I don't accidentally release a build that can't play tourneys)
178        if not env.debug and not env.test and not plus.is_blessed():
179            babase.screenmessage('WARNING: NON-BLESSED BUILD', color=(1, 0, 0))
180
181        # FIXME: This should not be hard-coded.
182        for maptype in [
183            stdmaps.HockeyStadium,
184            stdmaps.FootballStadium,
185            stdmaps.Bridgit,
186            stdmaps.BigG,
187            stdmaps.Roundabout,
188            stdmaps.MonkeyFace,
189            stdmaps.ZigZag,
190            stdmaps.ThePad,
191            stdmaps.DoomShroom,
192            stdmaps.LakeFrigid,
193            stdmaps.TipTop,
194            stdmaps.CragCastle,
195            stdmaps.TowerD,
196            stdmaps.HappyThoughts,
197            stdmaps.StepRightUp,
198            stdmaps.Courtyard,
199            stdmaps.Rampage,
200        ]:
201            bascenev1.register_map(maptype)
202
203        spazappearance.register_appearances()
204        bascenev1.init_campaigns()
205
206        launch_count = cfg.get('launchCount', 0)
207        launch_count += 1
208
209        # So we know how many times we've run the game at various
210        # version milestones.
211        for key in ('lc14173', 'lc14292'):
212            cfg.setdefault(key, launch_count)
213
214        cfg['launchCount'] = launch_count
215        cfg.commit()
216
217        # If there's a leftover log file, attempt to upload it to the
218        # master-server and/or get rid of it.
219        babase.handle_leftover_v1_cloud_log_file()
220
221        self.accounts.on_app_loading()
222
223    @override
224    def on_app_suspend(self) -> None:
225        self.accounts.on_app_suspend()
226
227    @override
228    def on_app_unsuspend(self) -> None:
229        self.accounts.on_app_unsuspend()
230        self.music.on_app_unsuspend()
231
232    @override
233    def on_app_shutdown(self) -> None:
234        self.music.on_app_shutdown()
235
236    def pause(self) -> None:
237        """Pause the game due to a user request or menu popping up.
238
239        If there's a foreground host-activity that says it's pausable, tell it
240        to pause. Note: we now no longer pause if there are connected clients.
241        """
242        activity: bascenev1.Activity | None = (
243            bascenev1.get_foreground_host_activity()
244        )
245        if (
246            activity is not None
247            and activity.allow_pausing
248            and not bascenev1.have_connected_clients()
249        ):
250            from babase import Lstr
251            from bascenev1 import NodeActor
252
253            # FIXME: Shouldn't be touching scene stuff here;
254            #  should just pass the request on to the host-session.
255            with activity.context:
256                globs = activity.globalsnode
257                if not globs.paused:
258                    bascenev1.getsound('refWhistle').play()
259                    globs.paused = True
260
261                # FIXME: This should not be an attr on Actor.
262                activity.paused_text = NodeActor(
263                    bascenev1.newnode(
264                        'text',
265                        attrs={
266                            'text': Lstr(resource='pausedByHostText'),
267                            'client_only': True,
268                            'flatness': 1.0,
269                            'h_align': 'center',
270                        },
271                    )
272                )
273
274    def resume(self) -> None:
275        """Resume the game due to a user request or menu closing.
276
277        If there's a foreground host-activity that's currently paused, tell it
278        to resume.
279        """
280
281        # FIXME: Shouldn't be touching scene stuff here;
282        #  should just pass the request on to the host-session.
283        activity = bascenev1.get_foreground_host_activity()
284        if activity is not None:
285            with activity.context:
286                globs = activity.globalsnode
287                if globs.paused:
288                    bascenev1.getsound('refWhistle').play()
289                    globs.paused = False
290
291                    # FIXME: This should not be an actor attr.
292                    activity.paused_text = None
293
294    def add_coop_practice_level(self, level: bascenev1.Level) -> None:
295        """Adds an individual level to the 'practice' section in Co-op."""
296
297        # Assign this level to our catch-all campaign.
298        self.campaigns['Challenges'].addlevel(level)
299
300        # Make note to add it to our challenges UI.
301        self.custom_coop_practice_games.append(f'Challenges:{level.name}')
302
303    def launch_coop_game(
304        self, game: str, force: bool = False, args: dict | None = None
305    ) -> bool:
306        """High level way to launch a local co-op session."""
307        # pylint: disable=cyclic-import
308        from bauiv1lib.coop.level import CoopLevelLockedWindow
309
310        assert babase.app.classic is not None
311
312        if args is None:
313            args = {}
314        if game == '':
315            raise ValueError('empty game name')
316        campaignname, levelname = game.split(':')
317        campaign = babase.app.classic.getcampaign(campaignname)
318
319        # If this campaign is sequential, make sure we've completed the
320        # one before this.
321        if campaign.sequential and not force:
322            for level in campaign.levels:
323                if level.name == levelname:
324                    break
325                if not level.complete:
326                    CoopLevelLockedWindow(
327                        campaign.getlevel(levelname).displayname,
328                        campaign.getlevel(level.name).displayname,
329                    )
330                    return False
331
332        # Save where we are in the UI to come back to when done.
333        babase.app.classic.save_ui_state()
334
335        # Ok, we're good to go.
336        self.coop_session_args = {
337            'campaign': campaignname,
338            'level': levelname,
339        }
340        for arg_name, arg_val in list(args.items()):
341            self.coop_session_args[arg_name] = arg_val
342
343        def _fade_end() -> None:
344            from bascenev1 import CoopSession
345
346            try:
347                bascenev1.new_host_session(CoopSession)
348            except Exception:
349                logging.exception('Error creating coopsession after fade end.')
350                from bascenev1lib.mainmenu import MainMenuSession
351
352                bascenev1.new_host_session(MainMenuSession)
353
354        babase.fade_screen(False, endcall=_fade_end)
355        return True
356
357    def return_to_main_menu_session_gracefully(
358        self, reset_ui: bool = True
359    ) -> None:
360        """Attempt to cleanly get back to the main menu."""
361        # pylint: disable=cyclic-import
362        from baclassic import _benchmark
363        from bascenev1lib.mainmenu import MainMenuSession
364
365        plus = babase.app.plus
366        assert plus is not None
367
368        if reset_ui:
369            babase.app.ui_v1.clear_main_window()
370
371        if isinstance(bascenev1.get_foreground_host_session(), MainMenuSession):
372            # It may be possible we're on the main menu but the screen is faded
373            # so fade back in.
374            babase.fade_screen(True)
375            return
376
377        _benchmark.stop_stress_test()  # Stop stress-test if in progress.
378
379        # If we're in a host-session, tell them to end.
380        # This lets them tear themselves down gracefully.
381        host_session: bascenev1.Session | None = (
382            bascenev1.get_foreground_host_session()
383        )
384        if host_session is not None:
385            # Kick off a little transaction so we'll hopefully have all the
386            # latest account state when we get back to the menu.
387            plus.add_v1_account_transaction(
388                {'type': 'END_SESSION', 'sType': str(type(host_session))}
389            )
390            plus.run_v1_account_transactions()
391
392            host_session.end()
393
394        # Otherwise just force the issue.
395        else:
396            babase.pushcall(
397                babase.Call(bascenev1.new_host_session, MainMenuSession)
398            )
399
400    def getmaps(self, playtype: str) -> list[str]:
401        """Return a list of bascenev1.Map types supporting a playtype str.
402
403        Category: **Asset Functions**
404
405        Maps supporting a given playtype must provide a particular set of
406        features and lend themselves to a certain style of play.
407
408        Play Types:
409
410        'melee'
411          General fighting map.
412          Has one or more 'spawn' locations.
413
414        'team_flag'
415          For games such as Capture The Flag where each team spawns by a flag.
416          Has two or more 'spawn' locations, each with a corresponding 'flag'
417          location (based on index).
418
419        'single_flag'
420          For games such as King of the Hill or Keep Away where multiple teams
421          are fighting over a single flag.
422          Has two or more 'spawn' locations and 1 'flag_default' location.
423
424        'conquest'
425          For games such as Conquest where flags are spread throughout the map
426          - has 2+ 'flag' locations, 2+ 'spawn_by_flag' locations.
427
428        'king_of_the_hill' - has 2+ 'spawn' locations,
429           1+ 'flag_default' locations, and 1+ 'powerup_spawn' locations
430
431        'hockey'
432          For hockey games.
433          Has two 'goal' locations, corresponding 'spawn' locations, and one
434          'flag_default' location (for where puck spawns)
435
436        'football'
437          For football games.
438          Has two 'goal' locations, corresponding 'spawn' locations, and one
439          'flag_default' location (for where flag/ball/etc. spawns)
440
441        'race'
442          For racing games where players much touch each region in order.
443          Has two or more 'race_point' locations.
444        """
445        return sorted(
446            key
447            for key, val in self.maps.items()
448            if playtype in val.get_play_types()
449        )
450
451    def game_begin_analytics(self) -> None:
452        """(internal)"""
453        from baclassic import _analytics
454
455        _analytics.game_begin_analytics()
456
457    @classmethod
458    def json_prep(cls, data: Any) -> Any:
459        """Return a json-friendly version of the provided data.
460
461        This converts any tuples to lists and any bytes to strings
462        (interpreted as utf-8, ignoring errors). Logs errors (just once)
463        if any data is modified/discarded/unsupported.
464        """
465
466        if isinstance(data, dict):
467            return dict(
468                (cls.json_prep(key), cls.json_prep(value))
469                for key, value in list(data.items())
470            )
471        if isinstance(data, list):
472            return [cls.json_prep(element) for element in data]
473        if isinstance(data, tuple):
474            logging.exception('json_prep encountered tuple')
475            return [cls.json_prep(element) for element in data]
476        if isinstance(data, bytes):
477            try:
478                return data.decode(errors='ignore')
479            except Exception:
480                logging.exception('json_prep encountered utf-8 decode error')
481                return data.decode(errors='ignore')
482        if not isinstance(data, (str, float, bool, type(None), int)):
483            logging.exception(
484                'got unsupported type in json_prep: %s', type(data)
485            )
486        return data
487
488    def master_server_v1_get(
489        self,
490        request: str,
491        data: dict[str, Any],
492        callback: MasterServerCallback | None = None,
493        response_type: MasterServerResponseType = MasterServerResponseType.JSON,
494    ) -> None:
495        """Make a call to the master server via a http GET."""
496
497        MasterServerV1CallThread(
498            request, 'get', data, callback, response_type
499        ).start()
500
501    def master_server_v1_post(
502        self,
503        request: str,
504        data: dict[str, Any],
505        callback: MasterServerCallback | None = None,
506        response_type: MasterServerResponseType = MasterServerResponseType.JSON,
507    ) -> None:
508        """Make a call to the master server via a http POST."""
509        MasterServerV1CallThread(
510            request, 'post', data, callback, response_type
511        ).start()
512
513    def get_tournament_prize_strings(self, entry: dict[str, Any]) -> list[str]:
514        """Given a tournament entry, return strings for its prize levels."""
515        from baclassic import _tournament
516
517        return _tournament.get_tournament_prize_strings(entry)
518
519    def getcampaign(self, name: str) -> bascenev1.Campaign:
520        """Return a campaign by name."""
521        return self.campaigns[name]
522
523    def get_next_tip(self) -> str:
524        """Returns the next tip to be displayed."""
525        if not self.tips:
526            for tip in get_all_tips():
527                self.tips.insert(random.randint(0, len(self.tips)), tip)
528        tip = self.tips.pop()
529        return tip
530
531    def run_cpu_benchmark(self) -> None:
532        """Kick off a benchmark to test cpu speeds."""
533        from baclassic._benchmark import run_cpu_benchmark
534
535        run_cpu_benchmark()
536
537    def run_media_reload_benchmark(self) -> None:
538        """Kick off a benchmark to test media reloading speeds."""
539        from baclassic._benchmark import run_media_reload_benchmark
540
541        run_media_reload_benchmark()
542
543    def run_stress_test(
544        self,
545        *,
546        playlist_type: str = 'Random',
547        playlist_name: str = '__default__',
548        player_count: int = 8,
549        round_duration: int = 30,
550        attract_mode: bool = False,
551    ) -> None:
552        """Run a stress test."""
553        from baclassic._benchmark import run_stress_test
554
555        run_stress_test(
556            playlist_type=playlist_type,
557            playlist_name=playlist_name,
558            player_count=player_count,
559            round_duration=round_duration,
560            attract_mode=attract_mode,
561        )
562
563    def get_input_device_mapped_value(
564        self,
565        device: bascenev1.InputDevice,
566        name: str,
567        default: bool = False,
568    ) -> Any:
569        """Return a mapped value for an input device.
570
571        This checks the user config and falls back to default values
572        where available.
573        """
574        return _input.get_input_device_mapped_value(
575            device.name, device.unique_identifier, name, default
576        )
577
578    def get_input_device_map_hash(
579        self, inputdevice: bascenev1.InputDevice
580    ) -> str:
581        """Given an input device, return hash based on its raw input values."""
582        del inputdevice  # unused currently
583        return _input.get_input_device_map_hash()
584
585    def get_input_device_config(
586        self, inputdevice: bascenev1.InputDevice, default: bool
587    ) -> tuple[dict, str]:
588        """Given an input device, return its config dict in the app config.
589
590        The dict will be created if it does not exist.
591        """
592        return _input.get_input_device_config(
593            inputdevice.name, inputdevice.unique_identifier, default
594        )
595
596    def get_player_colors(self) -> list[tuple[float, float, float]]:
597        """Return user-selectable player colors."""
598        return bascenev1.get_player_colors()
599
600    def get_player_profile_icon(self, profilename: str) -> str:
601        """Given a profile name, returns an icon string for it.
602
603        (non-account profiles only)
604        """
605        return bascenev1.get_player_profile_icon(profilename)
606
607    def get_player_profile_colors(
608        self,
609        profilename: str | None,
610        profiles: dict[str, dict[str, Any]] | None = None,
611    ) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
612        """Given a profile, return colors for them."""
613        return bascenev1.get_player_profile_colors(profilename, profiles)
614
615    def get_foreground_host_session(self) -> bascenev1.Session | None:
616        """(internal)"""
617        return bascenev1.get_foreground_host_session()
618
619    def get_foreground_host_activity(self) -> bascenev1.Activity | None:
620        """(internal)"""
621        return bascenev1.get_foreground_host_activity()
622
623    def value_test(
624        self,
625        arg: str,
626        change: float | None = None,
627        absolute: float | None = None,
628    ) -> float:
629        """(internal)"""
630        return _baclassic.value_test(arg, change, absolute)
631
632    def set_master_server_source(self, source: int) -> None:
633        """(internal)"""
634        bascenev1.set_master_server_source(source)
635
636    def get_game_port(self) -> int:
637        """(internal)"""
638        return bascenev1.get_game_port()
639
640    def v2_upgrade_window(self, login_name: str, code: str) -> None:
641        """(internal)"""
642
643        from bauiv1lib.v2upgrade import V2UpgradeWindow
644
645        V2UpgradeWindow(login_name, code)
646
647    def account_link_code_window(self, data: dict[str, Any]) -> None:
648        """(internal)"""
649        from bauiv1lib.account.link import AccountLinkCodeWindow
650
651        AccountLinkCodeWindow(data)
652
653    def server_dialog(self, delay: float, data: dict[str, Any]) -> None:
654        """(internal)"""
655        from bauiv1lib.serverdialog import (
656            ServerDialogData,
657            ServerDialogWindow,
658        )
659
660        try:
661            sddata = dataclass_from_dict(ServerDialogData, data)
662        except Exception:
663            sddata = None
664            logging.warning(
665                'Got malformatted ServerDialogData: %s',
666                data,
667            )
668        if sddata is not None:
669            babase.apptimer(
670                delay,
671                babase.Call(ServerDialogWindow, sddata),
672            )
673
674    # def root_ui_ticket_icon_press(self) -> None:
675    #     """(internal)"""
676    #     from bauiv1lib.resourcetypeinfo import ResourceTypeInfoWindow
677
678    #     ResourceTypeInfoWindow(
679    #         origin_widget=bauiv1.get_special_widget('tickets_meter')
680    #     )
681
682    def show_url_window(self, address: str) -> None:
683        """(internal)"""
684        from bauiv1lib.url import ShowURLWindow
685
686        ShowURLWindow(address)
687
688    def quit_window(self, quit_type: babase.QuitType) -> None:
689        """(internal)"""
690        from bauiv1lib.confirm import QuitWindow
691
692        QuitWindow(quit_type)
693
694    def tournament_entry_window(
695        self,
696        tournament_id: str,
697        *,
698        tournament_activity: bascenev1.Activity | None = None,
699        position: tuple[float, float] = (0.0, 0.0),
700        delegate: Any = None,
701        scale: float | None = None,
702        offset: tuple[float, float] = (0.0, 0.0),
703        on_close_call: Callable[[], Any] | None = None,
704    ) -> None:
705        """(internal)"""
706        from bauiv1lib.tournamententry import TournamentEntryWindow
707
708        TournamentEntryWindow(
709            tournament_id,
710            tournament_activity,
711            position,
712            delegate,
713            scale,
714            offset,
715            on_close_call,
716        )
717
718    def get_main_menu_session(self) -> type[bascenev1.Session]:
719        """(internal)"""
720        from bascenev1lib.mainmenu import MainMenuSession
721
722        return MainMenuSession
723
724    def profile_browser_window(
725        self,
726        transition: str = 'in_right',
727        origin_widget: bauiv1.Widget | None = None,
728        # in_main_menu: bool = True,
729        selected_profile: str | None = None,
730    ) -> None:
731        """(internal)"""
732        from bauiv1lib.profile.browser import ProfileBrowserWindow
733
734        main_window = babase.app.ui_v1.get_main_window()
735        if main_window is not None:
736            logging.warning(
737                'profile_browser_window()'
738                ' called with existing main window; should not happen.'
739            )
740            return
741
742        babase.app.ui_v1.set_main_window(
743            ProfileBrowserWindow(
744                transition=transition,
745                selected_profile=selected_profile,
746                origin_widget=origin_widget,
747                minimal_toolbar=True,
748            ),
749            is_top_level=True,
750            suppress_warning=True,
751        )
752
753    def preload_map_preview_media(self) -> None:
754        """Preload media needed for map preview UIs.
755
756        Category: **Asset Functions**
757        """
758        try:
759            bauiv1.getmesh('level_select_button_opaque')
760            bauiv1.getmesh('level_select_button_transparent')
761            for maptype in list(self.maps.values()):
762                map_tex_name = maptype.get_preview_texture_name()
763                if map_tex_name is not None:
764                    bauiv1.gettexture(map_tex_name)
765        except Exception:
766            logging.exception('Error preloading map preview media.')
767
768    def party_icon_activate(self, origin: Sequence[float]) -> None:
769        """(internal)"""
770        from bauiv1lib.party import PartyWindow
771        from babase import app
772
773        assert app.env.gui
774
775        # Play explicit swish sound so it occurs due to keypresses/etc.
776        # This means we have to disable it for any button or else we get
777        # double.
778        bauiv1.getsound('swish').play()
779
780        # If it exists, dismiss it; otherwise make a new one.
781        party_window = (
782            None if self.party_window is None else self.party_window()
783        )
784        if party_window is not None:
785            party_window.close()
786        else:
787            self.party_window = weakref.ref(PartyWindow(origin=origin))
788
789    def device_menu_press(self, device_id: int | None) -> None:
790        """(internal)"""
791        from bauiv1lib.ingamemenu import InGameMenuWindow
792        from bauiv1 import set_ui_input_device
793
794        assert babase.app is not None
795        in_main_menu = babase.app.ui_v1.has_main_window()
796        if not in_main_menu:
797            set_ui_input_device(device_id)
798
799            # Hack(ish). We play swish sound here so it happens for
800            # device presses, but this means we need to disable default
801            # swish sounds for any menu buttons or we'll get double.
802            if babase.app.env.gui:
803                bauiv1.getsound('swish').play()
804
805            babase.app.ui_v1.set_main_window(
806                InGameMenuWindow(), is_top_level=True, suppress_warning=True
807            )
808
809    def save_ui_state(self) -> None:
810        """Store our current place in the UI."""
811        ui = babase.app.ui_v1
812        mainwindow = ui.get_main_window()
813        if mainwindow is not None:
814            self.saved_ui_state = ui.save_main_window_state(mainwindow)
815        else:
816            self.saved_ui_state = None
817
818    def invoke_main_menu_ui(self) -> None:
819        """Bring up main menu ui."""
820
821        # Bring up the last place we were, or start at the main menu
822        # otherwise.
823        app = bauiv1.app
824        env = app.env
825        with bascenev1.ContextRef.empty():
826            # from bauiv1lib import specialoffer
827
828            assert app.classic is not None
829            if app.env.headless:
830                # UI stuff fails now in headless builds; avoid it.
831                pass
832            else:
833
834                # When coming back from a kiosk-mode game, jump to the
835                # kiosk start screen.
836                if env.demo or env.arcade:
837                    # pylint: disable=cyclic-import
838                    from bauiv1lib.kiosk import KioskWindow
839
840                    app.ui_v1.set_main_window(
841                        KioskWindow(), is_top_level=True, suppress_warning=True
842                    )
843                else:
844                    # If there's a saved ui state, restore that.
845                    if self.saved_ui_state is not None:
846                        app.ui_v1.restore_main_window_state(self.saved_ui_state)
847                    else:
848                        # Otherwise start fresh at the main menu.
849                        from bauiv1lib.mainmenu import MainMenuWindow
850
851                        app.ui_v1.set_main_window(
852                            MainMenuWindow(transition=None),
853                            is_top_level=True,
854                            suppress_warning=True,
855                        )