bauiv1lib.ingamemenu

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Implements the in-gmae menu window."""
  4
  5from __future__ import annotations
  6
  7from typing import TYPE_CHECKING, override
  8import logging
  9
 10import bauiv1 as bui
 11import bascenev1 as bs
 12
 13if TYPE_CHECKING:
 14    from typing import Any, Callable
 15
 16
 17class InGameMenuWindow(bui.MainWindow):
 18    """The menu that can be invoked while in a game."""
 19
 20    def __init__(
 21        self,
 22        transition: str | None = 'in_right',
 23        origin_widget: bui.Widget | None = None,
 24    ):
 25
 26        # Make a vanilla container; we'll modify it to our needs in
 27        # refresh.
 28        super().__init__(
 29            root_widget=bui.containerwidget(
 30                toolbar_visibility=('menu_in_game')
 31            ),
 32            transition=transition,
 33            origin_widget=origin_widget,
 34        )
 35
 36        # Grab this stuff in case it changes.
 37        self._is_demo = bui.app.env.demo
 38        self._is_arcade = bui.app.env.arcade
 39
 40        self._p_index = 0
 41        self._use_autoselect = True
 42        self._button_width = 200.0
 43        self._button_height = 45.0
 44        self._width = 100.0
 45        self._height = 100.0
 46
 47        self._refresh()
 48
 49    @override
 50    def get_main_window_state(self) -> bui.MainWindowState:
 51        cls = type(self)
 52        return bui.BasicMainWindowState(
 53            create_call=lambda transition, origin_widget: cls(
 54                transition=transition, origin_widget=origin_widget
 55            )
 56        )
 57
 58    def _refresh(self) -> None:
 59
 60        # Clear everything that was there.
 61        children = self._root_widget.get_children()
 62        for child in children:
 63            child.delete()
 64
 65        self._r = 'mainMenu'
 66
 67        self._input_device = input_device = bs.get_ui_input_device()
 68
 69        # Are we connected to a local player?
 70        self._input_player = input_device.player if input_device else None
 71
 72        # Are we connected to a remote player?.
 73        self._connected_to_remote_player = (
 74            input_device.is_attached_to_player()
 75            if (input_device and self._input_player is None)
 76            else False
 77        )
 78
 79        positions: list[tuple[float, float, float]] = []
 80        self._p_index = 0
 81
 82        self._refresh_in_game(positions)
 83
 84        h, v, scale = positions[self._p_index]
 85        self._p_index += 1
 86
 87        # If we're in a replay, we have a 'Leave Replay' button.
 88        if bs.is_in_replay():
 89            bui.buttonwidget(
 90                parent=self._root_widget,
 91                position=(h - self._button_width * 0.5 * scale, v),
 92                scale=scale,
 93                size=(self._button_width, self._button_height),
 94                autoselect=self._use_autoselect,
 95                label=bui.Lstr(resource='replayEndText'),
 96                on_activate_call=self._confirm_end_replay,
 97            )
 98        elif bs.get_foreground_host_session() is not None:
 99            bui.buttonwidget(
100                parent=self._root_widget,
101                position=(h - self._button_width * 0.5 * scale, v),
102                scale=scale,
103                size=(self._button_width, self._button_height),
104                autoselect=self._use_autoselect,
105                label=bui.Lstr(
106                    resource=self._r
107                    + (
108                        '.endTestText'
109                        if self._is_benchmark()
110                        else '.endGameText'
111                    )
112                ),
113                on_activate_call=(
114                    self._confirm_end_test
115                    if self._is_benchmark()
116                    else self._confirm_end_game
117                ),
118            )
119        else:
120            # Assume we're in a client-session.
121            bui.buttonwidget(
122                parent=self._root_widget,
123                position=(h - self._button_width * 0.5 * scale, v),
124                scale=scale,
125                size=(self._button_width, self._button_height),
126                autoselect=self._use_autoselect,
127                label=bui.Lstr(resource=f'{self._r}.leavePartyText'),
128                on_activate_call=self._confirm_leave_party,
129            )
130
131        # Add speed-up/slow-down buttons for replays. Ideally this
132        # should be part of a fading-out playback bar like most media
133        # players but this works for now.
134        if bs.is_in_replay():
135            b_size = 50.0
136            b_buffer_1 = 50.0
137            b_buffer_2 = 10.0
138            t_scale = 0.75
139            assert bui.app.classic is not None
140            uiscale = bui.app.ui_v1.uiscale
141            if uiscale is bui.UIScale.SMALL:
142                b_size *= 0.6
143                b_buffer_1 *= 0.8
144                b_buffer_2 *= 1.0
145                v_offs = -40
146                t_scale = 0.5
147            elif uiscale is bui.UIScale.MEDIUM:
148                v_offs = -70
149            else:
150                v_offs = -100
151            self._replay_speed_text = bui.textwidget(
152                parent=self._root_widget,
153                text=bui.Lstr(
154                    resource='watchWindow.playbackSpeedText',
155                    subs=[('${SPEED}', str(1.23))],
156                ),
157                position=(h, v + v_offs + 15 * t_scale),
158                h_align='center',
159                v_align='center',
160                size=(0, 0),
161                scale=t_scale,
162            )
163
164            # Update to current value.
165            self._change_replay_speed(0)
166
167            # Keep updating in a timer in case it gets changed elsewhere.
168            self._change_replay_speed_timer = bui.AppTimer(
169                0.25, bui.WeakCall(self._change_replay_speed, 0), repeat=True
170            )
171            btn = bui.buttonwidget(
172                parent=self._root_widget,
173                position=(
174                    h - b_size - b_buffer_1,
175                    v - b_size - b_buffer_2 + v_offs,
176                ),
177                button_type='square',
178                size=(b_size, b_size),
179                label='',
180                autoselect=True,
181                on_activate_call=bui.Call(self._change_replay_speed, -1),
182            )
183            bui.textwidget(
184                parent=self._root_widget,
185                draw_controller=btn,
186                text='-',
187                position=(
188                    h - b_size * 0.5 - b_buffer_1,
189                    v - b_size * 0.5 - b_buffer_2 + 5 * t_scale + v_offs,
190                ),
191                h_align='center',
192                v_align='center',
193                size=(0, 0),
194                scale=3.0 * t_scale,
195            )
196            btn = bui.buttonwidget(
197                parent=self._root_widget,
198                position=(h + b_buffer_1, v - b_size - b_buffer_2 + v_offs),
199                button_type='square',
200                size=(b_size, b_size),
201                label='',
202                autoselect=True,
203                on_activate_call=bui.Call(self._change_replay_speed, 1),
204            )
205            bui.textwidget(
206                parent=self._root_widget,
207                draw_controller=btn,
208                text='+',
209                position=(
210                    h + b_size * 0.5 + b_buffer_1,
211                    v - b_size * 0.5 - b_buffer_2 + 5 * t_scale + v_offs,
212                ),
213                h_align='center',
214                v_align='center',
215                size=(0, 0),
216                scale=3.0 * t_scale,
217            )
218            self._pause_resume_button = btn = bui.buttonwidget(
219                parent=self._root_widget,
220                position=(h - b_size * 0.5, v - b_size - b_buffer_2 + v_offs),
221                button_type='square',
222                size=(b_size, b_size),
223                label=bui.charstr(
224                    bui.SpecialChar.PLAY_BUTTON
225                    if bs.is_replay_paused()
226                    else bui.SpecialChar.PAUSE_BUTTON
227                ),
228                autoselect=True,
229                on_activate_call=bui.Call(self._pause_or_resume_replay),
230            )
231            btn = bui.buttonwidget(
232                parent=self._root_widget,
233                position=(
234                    h - b_size * 1.5 - b_buffer_1 * 2,
235                    v - b_size - b_buffer_2 + v_offs,
236                ),
237                button_type='square',
238                size=(b_size, b_size),
239                label='',
240                autoselect=True,
241                on_activate_call=bui.WeakCall(self._rewind_replay),
242            )
243            bui.textwidget(
244                parent=self._root_widget,
245                draw_controller=btn,
246                # text='<<',
247                text=bui.charstr(bui.SpecialChar.REWIND_BUTTON),
248                position=(
249                    h - b_size - b_buffer_1 * 2,
250                    v - b_size * 0.5 - b_buffer_2 + 5 * t_scale + v_offs,
251                ),
252                h_align='center',
253                v_align='center',
254                size=(0, 0),
255                scale=2.0 * t_scale,
256            )
257            btn = bui.buttonwidget(
258                parent=self._root_widget,
259                position=(
260                    h + b_size * 0.5 + b_buffer_1 * 2,
261                    v - b_size - b_buffer_2 + v_offs,
262                ),
263                button_type='square',
264                size=(b_size, b_size),
265                label='',
266                autoselect=True,
267                on_activate_call=bui.WeakCall(self._forward_replay),
268            )
269            bui.textwidget(
270                parent=self._root_widget,
271                draw_controller=btn,
272                # text='>>',
273                text=bui.charstr(bui.SpecialChar.FAST_FORWARD_BUTTON),
274                position=(
275                    h + b_size + b_buffer_1 * 2,
276                    v - b_size * 0.5 - b_buffer_2 + 5 * t_scale + v_offs,
277                ),
278                h_align='center',
279                v_align='center',
280                size=(0, 0),
281                scale=2.0 * t_scale,
282            )
283
284    def _rewind_replay(self) -> None:
285        bs.seek_replay(-2 * pow(2, bs.get_replay_speed_exponent()))
286
287    def _forward_replay(self) -> None:
288        bs.seek_replay(2 * pow(2, bs.get_replay_speed_exponent()))
289
290    def _refresh_in_game(
291        self, positions: list[tuple[float, float, float]]
292    ) -> tuple[float, float, float]:
293        # pylint: disable=too-many-branches
294        # pylint: disable=too-many-locals
295        # pylint: disable=too-many-statements
296        assert bui.app.classic is not None
297        custom_menu_entries: list[dict[str, Any]] = []
298        session = bs.get_foreground_host_session()
299        if session is not None:
300            try:
301                custom_menu_entries = session.get_custom_menu_entries()
302                for cme in custom_menu_entries:
303                    cme_any: Any = cme  # Type check may not hold true.
304                    if (
305                        not isinstance(cme_any, dict)
306                        or 'label' not in cme
307                        or not isinstance(cme['label'], (str, bui.Lstr))
308                        or 'call' not in cme
309                        or not callable(cme['call'])
310                    ):
311                        raise ValueError(
312                            'invalid custom menu entry: ' + str(cme)
313                        )
314            except Exception:
315                custom_menu_entries = []
316                logging.exception(
317                    'Error getting custom menu entries for %s.', session
318                )
319        self._width = 250.0
320        self._height = 250.0 if self._input_player else 180.0
321        if (self._is_demo or self._is_arcade) and self._input_player:
322            self._height -= 40
323        # if not self._have_settings_button:
324        self._height -= 50
325        if self._connected_to_remote_player:
326            # In this case we have a leave *and* a disconnect button.
327            self._height += 50
328        self._height += 50 * (len(custom_menu_entries))
329        uiscale = bui.app.ui_v1.uiscale
330        bui.containerwidget(
331            edit=self._root_widget,
332            size=(self._width, self._height),
333            scale=(
334                2.15
335                if uiscale is bui.UIScale.SMALL
336                else 1.6 if uiscale is bui.UIScale.MEDIUM else 1.0
337            ),
338        )
339        h = 125.0
340        v = self._height - 80.0 if self._input_player else self._height - 60
341        h_offset = 0
342        d_h_offset = 0
343        v_offset = -50
344
345        for _i in range(6 + len(custom_menu_entries)):
346            positions.append((h, v, 1.0))
347            v += v_offset
348            h += h_offset
349            h_offset += d_h_offset
350
351        # Player name if applicable.
352        if self._input_player:
353            player_name = self._input_player.getname()
354            h, v, scale = positions[self._p_index]
355            v += 35
356            bui.textwidget(
357                parent=self._root_widget,
358                position=(h - self._button_width / 2, v),
359                size=(self._button_width, self._button_height),
360                color=(1, 1, 1, 0.5),
361                scale=0.7,
362                h_align='center',
363                text=bui.Lstr(value=player_name),
364            )
365        else:
366            player_name = ''
367        h, v, scale = positions[self._p_index]
368        self._p_index += 1
369        btn = bui.buttonwidget(
370            parent=self._root_widget,
371            position=(h - self._button_width / 2, v),
372            size=(self._button_width, self._button_height),
373            scale=scale,
374            label=bui.Lstr(resource=f'{self._r}.resumeText'),
375            autoselect=self._use_autoselect,
376            on_activate_call=self._resume,
377        )
378        bui.containerwidget(edit=self._root_widget, cancel_button=btn)
379
380        # Add any custom options defined by the current game.
381        for entry in custom_menu_entries:
382            h, v, scale = positions[self._p_index]
383            self._p_index += 1
384
385            # Ask the entry whether we should resume when we call
386            # it (defaults to true).
387            resume = bool(entry.get('resume_on_call', True))
388
389            if resume:
390                call = bui.Call(self._resume_and_call, entry['call'])
391            else:
392                call = bui.Call(entry['call'], bui.WeakCall(self._resume))
393
394            bui.buttonwidget(
395                parent=self._root_widget,
396                position=(h - self._button_width / 2, v),
397                size=(self._button_width, self._button_height),
398                scale=scale,
399                on_activate_call=call,
400                label=entry['label'],
401                autoselect=self._use_autoselect,
402            )
403
404        # Add a 'leave' button if the menu-owner has a player.
405        if (self._input_player or self._connected_to_remote_player) and not (
406            self._is_demo or self._is_arcade
407        ):
408            h, v, scale = positions[self._p_index]
409            self._p_index += 1
410            btn = bui.buttonwidget(
411                parent=self._root_widget,
412                position=(h - self._button_width / 2, v),
413                size=(self._button_width, self._button_height),
414                scale=scale,
415                on_activate_call=self._leave,
416                label='',
417                autoselect=self._use_autoselect,
418            )
419
420            if (
421                player_name != ''
422                and player_name[0] != '<'
423                and player_name[-1] != '>'
424            ):
425                txt = bui.Lstr(
426                    resource=f'{self._r}.justPlayerText',
427                    subs=[('${NAME}', player_name)],
428                )
429            else:
430                txt = bui.Lstr(value=player_name)
431            bui.textwidget(
432                parent=self._root_widget,
433                position=(
434                    h,
435                    v
436                    + self._button_height
437                    * (0.64 if player_name != '' else 0.5),
438                ),
439                size=(0, 0),
440                text=bui.Lstr(resource=f'{self._r}.leaveGameText'),
441                scale=(0.83 if player_name != '' else 1.0),
442                color=(0.75, 1.0, 0.7),
443                h_align='center',
444                v_align='center',
445                draw_controller=btn,
446                maxwidth=self._button_width * 0.9,
447            )
448            bui.textwidget(
449                parent=self._root_widget,
450                position=(h, v + self._button_height * 0.27),
451                size=(0, 0),
452                text=txt,
453                color=(0.75, 1.0, 0.7),
454                h_align='center',
455                v_align='center',
456                draw_controller=btn,
457                scale=0.45,
458                maxwidth=self._button_width * 0.9,
459            )
460        return h, v, scale
461
462    def _change_replay_speed(self, offs: int) -> None:
463        if not self._replay_speed_text:
464            if bui.do_once():
465                print('_change_replay_speed called without widget')
466            return
467        bs.set_replay_speed_exponent(bs.get_replay_speed_exponent() + offs)
468        actual_speed = pow(2.0, bs.get_replay_speed_exponent())
469        bui.textwidget(
470            edit=self._replay_speed_text,
471            text=bui.Lstr(
472                resource='watchWindow.playbackSpeedText',
473                subs=[('${SPEED}', str(actual_speed))],
474            ),
475        )
476
477    def _pause_or_resume_replay(self) -> None:
478        if bs.is_replay_paused():
479            bs.resume_replay()
480            bui.buttonwidget(
481                edit=self._pause_resume_button,
482                label=bui.charstr(bui.SpecialChar.PAUSE_BUTTON),
483            )
484        else:
485            bs.pause_replay()
486            bui.buttonwidget(
487                edit=self._pause_resume_button,
488                label=bui.charstr(bui.SpecialChar.PLAY_BUTTON),
489            )
490
491    def _is_benchmark(self) -> bool:
492        session = bs.get_foreground_host_session()
493        return getattr(session, 'benchmark_type', None) == 'cpu' or (
494            bui.app.classic is not None
495            and bui.app.classic.stress_test_update_timer is not None
496        )
497
498    def _confirm_end_game(self) -> None:
499        # pylint: disable=cyclic-import
500        from bauiv1lib.confirm import ConfirmWindow
501
502        # FIXME: Currently we crash calling this on client-sessions.
503
504        # Select cancel by default; this occasionally gets called by accident
505        # in a fit of button mashing and this will help reduce damage.
506        ConfirmWindow(
507            bui.Lstr(resource=f'{self._r}.exitToMenuText'),
508            self._end_game,
509            cancel_is_selected=True,
510        )
511
512    def _confirm_end_test(self) -> None:
513        # pylint: disable=cyclic-import
514        from bauiv1lib.confirm import ConfirmWindow
515
516        # Select cancel by default; this occasionally gets called by accident
517        # in a fit of button mashing and this will help reduce damage.
518        ConfirmWindow(
519            bui.Lstr(resource=f'{self._r}.exitToMenuText'),
520            self._end_game,
521            cancel_is_selected=True,
522        )
523
524    def _confirm_end_replay(self) -> None:
525        # pylint: disable=cyclic-import
526        from bauiv1lib.confirm import ConfirmWindow
527
528        # Select cancel by default; this occasionally gets called by accident
529        # in a fit of button mashing and this will help reduce damage.
530        ConfirmWindow(
531            bui.Lstr(resource=f'{self._r}.exitToMenuText'),
532            self._end_game,
533            cancel_is_selected=True,
534        )
535
536    def _confirm_leave_party(self) -> None:
537        # pylint: disable=cyclic-import
538        from bauiv1lib.confirm import ConfirmWindow
539
540        # Select cancel by default; this occasionally gets called by accident
541        # in a fit of button mashing and this will help reduce damage.
542        ConfirmWindow(
543            bui.Lstr(resource=f'{self._r}.leavePartyConfirmText'),
544            self._leave_party,
545            cancel_is_selected=True,
546        )
547
548    def _leave_party(self) -> None:
549        bs.disconnect_from_host()
550
551    def _end_game(self) -> None:
552        assert bui.app.classic is not None
553
554        # no-op if our underlying widget is dead or on its way out.
555        if not self._root_widget or self._root_widget.transitioning_out:
556            return
557
558        bui.containerwidget(edit=self._root_widget, transition='out_left')
559        bui.app.classic.return_to_main_menu_session_gracefully(reset_ui=False)
560
561    def _leave(self) -> None:
562        if self._input_player:
563            self._input_player.remove_from_game()
564        elif self._connected_to_remote_player:
565            if self._input_device:
566                self._input_device.detach_from_player()
567        self._resume()
568
569    def _resume_and_call(self, call: Callable[[], Any]) -> None:
570        self._resume()
571        call()
572
573    def _resume(self) -> None:
574        classic = bui.app.classic
575
576        assert classic is not None
577        classic.resume()
578
579        bui.app.ui_v1.clear_main_window()
580
581        # If there's callbacks waiting for us to resume, call them.
582        for call in classic.main_menu_resume_callbacks:
583            try:
584                call()
585            except Exception:
586                logging.exception('Error in classic resume callback.')
587
588        classic.main_menu_resume_callbacks.clear()
589
590    # def __del__(self) -> None:
591    #     self._resume()