mirror of
https://github.com/bombsquad-community/plugin-manager.git
synced 2025-10-08 14:54:36 +00:00
410 lines
13 KiB
Python
410 lines
13 KiB
Python
# Porting to api 8 made easier by baport.(https://github.com/bombsquad-community/baport)
|
|
# ba_meta require api 8
|
|
# (see https://ballistica.net/wiki/meta-tag-system)
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING
|
|
|
|
import babase
|
|
import bauiv1 as bui
|
|
import bascenev1 as bs
|
|
import _babase
|
|
from bauiv1lib.play import PlayWindow
|
|
from bauiv1lib.playlist.addgame import PlaylistAddGameWindow
|
|
from bascenev1._freeforallsession import FreeForAllSession
|
|
from bascenev1lib.activity.multiteamjoin import MultiTeamJoinActivity
|
|
|
|
if TYPE_CHECKING:
|
|
pass
|
|
|
|
|
|
lang = bs.app.lang.language
|
|
|
|
if lang == "Spanish":
|
|
custom_txt = "personalizar..."
|
|
else:
|
|
custom_txt = "custom..."
|
|
|
|
|
|
if "quick_game_button" in babase.app.config:
|
|
config = babase.app.config["quick_game_button"]
|
|
else:
|
|
config = {"selected": None, "config": None}
|
|
babase.app.config["quick_game_button"] = config
|
|
babase.app.config.commit()
|
|
|
|
|
|
def start_game(session: bs.Session, fadeout: bool = True):
|
|
def callback():
|
|
if fadeout:
|
|
_babase.unlock_all_input()
|
|
try:
|
|
bs.new_host_session(session)
|
|
except Exception:
|
|
from bascenev1lib import mainmenu
|
|
|
|
babase.print_exception("exception running session", session)
|
|
|
|
# Drop back into a main menu session.
|
|
bs.new_host_session(mainmenu.MainMenuSession)
|
|
|
|
if fadeout:
|
|
_babase.fade_screen(False, time=0.25, endcall=callback)
|
|
_babase.lock_all_input()
|
|
else:
|
|
callback()
|
|
|
|
|
|
class SimplePlaylist:
|
|
def __init__(self, settings: dict, gametype: type[bs.GameActivity]):
|
|
self.settings = settings
|
|
self.gametype = gametype
|
|
|
|
def pull_next(self) -> None:
|
|
if "map" not in self.settings["settings"]:
|
|
settings = dict(map=self.settings["map"], **self.settings["settings"])
|
|
else:
|
|
settings = self.settings["settings"]
|
|
return dict(resolved_type=self.gametype, settings=settings)
|
|
|
|
|
|
class CustomSession(FreeForAllSession):
|
|
def __init__(self, *args, **kwargs):
|
|
# pylint: disable=cyclic-import
|
|
self.use_teams = False
|
|
self._tutorial_activity_instance = None
|
|
bs.Session.__init__(
|
|
self,
|
|
depsets=[],
|
|
team_names=None,
|
|
team_colors=None,
|
|
min_players=1,
|
|
max_players=self.get_max_players(),
|
|
)
|
|
|
|
self._series_length = 1
|
|
self._ffa_series_length = 1
|
|
|
|
# Which game activity we're on.
|
|
self._game_number = 0
|
|
self._playlist = SimplePlaylist(self._config, self._gametype)
|
|
config["selected"] = self._gametype.__name__
|
|
config["config"] = self._config
|
|
babase.app.config.commit()
|
|
|
|
# Get a game on deck ready to go.
|
|
self._current_game_spec: Optional[Dict[str, Any]] = None
|
|
self._next_game_spec: Dict[str, Any] = self._playlist.pull_next()
|
|
self._next_game: Type[bs.GameActivity] = self._next_game_spec["resolved_type"]
|
|
|
|
# Go ahead and instantiate the next game we'll
|
|
# use so it has lots of time to load.
|
|
self._instantiate_next_game()
|
|
|
|
# Start in our custom join screen.
|
|
self.setactivity(bs.newactivity(MultiTeamJoinActivity))
|
|
|
|
|
|
class SelectGameWindow(PlaylistAddGameWindow):
|
|
def __init__(self, transition: str = "in_right"):
|
|
class EditController:
|
|
_sessiontype = bs.FreeForAllSession
|
|
|
|
def get_session_type(self) -> Type[bs.Session]:
|
|
return self._sessiontype
|
|
|
|
self._editcontroller = EditController()
|
|
self._r = "addGameWindow"
|
|
uiscale = bui.app.ui_v1.uiscale
|
|
self._width = 750 if uiscale is babase.UIScale.SMALL else 650
|
|
x_inset = 50 if uiscale is babase.UIScale.SMALL else 0
|
|
self._height = (
|
|
346
|
|
if uiscale is babase.UIScale.SMALL
|
|
else 380
|
|
if uiscale is babase.UIScale.MEDIUM
|
|
else 440
|
|
)
|
|
top_extra = 30 if uiscale is babase.UIScale.SMALL else 20
|
|
self._scroll_width = 210
|
|
|
|
self._root_widget = bui.containerwidget(
|
|
size=(self._width, self._height + top_extra),
|
|
transition=transition,
|
|
scale=(
|
|
2.17
|
|
if uiscale is babase.UIScale.SMALL
|
|
else 1.5
|
|
if uiscale is babase.UIScale.MEDIUM
|
|
else 1.0
|
|
),
|
|
stack_offset=(0, 1) if uiscale is babase.UIScale.SMALL else (0, 0),
|
|
)
|
|
|
|
self._back_button = bui.buttonwidget(
|
|
parent=self._root_widget,
|
|
position=(58 + x_inset, self._height - 53),
|
|
size=(165, 70),
|
|
scale=0.75,
|
|
text_scale=1.2,
|
|
label=babase.Lstr(resource="backText"),
|
|
autoselect=True,
|
|
button_type="back",
|
|
on_activate_call=self._back,
|
|
)
|
|
self._select_button = select_button = bui.buttonwidget(
|
|
parent=self._root_widget,
|
|
position=(self._width - (172 + x_inset), self._height - 50),
|
|
autoselect=True,
|
|
size=(160, 60),
|
|
scale=0.75,
|
|
text_scale=1.2,
|
|
label=babase.Lstr(resource="selectText"),
|
|
on_activate_call=self._add,
|
|
)
|
|
|
|
if bui.app.ui_v1.use_toolbars:
|
|
bui.widget(
|
|
edit=select_button, right_widget=bui.get_special_widget("party_button")
|
|
)
|
|
|
|
bui.textwidget(
|
|
parent=self._root_widget,
|
|
position=(self._width * 0.5, self._height - 28),
|
|
size=(0, 0),
|
|
scale=1.0,
|
|
text=babase.Lstr(resource=self._r + ".titleText"),
|
|
h_align="center",
|
|
color=bui.app.ui_v1.title_color,
|
|
maxwidth=250,
|
|
v_align="center",
|
|
)
|
|
v = self._height - 64
|
|
|
|
self._selected_title_text = bui.textwidget(
|
|
parent=self._root_widget,
|
|
position=(x_inset + self._scroll_width + 50 + 30, v - 15),
|
|
size=(0, 0),
|
|
scale=1.0,
|
|
color=(0.7, 1.0, 0.7, 1.0),
|
|
maxwidth=self._width - self._scroll_width - 150 - x_inset * 2,
|
|
h_align="left",
|
|
v_align="center",
|
|
)
|
|
v -= 30
|
|
|
|
self._selected_description_text = bui.textwidget(
|
|
parent=self._root_widget,
|
|
position=(x_inset + self._scroll_width + 50 + 30, v),
|
|
size=(0, 0),
|
|
scale=0.7,
|
|
color=(0.5, 0.8, 0.5, 1.0),
|
|
maxwidth=self._width - self._scroll_width - 150 - x_inset * 2,
|
|
h_align="left",
|
|
)
|
|
|
|
scroll_height = self._height - 100
|
|
|
|
v = self._height - 60
|
|
|
|
self._scrollwidget = bui.scrollwidget(
|
|
parent=self._root_widget,
|
|
position=(x_inset + 61, v - scroll_height),
|
|
size=(self._scroll_width, scroll_height),
|
|
highlight=False,
|
|
)
|
|
bui.widget(
|
|
edit=self._scrollwidget,
|
|
up_widget=self._back_button,
|
|
left_widget=self._back_button,
|
|
right_widget=select_button,
|
|
)
|
|
self._column: Optional[bui.Widget] = None
|
|
|
|
v -= 35
|
|
bui.containerwidget(
|
|
edit=self._root_widget,
|
|
cancel_button=self._back_button,
|
|
start_button=select_button,
|
|
)
|
|
self._selected_game_type: Optional[Type[bs.GameActivity]] = None
|
|
|
|
bui.containerwidget(edit=self._root_widget, selected_child=self._scrollwidget)
|
|
|
|
self._game_types: list[type[bs.GameActivity]] = []
|
|
|
|
# Get actual games loading in the bg.
|
|
babase.app.meta.load_exported_classes(
|
|
bs.GameActivity, self._on_game_types_loaded, completion_cb_in_bg_thread=True
|
|
)
|
|
|
|
# Refresh with our initial empty list. We'll refresh again once
|
|
# game loading is complete.
|
|
self._refresh()
|
|
|
|
if config["selected"]:
|
|
for gt in self._game_types:
|
|
if gt.__name__ == config["selected"]:
|
|
self._refresh(selected=gt)
|
|
self._set_selected_game_type(gt)
|
|
|
|
def _refresh(
|
|
self, select_get_more_games_button: bool = False, selected: bool = None
|
|
) -> None:
|
|
# from babase.internal import get_game_types
|
|
|
|
if self._column is not None:
|
|
self._column.delete()
|
|
|
|
self._column = bui.columnwidget(parent=self._scrollwidget, border=2, margin=0)
|
|
|
|
for i, gametype in enumerate(self._game_types):
|
|
|
|
def _doit() -> None:
|
|
if self._select_button:
|
|
bs.apptimer(0.1, self._select_button.activate)
|
|
|
|
txt = bui.textwidget(
|
|
parent=self._column,
|
|
position=(0, 0),
|
|
size=(self._width - 88, 24),
|
|
text=gametype.get_display_string(),
|
|
h_align="left",
|
|
v_align="center",
|
|
color=(0.8, 0.8, 0.8, 1.0),
|
|
maxwidth=self._scroll_width * 0.8,
|
|
on_select_call=babase.Call(self._set_selected_game_type, gametype),
|
|
always_highlight=True,
|
|
selectable=True,
|
|
on_activate_call=_doit,
|
|
)
|
|
if i == 0:
|
|
bui.widget(edit=txt, up_widget=self._back_button)
|
|
|
|
self._get_more_games_button = bui.buttonwidget(
|
|
parent=self._column,
|
|
autoselect=True,
|
|
label=babase.Lstr(resource=self._r + ".getMoreGamesText"),
|
|
color=(0.54, 0.52, 0.67),
|
|
textcolor=(0.7, 0.65, 0.7),
|
|
on_activate_call=self._on_get_more_games_press,
|
|
size=(178, 50),
|
|
)
|
|
if select_get_more_games_button:
|
|
bui.containerwidget(
|
|
edit=self._column,
|
|
selected_child=self._get_more_games_button,
|
|
visible_child=self._get_more_games_button,
|
|
)
|
|
|
|
def _add(self) -> None:
|
|
_babase.lock_all_input() # Make sure no more commands happen.
|
|
bs.apptimer(0.1, _babase.unlock_all_input)
|
|
gameconfig = {}
|
|
if config["selected"] == self._selected_game_type.__name__:
|
|
if config["config"]:
|
|
gameconfig = config["config"]
|
|
if "map" in gameconfig:
|
|
gameconfig["settings"]["map"] = gameconfig.pop("map")
|
|
self._selected_game_type.create_settings_ui(
|
|
self._editcontroller.get_session_type(), gameconfig, self._edit_game_done
|
|
)
|
|
|
|
def _edit_game_done(self, config: Optional[Dict[str, Any]]) -> None:
|
|
if config:
|
|
CustomSession._config = config
|
|
CustomSession._gametype = self._selected_game_type
|
|
start_game(CustomSession)
|
|
else:
|
|
bui.app.ui_v1.clear_main_menu_window(transition="out_right")
|
|
bui.app.ui_v1.set_main_menu_window(
|
|
SelectGameWindow(transition="in_left").get_root_widget(),
|
|
from_window=None,
|
|
)
|
|
|
|
def _back(self) -> None:
|
|
if not self._root_widget or self._root_widget.transitioning_out:
|
|
return
|
|
|
|
bui.containerwidget(edit=self._root_widget, transition="out_right")
|
|
bui.app.ui_v1.set_main_menu_window(
|
|
PlayWindow(transition="in_left").get_root_widget(),
|
|
from_window=self._root_widget,
|
|
)
|
|
|
|
|
|
PlayWindow._old_init = PlayWindow.__init__
|
|
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self._old_init()
|
|
|
|
width = 800
|
|
height = 550
|
|
|
|
def do_quick_game() -> None:
|
|
if not self._root_widget or self._root_widget.transitioning_out:
|
|
return
|
|
|
|
self._save_state()
|
|
bui.containerwidget(edit=self._root_widget, transition="out_left")
|
|
bui.app.ui_v1.set_main_menu_window(
|
|
SelectGameWindow().get_root_widget(), from_window=self._root_widget
|
|
)
|
|
|
|
self._quick_game_button = bui.buttonwidget(
|
|
parent=self._root_widget,
|
|
position=(width - 55 - 120, height - 132),
|
|
autoselect=True,
|
|
size=(120, 60),
|
|
scale=1.1,
|
|
text_scale=1.2,
|
|
label=custom_txt,
|
|
on_activate_call=do_quick_game,
|
|
color=(0.54, 0.52, 0.67),
|
|
textcolor=(0.7, 0.65, 0.7),
|
|
)
|
|
|
|
self._restore_state()
|
|
|
|
|
|
def states(self) -> None:
|
|
return {
|
|
"Team Games": self._teams_button,
|
|
"Co-op Games": self._coop_button,
|
|
"Free-for-All Games": self._free_for_all_button,
|
|
"Back": self._back_button,
|
|
"Quick Game": self._quick_game_button,
|
|
}
|
|
|
|
|
|
def _save_state(self) -> None:
|
|
swapped = {v: k for k, v in states(self).items()}
|
|
if self._root_widget.get_selected_child() in swapped:
|
|
bui.app.ui_v1.window_states[self.__class__.__name__] = swapped[
|
|
self._root_widget.get_selected_child()
|
|
]
|
|
else:
|
|
babase.print_exception(f"Error saving state for {self}.")
|
|
|
|
|
|
def _restore_state(self) -> None:
|
|
if not hasattr(self, "_quick_game_button"):
|
|
return # ensure that our monkey patched init ran
|
|
if self.__class__.__name__ not in bui.app.ui_v1.window_states:
|
|
bui.containerwidget(edit=self._root_widget, selected_child=self._coop_button)
|
|
return
|
|
sel = states(self).get(bui.app.ui_v1.window_states[self.__class__.__name__], None)
|
|
if sel:
|
|
bui.containerwidget(edit=self._root_widget, selected_child=sel)
|
|
else:
|
|
bui.containerwidget(edit=self._root_widget, selected_child=self._coop_button)
|
|
babase.print_exception(f"Error restoring state for {self}.")
|
|
|
|
|
|
# ba_meta export plugin
|
|
class QuickGamePlugin(babase.Plugin):
|
|
PlayWindow.__init__ = __init__
|
|
PlayWindow._save_state = _save_state
|
|
PlayWindow._restore_state = _restore_state
|