bastd.ui.playlist.editgame

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Provides UI for editing a game config."""
  4
  5from __future__ import annotations
  6
  7import copy
  8import random
  9from typing import TYPE_CHECKING, cast
 10
 11import _ba
 12import ba
 13
 14if TYPE_CHECKING:
 15    from typing import Any, Callable
 16
 17
 18class PlaylistEditGameWindow(ba.Window):
 19    """Window for editing a game config."""
 20
 21    def __init__(self,
 22                 gametype: type[ba.GameActivity],
 23                 sessiontype: type[ba.Session],
 24                 config: dict[str, Any] | None,
 25                 completion_call: Callable[[dict[str, Any] | None], Any],
 26                 default_selection: str | None = None,
 27                 transition: str = 'in_right',
 28                 edit_info: dict[str, Any] | None = None):
 29        # pylint: disable=too-many-branches
 30        # pylint: disable=too-many-statements
 31        # pylint: disable=too-many-locals
 32        from ba.internal import (get_unowned_maps, get_filtered_map_name,
 33                                 get_map_class, get_map_display_string)
 34        self._gametype = gametype
 35        self._sessiontype = sessiontype
 36
 37        # If we're within an editing session we get passed edit_info
 38        # (returning from map selection window, etc).
 39        if edit_info is not None:
 40            self._edit_info = edit_info
 41
 42        # ..otherwise determine whether we're adding or editing a game based
 43        # on whether an existing config was passed to us.
 44        else:
 45            if config is None:
 46                self._edit_info = {'editType': 'add'}
 47            else:
 48                self._edit_info = {'editType': 'edit'}
 49
 50        self._r = 'gameSettingsWindow'
 51
 52        valid_maps = gametype.get_supported_maps(sessiontype)
 53        if not valid_maps:
 54            ba.screenmessage(ba.Lstr(resource='noValidMapsErrorText'))
 55            raise Exception('No valid maps')
 56
 57        self._settings_defs = gametype.get_available_settings(sessiontype)
 58        self._completion_call = completion_call
 59
 60        # To start with, pick a random map out of the ones we own.
 61        unowned_maps = get_unowned_maps()
 62        valid_maps_owned = [m for m in valid_maps if m not in unowned_maps]
 63        if valid_maps_owned:
 64            self._map = valid_maps[random.randrange(len(valid_maps_owned))]
 65
 66        # Hmmm.. we own none of these maps.. just pick a random un-owned one
 67        # I guess.. should this ever happen?
 68        else:
 69            self._map = valid_maps[random.randrange(len(valid_maps))]
 70
 71        is_add = (self._edit_info['editType'] == 'add')
 72
 73        # If there's a valid map name in the existing config, use that.
 74        try:
 75            if (config is not None and 'settings' in config
 76                    and 'map' in config['settings']):
 77                filtered_map_name = get_filtered_map_name(
 78                    config['settings']['map'])
 79                if filtered_map_name in valid_maps:
 80                    self._map = filtered_map_name
 81        except Exception:
 82            ba.print_exception('Error getting map for editor.')
 83
 84        if config is not None and 'settings' in config:
 85            self._settings = config['settings']
 86        else:
 87            self._settings = {}
 88
 89        self._choice_selections: dict[str, int] = {}
 90
 91        uiscale = ba.app.ui.uiscale
 92        width = 720 if uiscale is ba.UIScale.SMALL else 620
 93        x_inset = 50 if uiscale is ba.UIScale.SMALL else 0
 94        height = (365 if uiscale is ba.UIScale.SMALL else
 95                  460 if uiscale is ba.UIScale.MEDIUM else 550)
 96        spacing = 52
 97        y_extra = 15
 98        y_extra2 = 21
 99
100        map_tex_name = (get_map_class(self._map).get_preview_texture_name())
101        if map_tex_name is None:
102            raise Exception('no map preview tex found for' + self._map)
103        map_tex = ba.gettexture(map_tex_name)
104
105        top_extra = 20 if uiscale is ba.UIScale.SMALL else 0
106        super().__init__(root_widget=ba.containerwidget(
107            size=(width, height + top_extra),
108            transition=transition,
109            scale=(2.19 if uiscale is ba.UIScale.SMALL else
110                   1.35 if uiscale is ba.UIScale.MEDIUM else 1.0),
111            stack_offset=(0, -17) if uiscale is ba.UIScale.SMALL else (0, 0)))
112
113        btn = ba.buttonwidget(
114            parent=self._root_widget,
115            position=(45 + x_inset, height - 82 + y_extra2),
116            size=(180, 70) if is_add else (180, 65),
117            label=ba.Lstr(resource='backText') if is_add else ba.Lstr(
118                resource='cancelText'),
119            button_type='back' if is_add else None,
120            autoselect=True,
121            scale=0.75,
122            text_scale=1.3,
123            on_activate_call=ba.Call(self._cancel))
124        ba.containerwidget(edit=self._root_widget, cancel_button=btn)
125
126        add_button = ba.buttonwidget(
127            parent=self._root_widget,
128            position=(width - (193 + x_inset), height - 82 + y_extra2),
129            size=(200, 65),
130            scale=0.75,
131            text_scale=1.3,
132            label=ba.Lstr(resource=self._r +
133                          '.addGameText') if is_add else ba.Lstr(
134                              resource='doneText'))
135
136        if ba.app.ui.use_toolbars:
137            pbtn = _ba.get_special_widget('party_button')
138            ba.widget(edit=add_button, right_widget=pbtn, up_widget=pbtn)
139
140        ba.textwidget(parent=self._root_widget,
141                      position=(-8, height - 70 + y_extra2),
142                      size=(width, 25),
143                      text=gametype.get_display_string(),
144                      color=ba.app.ui.title_color,
145                      maxwidth=235,
146                      scale=1.1,
147                      h_align='center',
148                      v_align='center')
149
150        map_height = 100
151
152        scroll_height = map_height + 10  # map select and margin
153
154        # Calc our total height we'll need
155        scroll_height += spacing * len(self._settings_defs)
156
157        scroll_width = width - (86 + 2 * x_inset)
158        self._scrollwidget = ba.scrollwidget(parent=self._root_widget,
159                                             position=(44 + x_inset,
160                                                       35 + y_extra),
161                                             size=(scroll_width, height - 116),
162                                             highlight=False,
163                                             claims_left_right=True,
164                                             claims_tab=True,
165                                             selection_loops_to_parent=True)
166        self._subcontainer = ba.containerwidget(parent=self._scrollwidget,
167                                                size=(scroll_width,
168                                                      scroll_height),
169                                                background=False,
170                                                claims_left_right=True,
171                                                claims_tab=True,
172                                                selection_loops_to_parent=True)
173
174        v = scroll_height - 5
175        h = -40
176
177        # Keep track of all the selectable widgets we make so we can wire
178        # them up conveniently.
179        widget_column: list[list[ba.Widget]] = []
180
181        # Map select button.
182        ba.textwidget(parent=self._subcontainer,
183                      position=(h + 49, v - 63),
184                      size=(100, 30),
185                      maxwidth=110,
186                      text=ba.Lstr(resource='mapText'),
187                      h_align='left',
188                      color=(0.8, 0.8, 0.8, 1.0),
189                      v_align='center')
190
191        ba.imagewidget(
192            parent=self._subcontainer,
193            size=(256 * 0.7, 125 * 0.7),
194            position=(h + 261 - 128 + 128.0 * 0.56, v - 90),
195            texture=map_tex,
196            model_opaque=ba.getmodel('level_select_button_opaque'),
197            model_transparent=ba.getmodel('level_select_button_transparent'),
198            mask_texture=ba.gettexture('mapPreviewMask'))
199        map_button = btn = ba.buttonwidget(
200            parent=self._subcontainer,
201            size=(140, 60),
202            position=(h + 448, v - 72),
203            on_activate_call=ba.Call(self._select_map),
204            scale=0.7,
205            label=ba.Lstr(resource='mapSelectText'))
206        widget_column.append([btn])
207
208        ba.textwidget(parent=self._subcontainer,
209                      position=(h + 363 - 123, v - 114),
210                      size=(100, 30),
211                      flatness=1.0,
212                      shadow=1.0,
213                      scale=0.55,
214                      maxwidth=256 * 0.7 * 0.8,
215                      text=get_map_display_string(self._map),
216                      h_align='center',
217                      color=(0.6, 1.0, 0.6, 1.0),
218                      v_align='center')
219        v -= map_height
220
221        for setting in self._settings_defs:
222            value = setting.default
223            value_type = type(value)
224
225            # Now, if there's an existing value for it in the config,
226            # override with that.
227            try:
228                if (config is not None and 'settings' in config
229                        and setting.name in config['settings']):
230                    value = value_type(config['settings'][setting.name])
231            except Exception:
232                ba.print_exception()
233
234            # Shove the starting value in there to start.
235            self._settings[setting.name] = value
236
237            name_translated = self._get_localized_setting_name(setting.name)
238
239            mw1 = 280
240            mw2 = 70
241
242            # Handle types with choices specially:
243            if isinstance(setting, ba.ChoiceSetting):
244                for choice in setting.choices:
245                    if len(choice) != 2:
246                        raise ValueError(
247                            "Expected 2-member tuples for 'choices'; got: " +
248                            repr(choice))
249                    if not isinstance(choice[0], str):
250                        raise TypeError(
251                            'First value for choice tuple must be a str; got: '
252                            + repr(choice))
253                    if not isinstance(choice[1], value_type):
254                        raise TypeError(
255                            'Choice type does not match default value; choice:'
256                            + repr(choice) + '; setting:' + repr(setting))
257                if value_type not in (int, float):
258                    raise TypeError(
259                        'Choice type setting must have int or float default; '
260                        'got: ' + repr(setting))
261
262                # Start at the choice corresponding to the default if possible.
263                self._choice_selections[setting.name] = 0
264                for index, choice in enumerate(setting.choices):
265                    if choice[1] == value:
266                        self._choice_selections[setting.name] = index
267                        break
268
269                v -= spacing
270                ba.textwidget(parent=self._subcontainer,
271                              position=(h + 50, v),
272                              size=(100, 30),
273                              maxwidth=mw1,
274                              text=name_translated,
275                              h_align='left',
276                              color=(0.8, 0.8, 0.8, 1.0),
277                              v_align='center')
278                txt = ba.textwidget(
279                    parent=self._subcontainer,
280                    position=(h + 509 - 95, v),
281                    size=(0, 28),
282                    text=self._get_localized_setting_name(setting.choices[
283                        self._choice_selections[setting.name]][0]),
284                    editable=False,
285                    color=(0.6, 1.0, 0.6, 1.0),
286                    maxwidth=mw2,
287                    h_align='right',
288                    v_align='center',
289                    padding=2)
290                btn1 = ba.buttonwidget(parent=self._subcontainer,
291                                       position=(h + 509 - 50 - 1, v),
292                                       size=(28, 28),
293                                       label='<',
294                                       autoselect=True,
295                                       on_activate_call=ba.Call(
296                                           self._choice_inc, setting.name, txt,
297                                           setting, -1),
298                                       repeat=True)
299                btn2 = ba.buttonwidget(parent=self._subcontainer,
300                                       position=(h + 509 + 5, v),
301                                       size=(28, 28),
302                                       label='>',
303                                       autoselect=True,
304                                       on_activate_call=ba.Call(
305                                           self._choice_inc, setting.name, txt,
306                                           setting, 1),
307                                       repeat=True)
308                widget_column.append([btn1, btn2])
309
310            elif isinstance(setting, (ba.IntSetting, ba.FloatSetting)):
311                v -= spacing
312                min_value = setting.min_value
313                max_value = setting.max_value
314                increment = setting.increment
315                ba.textwidget(parent=self._subcontainer,
316                              position=(h + 50, v),
317                              size=(100, 30),
318                              text=name_translated,
319                              h_align='left',
320                              color=(0.8, 0.8, 0.8, 1.0),
321                              v_align='center',
322                              maxwidth=mw1)
323                txt = ba.textwidget(parent=self._subcontainer,
324                                    position=(h + 509 - 95, v),
325                                    size=(0, 28),
326                                    text=str(value),
327                                    editable=False,
328                                    color=(0.6, 1.0, 0.6, 1.0),
329                                    maxwidth=mw2,
330                                    h_align='right',
331                                    v_align='center',
332                                    padding=2)
333                btn1 = ba.buttonwidget(parent=self._subcontainer,
334                                       position=(h + 509 - 50 - 1, v),
335                                       size=(28, 28),
336                                       label='-',
337                                       autoselect=True,
338                                       on_activate_call=ba.Call(
339                                           self._inc, txt, min_value,
340                                           max_value, -increment, value_type,
341                                           setting.name),
342                                       repeat=True)
343                btn2 = ba.buttonwidget(parent=self._subcontainer,
344                                       position=(h + 509 + 5, v),
345                                       size=(28, 28),
346                                       label='+',
347                                       autoselect=True,
348                                       on_activate_call=ba.Call(
349                                           self._inc, txt, min_value,
350                                           max_value, increment, value_type,
351                                           setting.name),
352                                       repeat=True)
353                widget_column.append([btn1, btn2])
354
355            elif value_type == bool:
356                v -= spacing
357                ba.textwidget(parent=self._subcontainer,
358                              position=(h + 50, v),
359                              size=(100, 30),
360                              text=name_translated,
361                              h_align='left',
362                              color=(0.8, 0.8, 0.8, 1.0),
363                              v_align='center',
364                              maxwidth=mw1)
365                txt = ba.textwidget(
366                    parent=self._subcontainer,
367                    position=(h + 509 - 95, v),
368                    size=(0, 28),
369                    text=ba.Lstr(resource='onText') if value else ba.Lstr(
370                        resource='offText'),
371                    editable=False,
372                    color=(0.6, 1.0, 0.6, 1.0),
373                    maxwidth=mw2,
374                    h_align='right',
375                    v_align='center',
376                    padding=2)
377                cbw = ba.checkboxwidget(parent=self._subcontainer,
378                                        text='',
379                                        position=(h + 505 - 50 - 5, v - 2),
380                                        size=(200, 30),
381                                        autoselect=True,
382                                        textcolor=(0.8, 0.8, 0.8),
383                                        value=value,
384                                        on_value_change_call=ba.Call(
385                                            self._check_value_change,
386                                            setting.name, txt))
387                widget_column.append([cbw])
388
389            else:
390                raise Exception()
391
392        # Ok now wire up the column.
393        try:
394            # pylint: disable=unsubscriptable-object
395            prev_widgets: list[ba.Widget] | None = None
396            for cwdg in widget_column:
397                if prev_widgets is not None:
398                    # Wire our rightmost to their rightmost.
399                    ba.widget(edit=prev_widgets[-1], down_widget=cwdg[-1])
400                    ba.widget(cwdg[-1], up_widget=prev_widgets[-1])
401
402                    # Wire our leftmost to their leftmost.
403                    ba.widget(edit=prev_widgets[0], down_widget=cwdg[0])
404                    ba.widget(cwdg[0], up_widget=prev_widgets[0])
405                prev_widgets = cwdg
406        except Exception:
407            ba.print_exception(
408                'Error wiring up game-settings-select widget column.')
409
410        ba.buttonwidget(edit=add_button, on_activate_call=ba.Call(self._add))
411        ba.containerwidget(edit=self._root_widget,
412                           selected_child=add_button,
413                           start_button=add_button)
414
415        if default_selection == 'map':
416            ba.containerwidget(edit=self._root_widget,
417                               selected_child=self._scrollwidget)
418            ba.containerwidget(edit=self._subcontainer,
419                               selected_child=map_button)
420
421    def _get_localized_setting_name(self, name: str) -> ba.Lstr:
422        return ba.Lstr(translate=('settingNames', name))
423
424    def _select_map(self) -> None:
425        # pylint: disable=cyclic-import
426        from bastd.ui.playlist.mapselect import PlaylistMapSelectWindow
427
428        # Replace ourself with the map-select UI.
429        ba.containerwidget(edit=self._root_widget, transition='out_left')
430        ba.app.ui.set_main_menu_window(
431            PlaylistMapSelectWindow(self._gametype, self._sessiontype,
432                                    copy.deepcopy(self._getconfig()),
433                                    self._edit_info,
434                                    self._completion_call).get_root_widget())
435
436    def _choice_inc(self, setting_name: str, widget: ba.Widget,
437                    setting: ba.ChoiceSetting, increment: int) -> None:
438        choices = setting.choices
439        if increment > 0:
440            self._choice_selections[setting_name] = min(
441                len(choices) - 1, self._choice_selections[setting_name] + 1)
442        else:
443            self._choice_selections[setting_name] = max(
444                0, self._choice_selections[setting_name] - 1)
445        ba.textwidget(edit=widget,
446                      text=self._get_localized_setting_name(
447                          choices[self._choice_selections[setting_name]][0]))
448        self._settings[setting_name] = choices[
449            self._choice_selections[setting_name]][1]
450
451    def _cancel(self) -> None:
452        self._completion_call(None)
453
454    def _check_value_change(self, setting_name: str, widget: ba.Widget,
455                            value: int) -> None:
456        ba.textwidget(edit=widget,
457                      text=ba.Lstr(resource='onText') if value else ba.Lstr(
458                          resource='offText'))
459        self._settings[setting_name] = value
460
461    def _getconfig(self) -> dict[str, Any]:
462        settings = copy.deepcopy(self._settings)
463        settings['map'] = self._map
464        return {'settings': settings}
465
466    def _add(self) -> None:
467        self._completion_call(copy.deepcopy(self._getconfig()))
468
469    def _inc(self, ctrl: ba.Widget, min_val: int | float, max_val: int | float,
470             increment: int | float, setting_type: type,
471             setting_name: str) -> None:
472        if setting_type == float:
473            val = float(cast(str, ba.textwidget(query=ctrl)))
474        else:
475            val = int(cast(str, ba.textwidget(query=ctrl)))
476        val += increment
477        val = max(min_val, min(val, max_val))
478        if setting_type == float:
479            ba.textwidget(edit=ctrl, text=str(round(val, 2)))
480        elif setting_type == int:
481            ba.textwidget(edit=ctrl, text=str(int(val)))
482        else:
483            raise TypeError('invalid vartype: ' + str(setting_type))
484        self._settings[setting_name] = val