baclassic

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