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