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