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