bauiv1lib.playlist.browser

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Provides a window for browsing and launching game playlists."""
  4
  5from __future__ import annotations
  6
  7import logging
  8import copy
  9import math
 10
 11import bascenev1 as bs
 12import bauiv1 as bui
 13
 14
 15class PlaylistBrowserWindow(bui.Window):
 16    """Window for starting teams games."""
 17
 18    def __init__(
 19        self,
 20        sessiontype: type[bs.Session],
 21        transition: str | None = 'in_right',
 22        origin_widget: bui.Widget | None = None,
 23    ):
 24        # pylint: disable=too-many-statements
 25        # pylint: disable=cyclic-import
 26        from bauiv1lib.playlist import PlaylistTypeVars
 27
 28        # If they provided an origin-widget, scale up from that.
 29        scale_origin: tuple[float, float] | None
 30        if origin_widget is not None:
 31            self._transition_out = 'out_scale'
 32            scale_origin = origin_widget.get_screen_space_center()
 33            transition = 'in_scale'
 34        else:
 35            self._transition_out = 'out_right'
 36            scale_origin = None
 37
 38        assert bui.app.classic is not None
 39
 40        # Store state for when we exit the next game.
 41        if issubclass(sessiontype, bs.DualTeamSession):
 42            bui.app.ui_v1.set_main_menu_location('Team Game Select')
 43            bui.set_analytics_screen('Teams Window')
 44        elif issubclass(sessiontype, bs.FreeForAllSession):
 45            bui.app.ui_v1.set_main_menu_location('Free-for-All Game Select')
 46            bui.set_analytics_screen('FreeForAll Window')
 47        else:
 48            raise TypeError(f'Invalid sessiontype: {sessiontype}.')
 49        self._pvars = PlaylistTypeVars(sessiontype)
 50
 51        self._sessiontype = sessiontype
 52
 53        self._customize_button: bui.Widget | None = None
 54        self._sub_width: float | None = None
 55        self._sub_height: float | None = None
 56
 57        self._ensure_standard_playlists_exist()
 58
 59        # Get the current selection (if any).
 60        self._selected_playlist = bui.app.config.get(
 61            self._pvars.config_name + ' Playlist Selection'
 62        )
 63
 64        uiscale = bui.app.ui_v1.uiscale
 65        self._width = 1100.0 if uiscale is bui.UIScale.SMALL else 800.0
 66        x_inset = 150 if uiscale is bui.UIScale.SMALL else 0
 67        self._height = (
 68            480
 69            if uiscale is bui.UIScale.SMALL
 70            else 510 if uiscale is bui.UIScale.MEDIUM else 580
 71        )
 72
 73        top_extra = 20 if uiscale is bui.UIScale.SMALL else 0
 74
 75        super().__init__(
 76            root_widget=bui.containerwidget(
 77                size=(self._width, self._height + top_extra),
 78                transition=transition,
 79                toolbar_visibility='menu_full',
 80                scale_origin_stack_offset=scale_origin,
 81                scale=(
 82                    1.69
 83                    if uiscale is bui.UIScale.SMALL
 84                    else 1.05 if uiscale is bui.UIScale.MEDIUM else 0.9
 85                ),
 86                stack_offset=(
 87                    (0, -26) if uiscale is bui.UIScale.SMALL else (0, 0)
 88                ),
 89            )
 90        )
 91
 92        self._back_button: bui.Widget | None = bui.buttonwidget(
 93            parent=self._root_widget,
 94            position=(59 + x_inset, self._height - 70),
 95            size=(120, 60),
 96            scale=1.0,
 97            on_activate_call=self._on_back_press,
 98            autoselect=True,
 99            label=bui.Lstr(resource='backText'),
100            button_type='back',
101        )
102        bui.containerwidget(
103            edit=self._root_widget, cancel_button=self._back_button
104        )
105        txt = self._title_text = bui.textwidget(
106            parent=self._root_widget,
107            position=(self._width * 0.5, self._height - 41),
108            size=(0, 0),
109            text=self._pvars.window_title_name,
110            scale=1.3,
111            res_scale=1.5,
112            color=bui.app.ui_v1.heading_color,
113            h_align='center',
114            v_align='center',
115        )
116        if uiscale is bui.UIScale.SMALL and bui.app.ui_v1.use_toolbars:
117            bui.textwidget(edit=txt, text='')
118
119        bui.buttonwidget(
120            edit=self._back_button,
121            button_type='backSmall',
122            size=(60, 54),
123            position=(59 + x_inset, self._height - 67),
124            label=bui.charstr(bui.SpecialChar.BACK),
125        )
126
127        if uiscale is bui.UIScale.SMALL and bui.app.ui_v1.use_toolbars:
128            self._back_button.delete()
129            self._back_button = None
130            bui.containerwidget(
131                edit=self._root_widget, on_cancel_call=self._on_back_press
132            )
133            scroll_offs = 33
134        else:
135            scroll_offs = 0
136        self._scroll_width = self._width - (100 + 2 * x_inset)
137        self._scroll_height = self._height - (
138            146
139            if uiscale is bui.UIScale.SMALL and bui.app.ui_v1.use_toolbars
140            else 136
141        )
142        self._scrollwidget = bui.scrollwidget(
143            parent=self._root_widget,
144            highlight=False,
145            size=(self._scroll_width, self._scroll_height),
146            position=(
147                (self._width - self._scroll_width) * 0.5,
148                65 + scroll_offs,
149            ),
150        )
151        bui.containerwidget(edit=self._scrollwidget, claims_left_right=True)
152        self._subcontainer: bui.Widget | None = None
153        self._config_name_full = self._pvars.config_name + ' Playlists'
154        self._last_config = None
155
156        # Update now and once per second.
157        # (this should do our initial refresh)
158        self._update()
159        self._update_timer = bui.AppTimer(
160            1.0, bui.WeakCall(self._update), repeat=True
161        )
162
163    def _ensure_standard_playlists_exist(self) -> None:
164        plus = bui.app.plus
165        assert plus is not None
166
167        # On new installations, go ahead and create a few playlists
168        # besides the hard-coded default one:
169        if not plus.get_v1_account_misc_val('madeStandardPlaylists', False):
170            plus.add_v1_account_transaction(
171                {
172                    'type': 'ADD_PLAYLIST',
173                    'playlistType': 'Free-for-All',
174                    'playlistName': bui.Lstr(
175                        resource='singleGamePlaylistNameText'
176                    )
177                    .evaluate()
178                    .replace(
179                        '${GAME}',
180                        bui.Lstr(
181                            translate=('gameNames', 'Death Match')
182                        ).evaluate(),
183                    ),
184                    'playlist': [
185                        {
186                            'type': 'bs_death_match.DeathMatchGame',
187                            'settings': {
188                                'Epic Mode': False,
189                                'Kills to Win Per Player': 10,
190                                'Respawn Times': 1.0,
191                                'Time Limit': 300,
192                                'map': 'Doom Shroom',
193                            },
194                        },
195                        {
196                            'type': 'bs_death_match.DeathMatchGame',
197                            'settings': {
198                                'Epic Mode': False,
199                                'Kills to Win Per Player': 10,
200                                'Respawn Times': 1.0,
201                                'Time Limit': 300,
202                                'map': 'Crag Castle',
203                            },
204                        },
205                    ],
206                }
207            )
208            plus.add_v1_account_transaction(
209                {
210                    'type': 'ADD_PLAYLIST',
211                    'playlistType': 'Team Tournament',
212                    'playlistName': bui.Lstr(
213                        resource='singleGamePlaylistNameText'
214                    )
215                    .evaluate()
216                    .replace(
217                        '${GAME}',
218                        bui.Lstr(
219                            translate=('gameNames', 'Capture the Flag')
220                        ).evaluate(),
221                    ),
222                    'playlist': [
223                        {
224                            'type': 'bs_capture_the_flag.CTFGame',
225                            'settings': {
226                                'map': 'Bridgit',
227                                'Score to Win': 3,
228                                'Flag Idle Return Time': 30,
229                                'Flag Touch Return Time': 0,
230                                'Respawn Times': 1.0,
231                                'Time Limit': 600,
232                                'Epic Mode': False,
233                            },
234                        },
235                        {
236                            'type': 'bs_capture_the_flag.CTFGame',
237                            'settings': {
238                                'map': 'Roundabout',
239                                'Score to Win': 2,
240                                'Flag Idle Return Time': 30,
241                                'Flag Touch Return Time': 0,
242                                'Respawn Times': 1.0,
243                                'Time Limit': 600,
244                                'Epic Mode': False,
245                            },
246                        },
247                        {
248                            'type': 'bs_capture_the_flag.CTFGame',
249                            'settings': {
250                                'map': 'Tip Top',
251                                'Score to Win': 2,
252                                'Flag Idle Return Time': 30,
253                                'Flag Touch Return Time': 3,
254                                'Respawn Times': 1.0,
255                                'Time Limit': 300,
256                                'Epic Mode': False,
257                            },
258                        },
259                    ],
260                }
261            )
262            plus.add_v1_account_transaction(
263                {
264                    'type': 'ADD_PLAYLIST',
265                    'playlistType': 'Team Tournament',
266                    'playlistName': bui.Lstr(
267                        translate=('playlistNames', 'Just Sports')
268                    ).evaluate(),
269                    'playlist': [
270                        {
271                            'type': 'bs_hockey.HockeyGame',
272                            'settings': {
273                                'Time Limit': 0,
274                                'map': 'Hockey Stadium',
275                                'Score to Win': 1,
276                                'Respawn Times': 1.0,
277                            },
278                        },
279                        {
280                            'type': 'bs_football.FootballTeamGame',
281                            'settings': {
282                                'Time Limit': 0,
283                                'map': 'Football Stadium',
284                                'Score to Win': 21,
285                                'Respawn Times': 1.0,
286                            },
287                        },
288                    ],
289                }
290            )
291            plus.add_v1_account_transaction(
292                {
293                    'type': 'ADD_PLAYLIST',
294                    'playlistType': 'Free-for-All',
295                    'playlistName': bui.Lstr(
296                        translate=('playlistNames', 'Just Epic')
297                    ).evaluate(),
298                    'playlist': [
299                        {
300                            'type': 'bs_elimination.EliminationGame',
301                            'settings': {
302                                'Time Limit': 120,
303                                'map': 'Tip Top',
304                                'Respawn Times': 1.0,
305                                'Lives Per Player': 1,
306                                'Epic Mode': 1,
307                            },
308                        }
309                    ],
310                }
311            )
312            plus.add_v1_account_transaction(
313                {
314                    'type': 'SET_MISC_VAL',
315                    'name': 'madeStandardPlaylists',
316                    'value': True,
317                }
318            )
319            plus.run_v1_account_transactions()
320
321    def _refresh(self) -> None:
322        # FIXME: Should tidy this up.
323        # pylint: disable=too-many-statements
324        # pylint: disable=too-many-branches
325        # pylint: disable=too-many-locals
326        # pylint: disable=too-many-nested-blocks
327        from efro.util import asserttype
328        from bascenev1 import get_map_class, filter_playlist
329
330        if not self._root_widget:
331            return
332        if self._subcontainer is not None:
333            self._save_state()
334            self._subcontainer.delete()
335
336        # Make sure config exists.
337        if self._config_name_full not in bui.app.config:
338            bui.app.config[self._config_name_full] = {}
339
340        items = list(bui.app.config[self._config_name_full].items())
341
342        # Make sure everything is unicode.
343        items = [
344            (i[0].decode(), i[1]) if not isinstance(i[0], str) else i
345            for i in items
346        ]
347
348        items.sort(key=lambda x2: asserttype(x2[0], str).lower())
349        items = [['__default__', None]] + items  # default is always first
350
351        count = len(items)
352        columns = 3
353        rows = int(math.ceil(float(count) / columns))
354        button_width = 230
355        button_height = 230
356        button_buffer_h = -3
357        button_buffer_v = 0
358
359        self._sub_width = self._scroll_width
360        self._sub_height = (
361            40.0 + rows * (button_height + 2 * button_buffer_v) + 90
362        )
363        assert self._sub_width is not None
364        assert self._sub_height is not None
365        self._subcontainer = bui.containerwidget(
366            parent=self._scrollwidget,
367            size=(self._sub_width, self._sub_height),
368            background=False,
369        )
370
371        children = self._subcontainer.get_children()
372        for child in children:
373            child.delete()
374
375        assert bui.app.classic is not None
376        bui.textwidget(
377            parent=self._subcontainer,
378            text=bui.Lstr(resource='playlistsText'),
379            position=(40, self._sub_height - 26),
380            size=(0, 0),
381            scale=1.0,
382            maxwidth=400,
383            color=bui.app.ui_v1.title_color,
384            h_align='left',
385            v_align='center',
386        )
387
388        index = 0
389        appconfig = bui.app.config
390
391        mesh_opaque = bui.getmesh('level_select_button_opaque')
392        mesh_transparent = bui.getmesh('level_select_button_transparent')
393        mask_tex = bui.gettexture('mapPreviewMask')
394
395        h_offs = 225 if count == 1 else 115 if count == 2 else 0
396        h_offs_bottom = 0
397
398        uiscale = bui.app.ui_v1.uiscale
399        for y in range(rows):
400            for x in range(columns):
401                name = items[index][0]
402                assert name is not None
403                pos = (
404                    x * (button_width + 2 * button_buffer_h)
405                    + button_buffer_h
406                    + 8
407                    + h_offs,
408                    self._sub_height
409                    - 47
410                    - (y + 1) * (button_height + 2 * button_buffer_v),
411                )
412                btn = bui.buttonwidget(
413                    parent=self._subcontainer,
414                    button_type='square',
415                    size=(button_width, button_height),
416                    autoselect=True,
417                    label='',
418                    position=pos,
419                )
420
421                if (
422                    x == 0
423                    and bui.app.ui_v1.use_toolbars
424                    and uiscale is bui.UIScale.SMALL
425                ):
426                    bui.widget(
427                        edit=btn,
428                        left_widget=bui.get_special_widget('back_button'),
429                    )
430                if (
431                    x == columns - 1
432                    and bui.app.ui_v1.use_toolbars
433                    and uiscale is bui.UIScale.SMALL
434                ):
435                    bui.widget(
436                        edit=btn,
437                        right_widget=bui.get_special_widget('party_button'),
438                    )
439                bui.buttonwidget(
440                    edit=btn,
441                    on_activate_call=bui.Call(
442                        self._on_playlist_press, btn, name
443                    ),
444                    on_select_call=bui.Call(self._on_playlist_select, name),
445                )
446                bui.widget(edit=btn, show_buffer_top=50, show_buffer_bottom=50)
447
448                if self._selected_playlist == name:
449                    bui.containerwidget(
450                        edit=self._subcontainer,
451                        selected_child=btn,
452                        visible_child=btn,
453                    )
454
455                if self._back_button is not None:
456                    if y == 0:
457                        bui.widget(edit=btn, up_widget=self._back_button)
458                    if x == 0:
459                        bui.widget(edit=btn, left_widget=self._back_button)
460
461                print_name: str | bui.Lstr | None
462                if name == '__default__':
463                    print_name = self._pvars.default_list_name
464                else:
465                    print_name = name
466                bui.textwidget(
467                    parent=self._subcontainer,
468                    text=print_name,
469                    position=(
470                        pos[0] + button_width * 0.5,
471                        pos[1] + button_height * 0.79,
472                    ),
473                    size=(0, 0),
474                    scale=button_width * 0.003,
475                    maxwidth=button_width * 0.7,
476                    draw_controller=btn,
477                    h_align='center',
478                    v_align='center',
479                )
480
481                # Poke into this playlist and see if we can display some of
482                # its maps.
483                map_images = []
484                try:
485                    map_textures = []
486                    map_texture_entries = []
487                    if name == '__default__':
488                        playlist = self._pvars.get_default_list_call()
489                    else:
490                        if (
491                            name
492                            not in appconfig[
493                                self._pvars.config_name + ' Playlists'
494                            ]
495                        ):
496                            print(
497                                'NOT FOUND ERR',
498                                appconfig[
499                                    self._pvars.config_name + ' Playlists'
500                                ],
501                            )
502                        playlist = appconfig[
503                            self._pvars.config_name + ' Playlists'
504                        ][name]
505                    playlist = filter_playlist(
506                        playlist,
507                        self._sessiontype,
508                        remove_unowned=False,
509                        mark_unowned=True,
510                        name=name,
511                    )
512                    for entry in playlist:
513                        mapname = entry['settings']['map']
514                        maptype: type[bs.Map] | None
515                        try:
516                            maptype = get_map_class(mapname)
517                        except bui.NotFoundError:
518                            maptype = None
519                        if maptype is not None:
520                            tex_name = maptype.get_preview_texture_name()
521                            if tex_name is not None:
522                                map_textures.append(tex_name)
523                                map_texture_entries.append(entry)
524                        if len(map_textures) >= 6:
525                            break
526
527                    if len(map_textures) > 4:
528                        img_rows = 3
529                        img_columns = 2
530                        scl = 0.33
531                        h_offs_img = 30
532                        v_offs_img = 126
533                    elif len(map_textures) > 2:
534                        img_rows = 2
535                        img_columns = 2
536                        scl = 0.35
537                        h_offs_img = 24
538                        v_offs_img = 110
539                    elif len(map_textures) > 1:
540                        img_rows = 2
541                        img_columns = 1
542                        scl = 0.5
543                        h_offs_img = 47
544                        v_offs_img = 105
545                    else:
546                        img_rows = 1
547                        img_columns = 1
548                        scl = 0.75
549                        h_offs_img = 20
550                        v_offs_img = 65
551
552                    v = None
553                    for row in range(img_rows):
554                        for col in range(img_columns):
555                            tex_index = row * img_columns + col
556                            if tex_index < len(map_textures):
557                                entry = map_texture_entries[tex_index]
558
559                                owned = not (
560                                    (
561                                        'is_unowned_map' in entry
562                                        and entry['is_unowned_map']
563                                    )
564                                    or (
565                                        'is_unowned_game' in entry
566                                        and entry['is_unowned_game']
567                                    )
568                                )
569
570                                tex_name = map_textures[tex_index]
571                                h = pos[0] + h_offs_img + scl * 250 * col
572                                v = pos[1] + v_offs_img - scl * 130 * row
573                                map_images.append(
574                                    bui.imagewidget(
575                                        parent=self._subcontainer,
576                                        size=(scl * 250.0, scl * 125.0),
577                                        position=(h, v),
578                                        texture=bui.gettexture(tex_name),
579                                        opacity=1.0 if owned else 0.25,
580                                        draw_controller=btn,
581                                        mesh_opaque=mesh_opaque,
582                                        mesh_transparent=mesh_transparent,
583                                        mask_texture=mask_tex,
584                                    )
585                                )
586                                if not owned:
587                                    bui.imagewidget(
588                                        parent=self._subcontainer,
589                                        size=(scl * 100.0, scl * 100.0),
590                                        position=(h + scl * 75, v + scl * 10),
591                                        texture=bui.gettexture('lock'),
592                                        draw_controller=btn,
593                                    )
594                        if v is not None:
595                            v -= scl * 130.0
596
597                except Exception:
598                    logging.exception('Error listing playlist maps.')
599
600                if not map_images:
601                    bui.textwidget(
602                        parent=self._subcontainer,
603                        text='???',
604                        scale=1.5,
605                        size=(0, 0),
606                        color=(1, 1, 1, 0.5),
607                        h_align='center',
608                        v_align='center',
609                        draw_controller=btn,
610                        position=(
611                            pos[0] + button_width * 0.5,
612                            pos[1] + button_height * 0.5,
613                        ),
614                    )
615
616                index += 1
617
618                if index >= count:
619                    break
620            if index >= count:
621                break
622        self._customize_button = btn = bui.buttonwidget(
623            parent=self._subcontainer,
624            size=(100, 30),
625            position=(34 + h_offs_bottom, 50),
626            text_scale=0.6,
627            label=bui.Lstr(resource='customizeText'),
628            on_activate_call=self._on_customize_press,
629            color=(0.54, 0.52, 0.67),
630            textcolor=(0.7, 0.65, 0.7),
631            autoselect=True,
632        )
633        bui.widget(edit=btn, show_buffer_top=22, show_buffer_bottom=28)
634        self._restore_state()
635
636    def on_play_options_window_run_game(self) -> None:
637        """(internal)"""
638        if not self._root_widget:
639            return
640        bui.containerwidget(edit=self._root_widget, transition='out_left')
641
642    def _on_playlist_select(self, playlist_name: str) -> None:
643        self._selected_playlist = playlist_name
644
645    def _update(self) -> None:
646        # make sure config exists
647        if self._config_name_full not in bui.app.config:
648            bui.app.config[self._config_name_full] = {}
649
650        cfg = bui.app.config[self._config_name_full]
651        if cfg != self._last_config:
652            self._last_config = copy.deepcopy(cfg)
653            self._refresh()
654
655    def _on_playlist_press(
656        self, button: bui.Widget, playlist_name: str
657    ) -> None:
658        # pylint: disable=cyclic-import
659        from bauiv1lib.playoptions import PlayOptionsWindow
660
661        # Make sure the target playlist still exists.
662        exists = (
663            playlist_name == '__default__'
664            or playlist_name in bui.app.config.get(self._config_name_full, {})
665        )
666        if not exists:
667            return
668
669        self._save_state()
670        PlayOptionsWindow(
671            sessiontype=self._sessiontype,
672            scale_origin=button.get_screen_space_center(),
673            playlist=playlist_name,
674            delegate=self,
675        )
676
677    def _on_customize_press(self) -> None:
678        # pylint: disable=cyclic-import
679        from bauiv1lib.playlist.customizebrowser import (
680            PlaylistCustomizeBrowserWindow,
681        )
682
683        # no-op if our underlying widget is dead or on its way out.
684        if not self._root_widget or self._root_widget.transitioning_out:
685            return
686
687        self._save_state()
688        bui.containerwidget(edit=self._root_widget, transition='out_left')
689        assert bui.app.classic is not None
690        bui.app.ui_v1.set_main_menu_window(
691            PlaylistCustomizeBrowserWindow(
692                origin_widget=self._customize_button,
693                sessiontype=self._sessiontype,
694            ).get_root_widget(),
695            from_window=self._root_widget,
696        )
697
698    def _on_back_press(self) -> None:
699        # pylint: disable=cyclic-import
700        from bauiv1lib.play import PlayWindow
701
702        # no-op if our underlying widget is dead or on its way out.
703        if not self._root_widget or self._root_widget.transitioning_out:
704            return
705
706        # Store our selected playlist if that's changed.
707        if self._selected_playlist is not None:
708            prev_sel = bui.app.config.get(
709                self._pvars.config_name + ' Playlist Selection'
710            )
711            if self._selected_playlist != prev_sel:
712                cfg = bui.app.config
713                cfg[self._pvars.config_name + ' Playlist Selection'] = (
714                    self._selected_playlist
715                )
716                cfg.commit()
717
718        self._save_state()
719        bui.containerwidget(
720            edit=self._root_widget, transition=self._transition_out
721        )
722        assert bui.app.classic is not None
723        bui.app.ui_v1.set_main_menu_window(
724            PlayWindow(transition='in_left').get_root_widget(),
725            from_window=self._root_widget,
726        )
727
728    def _save_state(self) -> None:
729        try:
730            sel = self._root_widget.get_selected_child()
731            if sel == self._back_button:
732                sel_name = 'Back'
733            elif sel == self._scrollwidget:
734                assert self._subcontainer is not None
735                subsel = self._subcontainer.get_selected_child()
736                if subsel == self._customize_button:
737                    sel_name = 'Customize'
738                else:
739                    sel_name = 'Scroll'
740            else:
741                raise RuntimeError('Unrecognized selected widget.')
742            assert bui.app.classic is not None
743            bui.app.ui_v1.window_states[type(self)] = sel_name
744        except Exception:
745            logging.exception('Error saving state for %s.', self)
746
747    def _restore_state(self) -> None:
748        try:
749            assert bui.app.classic is not None
750            sel_name = bui.app.ui_v1.window_states.get(type(self))
751            if sel_name == 'Back':
752                sel = self._back_button
753            elif sel_name == 'Scroll':
754                sel = self._scrollwidget
755            elif sel_name == 'Customize':
756                sel = self._scrollwidget
757                bui.containerwidget(
758                    edit=self._subcontainer,
759                    selected_child=self._customize_button,
760                    visible_child=self._customize_button,
761                )
762            else:
763                sel = self._scrollwidget
764            bui.containerwidget(edit=self._root_widget, selected_child=sel)
765        except Exception:
766            logging.exception('Error restoring state for %s.', self)