bastd.ui.playlist.editcontroller

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Defines a controller for wrangling playlist edit UIs."""
  4
  5from __future__ import annotations
  6
  7import copy
  8from typing import TYPE_CHECKING
  9
 10import ba
 11
 12if TYPE_CHECKING:
 13    from typing import Any
 14
 15
 16class PlaylistEditController:
 17    """Coordinates various UIs involved in playlist editing."""
 18
 19    def __init__(
 20        self,
 21        sessiontype: type[ba.Session],
 22        existing_playlist_name: str | None = None,
 23        transition: str = 'in_right',
 24        playlist: list[dict[str, Any]] | None = None,
 25        playlist_name: str | None = None,
 26    ):
 27        from ba.internal import preload_map_preview_media, filter_playlist
 28        from bastd.ui.playlist import PlaylistTypeVars
 29        from bastd.ui.playlist.edit import PlaylistEditWindow
 30
 31        appconfig = ba.app.config
 32
 33        # Since we may be showing our map list momentarily,
 34        # lets go ahead and preload all map preview textures.
 35        preload_map_preview_media()
 36        self._sessiontype = sessiontype
 37
 38        self._editing_game = False
 39        self._editing_game_type: type[ba.GameActivity] | None = None
 40        self._pvars = PlaylistTypeVars(sessiontype)
 41        self._existing_playlist_name = existing_playlist_name
 42        self._config_name_full = self._pvars.config_name + ' Playlists'
 43
 44        # Make sure config exists.
 45        if self._config_name_full not in appconfig:
 46            appconfig[self._config_name_full] = {}
 47
 48        self._selected_index = 0
 49        if existing_playlist_name:
 50            self._name = existing_playlist_name
 51
 52            # Filter out invalid games.
 53            self._playlist = filter_playlist(
 54                appconfig[self._pvars.config_name + ' Playlists'][
 55                    existing_playlist_name
 56                ],
 57                sessiontype=sessiontype,
 58                remove_unowned=False,
 59                name=existing_playlist_name,
 60            )
 61            self._edit_ui_selection = None
 62        else:
 63            if playlist is not None:
 64                self._playlist = playlist
 65            else:
 66                self._playlist = []
 67            if playlist_name is not None:
 68                self._name = playlist_name
 69            else:
 70
 71                # Find a good unused name.
 72                i = 1
 73                while True:
 74                    self._name = (
 75                        self._pvars.default_new_list_name.evaluate()
 76                        + ((' ' + str(i)) if i > 1 else '')
 77                    )
 78                    if (
 79                        self._name
 80                        not in appconfig[self._pvars.config_name + ' Playlists']
 81                    ):
 82                        break
 83                    i += 1
 84
 85            # Also we want it to start with 'add' highlighted since its empty
 86            # and that's all they can do.
 87            self._edit_ui_selection = 'add_button'
 88
 89        ba.app.ui.set_main_menu_window(
 90            PlaylistEditWindow(
 91                editcontroller=self, transition=transition
 92            ).get_root_widget()
 93        )
 94
 95    def get_config_name(self) -> str:
 96        """(internal)"""
 97        return self._pvars.config_name
 98
 99    def get_existing_playlist_name(self) -> str | None:
100        """(internal)"""
101        return self._existing_playlist_name
102
103    def get_edit_ui_selection(self) -> str | None:
104        """(internal)"""
105        return self._edit_ui_selection
106
107    def set_edit_ui_selection(self, selection: str) -> None:
108        """(internal)"""
109        self._edit_ui_selection = selection
110
111    def getname(self) -> str:
112        """(internal)"""
113        return self._name
114
115    def setname(self, name: str) -> None:
116        """(internal)"""
117        self._name = name
118
119    def get_playlist(self) -> list[dict[str, Any]]:
120        """Return the current state of the edited playlist."""
121        return copy.deepcopy(self._playlist)
122
123    def set_playlist(self, playlist: list[dict[str, Any]]) -> None:
124        """Set the playlist contents."""
125        self._playlist = copy.deepcopy(playlist)
126
127    def get_session_type(self) -> type[ba.Session]:
128        """Return the ba.Session type for this edit-session."""
129        return self._sessiontype
130
131    def get_selected_index(self) -> int:
132        """Return the index of the selected playlist."""
133        return self._selected_index
134
135    def get_default_list_name(self) -> ba.Lstr:
136        """(internal)"""
137        return self._pvars.default_list_name
138
139    def set_selected_index(self, index: int) -> None:
140        """Sets the selected playlist index."""
141        self._selected_index = index
142
143    def add_game_pressed(self) -> None:
144        """(internal)"""
145        from bastd.ui.playlist.addgame import PlaylistAddGameWindow
146
147        ba.app.ui.clear_main_menu_window(transition='out_left')
148        ba.app.ui.set_main_menu_window(
149            PlaylistAddGameWindow(editcontroller=self).get_root_widget()
150        )
151
152    def edit_game_pressed(self) -> None:
153        """Should be called by supplemental UIs when a game is to be edited."""
154        from ba.internal import getclass
155
156        if not self._playlist:
157            return
158        self._show_edit_ui(
159            gametype=getclass(
160                self._playlist[self._selected_index]['type'],
161                subclassof=ba.GameActivity,
162            ),
163            settings=self._playlist[self._selected_index],
164        )
165
166    def add_game_cancelled(self) -> None:
167        """(internal)"""
168        from bastd.ui.playlist.edit import PlaylistEditWindow
169
170        ba.app.ui.clear_main_menu_window(transition='out_right')
171        ba.app.ui.set_main_menu_window(
172            PlaylistEditWindow(
173                editcontroller=self, transition='in_left'
174            ).get_root_widget()
175        )
176
177    def _show_edit_ui(
178        self, gametype: type[ba.GameActivity], settings: dict[str, Any] | None
179    ) -> None:
180        self._editing_game = settings is not None
181        self._editing_game_type = gametype
182        assert self._sessiontype is not None
183        gametype.create_settings_ui(
184            self._sessiontype, copy.deepcopy(settings), self._edit_game_done
185        )
186
187    def add_game_type_selected(self, gametype: type[ba.GameActivity]) -> None:
188        """(internal)"""
189        self._show_edit_ui(gametype=gametype, settings=None)
190
191    def _edit_game_done(self, config: dict[str, Any] | None) -> None:
192        from bastd.ui.playlist.edit import PlaylistEditWindow
193        from bastd.ui.playlist.addgame import PlaylistAddGameWindow
194        from ba.internal import get_type_name
195
196        if config is None:
197            # If we were editing, go back to our list.
198            if self._editing_game:
199                ba.playsound(ba.getsound('powerdown01'))
200                ba.app.ui.clear_main_menu_window(transition='out_right')
201                ba.app.ui.set_main_menu_window(
202                    PlaylistEditWindow(
203                        editcontroller=self, transition='in_left'
204                    ).get_root_widget()
205                )
206
207            # Otherwise we were adding; go back to the add type choice list.
208            else:
209                ba.app.ui.clear_main_menu_window(transition='out_right')
210                ba.app.ui.set_main_menu_window(
211                    PlaylistAddGameWindow(
212                        editcontroller=self, transition='in_left'
213                    ).get_root_widget()
214                )
215        else:
216            # Make sure type is in there.
217            assert self._editing_game_type is not None
218            config['type'] = get_type_name(self._editing_game_type)
219
220            if self._editing_game:
221                self._playlist[self._selected_index] = copy.deepcopy(config)
222            else:
223                # Add a new entry to the playlist.
224                insert_index = min(
225                    len(self._playlist), self._selected_index + 1
226                )
227                self._playlist.insert(insert_index, copy.deepcopy(config))
228                self._selected_index = insert_index
229
230            ba.playsound(ba.getsound('gunCocking'))
231            ba.app.ui.clear_main_menu_window(transition='out_right')
232            ba.app.ui.set_main_menu_window(
233                PlaylistEditWindow(
234                    editcontroller=self, transition='in_left'
235                ).get_root_widget()
236            )