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