def _update(self) -> None:
app = ba.app
# Update logo in case it changes.
if self._logo_node:
custom_texture = self._get_custom_logo_tex_name()
if custom_texture != self._custom_logo_tex_name:
self._custom_logo_tex_name = custom_texture
self._logo_node.texture = ba.gettexture(
custom_texture if custom_texture is not None else 'logo')
self._logo_node.model_opaque = (None
if custom_texture is not None
else ba.getmodel('logo'))
self._logo_node.model_transparent = (
None if custom_texture is not None else
ba.getmodel('logoTransparent'))
# If language has changed, recreate our logo text/graphics.
lang = app.language
if lang != self._language:
self._language = lang
y = 20
base_scale = 1.1
self._word_actors = []
base_delay = 1.0
delay = base_delay
delay_inc = 0.02
# Come on faster after the first time.
if app.main_menu_did_initial_transition:
base_delay = 0.0
delay = base_delay
delay_inc = 0.02
# We draw higher in kiosk mode (make sure to test this
# when making adjustments) for now we're hard-coded for
# a few languages.. should maybe look into generalizing this?..
if app.language == 'Chinese':
base_x = -270.0
x = base_x - 20.0
spacing = 85.0 * base_scale
y_extra = 0.0 if app.kiosk_mode else 0.0
self._make_logo(x - 110 + 50,
113 + y + 1.2 * y_extra,
0.34 * base_scale,
delay=base_delay + 0.1,
custom_texture='chTitleChar1',
jitter_scale=2.0,
vr_depth_offset=-30)
x += spacing
delay += delay_inc
self._make_logo(x - 10 + 50,
110 + y + 1.2 * y_extra,
0.31 * base_scale,
delay=base_delay + 0.15,
custom_texture='chTitleChar2',
jitter_scale=2.0,
vr_depth_offset=-30)
x += 2.0 * spacing
delay += delay_inc
self._make_logo(x + 180 - 140,
110 + y + 1.2 * y_extra,
0.3 * base_scale,
delay=base_delay + 0.25,
custom_texture='chTitleChar3',
jitter_scale=2.0,
vr_depth_offset=-30)
x += spacing
delay += delay_inc
self._make_logo(x + 241 - 120,
110 + y + 1.2 * y_extra,
0.31 * base_scale,
delay=base_delay + 0.3,
custom_texture='chTitleChar4',
jitter_scale=2.0,
vr_depth_offset=-30)
x += spacing
delay += delay_inc
self._make_logo(x + 300 - 90,
105 + y + 1.2 * y_extra,
0.34 * base_scale,
delay=base_delay + 0.35,
custom_texture='chTitleChar5',
jitter_scale=2.0,
vr_depth_offset=-30)
self._make_logo(base_x + 155,
146 + y + 1.2 * y_extra,
0.28 * base_scale,
delay=base_delay + 0.2,
rotate=-7)
else:
base_x = -170
x = base_x - 20
spacing = 55 * base_scale
y_extra = 0 if app.kiosk_mode else 0
xv1 = x
delay1 = delay
for shadow in (True, False):
x = xv1
delay = delay1
self._make_word('B',
x - 50,
y - 23 + 0.8 * y_extra,
scale=1.3 * base_scale,
delay=delay,
vr_depth_offset=3,
shadow=shadow)
x += spacing
delay += delay_inc
self._make_word('m',
x,
y + y_extra,
delay=delay,
scale=base_scale,
shadow=shadow)
x += spacing * 1.25
delay += delay_inc
self._make_word('b',
x,
y + y_extra - 10,
delay=delay,
scale=1.1 * base_scale,
vr_depth_offset=5,
shadow=shadow)
x += spacing * 0.85
delay += delay_inc
self._make_word('S',
x,
y - 25 + 0.8 * y_extra,
scale=1.35 * base_scale,
delay=delay,
vr_depth_offset=14,
shadow=shadow)
x += spacing
delay += delay_inc
self._make_word('q',
x,
y + y_extra,
delay=delay,
scale=base_scale,
shadow=shadow)
x += spacing * 0.9
delay += delay_inc
self._make_word('u',
x,
y + y_extra,
delay=delay,
scale=base_scale,
vr_depth_offset=7,
shadow=shadow)
x += spacing * 0.9
delay += delay_inc
self._make_word('a',
x,
y + y_extra,
delay=delay,
scale=base_scale,
shadow=shadow)
x += spacing * 0.64
delay += delay_inc
self._make_word('d',
x,
y + y_extra - 10,
delay=delay,
scale=1.1 * base_scale,
vr_depth_offset=6,
shadow=shadow)
self._make_logo(base_x - 28,
125 + y + 1.2 * y_extra,
0.32 * base_scale,
delay=base_delay)
def __init__(self,
transition: Optional[str] = 'in_right',
origin_widget: ba.Widget = None):
# pylint: disable=too-many-statements
# pylint: disable=too-many-locals
ba.set_analytics_screen('Gather Window')
scale_origin: Optional[Tuple[float, float]]
if origin_widget is not None:
self._transition_out = 'out_scale'
scale_origin = origin_widget.get_screen_space_center()
transition = 'in_scale'
else:
self._transition_out = 'out_right'
scale_origin = None
ba.app.ui.set_main_menu_location('Gather')
_ba.set_party_icon_always_visible(True)
uiscale = ba.app.ui.uiscale
self._width = 1240 if uiscale is ba.UIScale.SMALL else 1040
x_offs = 100 if uiscale is ba.UIScale.SMALL else 0
self._height = (582 if uiscale is ba.UIScale.SMALL else
680 if uiscale is ba.UIScale.MEDIUM else 800)
self._current_tab: Optional[GatherWindow.TabID] = None
extra_top = 20 if uiscale is ba.UIScale.SMALL else 0
self._r = 'gatherWindow'
super().__init__(root_widget=ba.containerwidget(
size=(self._width, self._height + extra_top),
transition=transition,
toolbar_visibility='menu_minimal',
scale_origin_stack_offset=scale_origin,
scale=(1.3 if uiscale is ba.UIScale.SMALL else
0.97 if uiscale is ba.UIScale.MEDIUM else 0.8),
stack_offset=(0, -11) if uiscale is ba.UIScale.SMALL else (
0, 0) if uiscale is ba.UIScale.MEDIUM else (0, 0)))
if uiscale is ba.UIScale.SMALL and ba.app.ui.use_toolbars:
ba.containerwidget(edit=self._root_widget,
on_cancel_call=self._back)
self._back_button = None
else:
self._back_button = btn = ba.buttonwidget(
parent=self._root_widget,
position=(70 + x_offs, self._height - 74),
size=(140, 60),
scale=1.1,
autoselect=True,
label=ba.Lstr(resource='backText'),
button_type='back',
on_activate_call=self._back)
ba.containerwidget(edit=self._root_widget, cancel_button=btn)
ba.buttonwidget(edit=btn,
button_type='backSmall',
position=(70 + x_offs, self._height - 78),
size=(60, 60),
label=ba.charstr(ba.SpecialChar.BACK))
condensed = uiscale is not ba.UIScale.LARGE
t_offs_y = (0 if not condensed else
25 if uiscale is ba.UIScale.MEDIUM else 17)
ba.textwidget(parent=self._root_widget,
position=(self._width * 0.5,
self._height - 42 + t_offs_y),
size=(0, 0),
color=ba.app.ui.title_color,
scale=(1.5 if not condensed else
1.0 if uiscale is ba.UIScale.MEDIUM else 0.6),
h_align='center',
v_align='center',
text=ba.Lstr(resource=self._r + '.titleText'),
maxwidth=550)
platform = ba.app.platform
subplatform = ba.app.subplatform
scroll_buffer_h = 130 + 2 * x_offs
tab_buffer_h = ((320 if condensed else 250) + 2 * x_offs)
# Build up the set of tabs we want.
tabdefs: List[Tuple[GatherWindow.TabID, ba.Lstr]] = [
(self.TabID.ABOUT, ba.Lstr(resource=self._r + '.aboutText'))
]
if _ba.get_account_misc_read_val('enablePublicParties', True):
tabdefs.append((self.TabID.INTERNET,
ba.Lstr(resource=self._r + '.internetText')))
if platform == 'android' and subplatform == 'google':
tabdefs.append((self.TabID.GOOGLE_PLAY,
ba.Lstr(resource=self._r + '.googlePlayText')))
tabdefs.append((self.TabID.LOCAL_NETWORK,
ba.Lstr(resource=self._r + '.localNetworkText')))
tabdefs.append(
(self.TabID.MANUAL, ba.Lstr(resource=self._r + '.manualText')))
# On small UI, push our tabs up closer to the top of the screen to
# save a bit of space.
tabs_top_extra = 42 if condensed else 0
self._tab_row = TabRow(self._root_widget,
tabdefs,
pos=(tab_buffer_h * 0.5,
self._height - 130 + tabs_top_extra),
size=(self._width - tab_buffer_h, 50),
on_select_call=ba.WeakCall(self._set_tab))
# Now instantiate handlers for these tabs.
tabtypes: Dict[GatherWindow.TabID, Type[GatherTab]] = {
self.TabID.ABOUT: AboutGatherTab,
self.TabID.MANUAL: ManualGatherTab,
self.TabID.GOOGLE_PLAY: GooglePlayGatherTab,
self.TabID.INTERNET: PublicGatherTab,
self.TabID.LOCAL_NETWORK: NearbyGatherTab
}
self._tabs: Dict[GatherWindow.TabID, GatherTab] = {}
for tab_id in self._tab_row.tabs:
tabtype = tabtypes.get(tab_id)
if tabtype is not None:
self._tabs[tab_id] = tabtype(self)
if ba.app.ui.use_toolbars:
ba.widget(edit=self._tab_row.tabs[tabdefs[-1][0]].button,
right_widget=_ba.get_special_widget('party_button'))
if uiscale is ba.UIScale.SMALL:
ba.widget(edit=self._tab_row.tabs[tabdefs[0][0]].button,
left_widget=_ba.get_special_widget('back_button'))
self._scroll_width = self._width - scroll_buffer_h
self._scroll_height = self._height - 180.0 + tabs_top_extra
self._scroll_left = (self._width - self._scroll_width) * 0.5
self._scroll_bottom = (self._height - self._scroll_height - 79 - 48 +
tabs_top_extra)
buffer_h = 10
buffer_v = 4
# Not actually using a scroll widget anymore; just an image.
ba.imagewidget(parent=self._root_widget,
position=(self._scroll_left - buffer_h,
self._scroll_bottom - buffer_v),
size=(self._scroll_width + 2 * buffer_h,
self._scroll_height + 2 * buffer_v),
texture=ba.gettexture('scrollWidget'),
model_transparent=ba.getmodel('softEdgeOutside'))
self._tab_container: Optional[ba.Widget] = None
self._restore_state()
def __init__(self, transition: str = 'in_right'):
# pylint: disable=too-many-locals, too-many-statements
from bastd.ui import confirm
self._width = 720.0
self._height = 340.0
def _do_cancel() -> None:
confirm.QuitWindow(swish=True, back=True)
super().__init__(
root_widget=ba.containerwidget(size=(self._width, self._height),
transition=transition,
on_cancel_call=_do_cancel,
background=False,
stack_offset=(0, -130)))
self._r = 'kioskWindow'
self._show_multiplayer = False
# Let's reset all random player names every time we hit the main menu.
_ba.reset_random_player_names()
# Reset achievements too (at least locally).
ba.app.config['Achievements'] = {}
t_delay_base = 0.0
t_delay_scale = 0.0
if not ba.app.did_menu_intro:
t_delay_base = 1.0
t_delay_scale = 1.0
model_opaque = ba.getmodel('level_select_button_opaque')
model_transparent = ba.getmodel('level_select_button_transparent')
mask_tex = ba.gettexture('mapPreviewMask')
y_extra = 130.0 + (0.0 if self._show_multiplayer else -130.0)
b_width = 250.0
b_height = 200.0
b_space = 280.0
b_v = 80.0 + y_extra
label_height = 130.0 + y_extra
img_width = 180.0
img_v = 158.0 + y_extra
if self._show_multiplayer:
tdelay = t_delay_base + t_delay_scale * 1.3
ba.textwidget(
parent=self._root_widget,
size=(0, 0),
position=(self._width * 0.5, self._height + y_extra - 44),
transition_delay=tdelay,
text=ba.Lstr(resource=self._r + '.singlePlayerExamplesText'),
flatness=1.0,
scale=1.2,
h_align='center',
v_align='center',
shadow=1.0)
else:
tdelay = t_delay_base + t_delay_scale * 0.7
ba.textwidget(
parent=self._root_widget,
size=(0, 0),
position=(self._width * 0.5, self._height + y_extra - 34),
transition_delay=tdelay,
text=ba.Lstr(resource='demoText',
fallback_resource='mainMenu.demoMenuText'),
flatness=1.0,
scale=1.2,
h_align='center',
v_align='center',
shadow=1.0)
h = self._width * 0.5 - b_space
tdelay = t_delay_base + t_delay_scale * 0.7
self._b1 = btn = ba.buttonwidget(parent=self._root_widget,
autoselect=True,
size=(b_width, b_height),
on_activate_call=ba.Call(
self._do_game, 'easy'),
transition_delay=tdelay,
position=(h - b_width * 0.5, b_v),
label='',
button_type='square')
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
transition_delay=tdelay,
size=(0, 0),
position=(h, label_height),
maxwidth=b_width * 0.7,
text=ba.Lstr(resource=self._r + '.easyText'),
scale=1.3,
h_align='center',
v_align='center')
ba.imagewidget(parent=self._root_widget,
draw_controller=btn,
size=(img_width, 0.5 * img_width),
transition_delay=tdelay,
position=(h - img_width * 0.5, img_v),
texture=ba.gettexture('doomShroomPreview'),
model_opaque=model_opaque,
model_transparent=model_transparent,
mask_texture=mask_tex)
h = self._width * 0.5
tdelay = t_delay_base + t_delay_scale * 0.65
self._b2 = btn = ba.buttonwidget(parent=self._root_widget,
autoselect=True,
size=(b_width, b_height),
on_activate_call=ba.Call(
self._do_game, 'medium'),
position=(h - b_width * 0.5, b_v),
label='',
button_type='square',
transition_delay=tdelay)
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
transition_delay=tdelay,
size=(0, 0),
position=(h, label_height),
maxwidth=b_width * 0.7,
text=ba.Lstr(resource=self._r + '.mediumText'),
scale=1.3,
h_align='center',
v_align='center')
ba.imagewidget(parent=self._root_widget,
draw_controller=btn,
size=(img_width, 0.5 * img_width),
transition_delay=tdelay,
position=(h - img_width * 0.5, img_v),
texture=ba.gettexture('footballStadiumPreview'),
model_opaque=model_opaque,
model_transparent=model_transparent,
mask_texture=mask_tex)
h = self._width * 0.5 + b_space
tdelay = t_delay_base + t_delay_scale * 0.6
self._b3 = btn = ba.buttonwidget(parent=self._root_widget,
autoselect=True,
size=(b_width, b_height),
on_activate_call=ba.Call(
self._do_game, 'hard'),
transition_delay=tdelay,
position=(h - b_width * 0.5, b_v),
label='',
button_type='square')
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
transition_delay=tdelay,
size=(0, 0),
position=(h, label_height),
maxwidth=b_width * 0.7,
text='Hard',
scale=1.3,
h_align='center',
v_align='center')
ba.imagewidget(parent=self._root_widget,
draw_controller=btn,
transition_delay=tdelay,
size=(img_width, 0.5 * img_width),
position=(h - img_width * 0.5, img_v),
texture=ba.gettexture('courtyardPreview'),
model_opaque=model_opaque,
model_transparent=model_transparent,
mask_texture=mask_tex)
if not ba.app.did_menu_intro:
ba.app.did_menu_intro = True
self._b4: Optional[ba.Widget]
self._b5: Optional[ba.Widget]
self._b6: Optional[ba.Widget]
if bool(False):
ba.textwidget(
parent=self._root_widget,
size=(0, 0),
position=(self._width * 0.5, self._height + y_extra - 44),
transition_delay=tdelay,
text=ba.Lstr(resource=self._r + '.versusExamplesText'),
flatness=1.0,
scale=1.2,
h_align='center',
v_align='center',
shadow=1.0)
h = self._width * 0.5 - b_space
tdelay = t_delay_base + t_delay_scale * 0.7
self._b4 = btn = ba.buttonwidget(parent=self._root_widget,
autoselect=True,
size=(b_width, b_height),
on_activate_call=ba.Call(
self._do_game, 'ctf'),
transition_delay=tdelay,
position=(h - b_width * 0.5, b_v),
label='',
button_type='square')
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
transition_delay=tdelay,
size=(0, 0),
position=(h, label_height),
maxwidth=b_width * 0.7,
text=ba.Lstr(translate=('gameNames',
'Capture the Flag')),
scale=1.3,
h_align='center',
v_align='center')
ba.imagewidget(parent=self._root_widget,
draw_controller=btn,
size=(img_width, 0.5 * img_width),
transition_delay=tdelay,
position=(h - img_width * 0.5, img_v),
texture=ba.gettexture('bridgitPreview'),
model_opaque=model_opaque,
model_transparent=model_transparent,
mask_texture=mask_tex)
h = self._width * 0.5
tdelay = t_delay_base + t_delay_scale * 0.65
self._b5 = btn = ba.buttonwidget(parent=self._root_widget,
autoselect=True,
size=(b_width, b_height),
on_activate_call=ba.Call(
self._do_game, 'hockey'),
position=(h - b_width * 0.5, b_v),
label='',
button_type='square',
transition_delay=tdelay)
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
transition_delay=tdelay,
size=(0, 0),
position=(h, label_height),
maxwidth=b_width * 0.7,
text=ba.Lstr(translate=('gameNames', 'Hockey')),
scale=1.3,
h_align='center',
v_align='center')
ba.imagewidget(parent=self._root_widget,
draw_controller=btn,
size=(img_width, 0.5 * img_width),
transition_delay=tdelay,
position=(h - img_width * 0.5, img_v),
texture=ba.gettexture('hockeyStadiumPreview'),
model_opaque=model_opaque,
model_transparent=model_transparent,
mask_texture=mask_tex)
h = self._width * 0.5 + b_space
tdelay = t_delay_base + t_delay_scale * 0.6
self._b6 = btn = ba.buttonwidget(parent=self._root_widget,
autoselect=True,
size=(b_width, b_height),
on_activate_call=ba.Call(
self._do_game, 'epic'),
transition_delay=tdelay,
position=(h - b_width * 0.5, b_v),
label='',
button_type='square')
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
transition_delay=tdelay,
size=(0, 0),
position=(h, label_height),
maxwidth=b_width * 0.7,
text=ba.Lstr(resource=self._r + '.epicModeText'),
scale=1.3,
h_align='center',
v_align='center')
ba.imagewidget(parent=self._root_widget,
draw_controller=btn,
transition_delay=tdelay,
size=(img_width, 0.5 * img_width),
position=(h - img_width * 0.5, img_v),
texture=ba.gettexture('tipTopPreview'),
model_opaque=model_opaque,
model_transparent=model_transparent,
mask_texture=mask_tex)
else:
self._b4 = self._b5 = self._b6 = None
self._b7: Optional[ba.Widget]
if bool(False):
self._b7 = ba.buttonwidget(
parent=self._root_widget,
autoselect=True,
size=(b_width, 50),
color=(0.45, 0.55, 0.45),
textcolor=(0.7, 0.8, 0.7),
scale=0.5,
position=((self._width * 0.5 - 37.5,
y_extra + 120) if not self._show_multiplayer else
(self._width + 100,
y_extra + (140 if ba.app.small_ui else 120))),
transition_delay=tdelay,
label=ba.Lstr(resource=self._r + '.fullMenuText'),
on_activate_call=self._do_full_menu)
else:
self._b7 = None
self._restore_state()
self._update()
self._update_timer = ba.Timer(1.0,
ba.WeakCall(self._update),
timetype=ba.TimeType.REAL,
repeat=True)
def __init__(self,
transition: Optional[str] = 'in_right',
origin_widget: ba.Widget = None):
# pylint: disable=too-many-locals
# pylint: disable=too-many-statements
from bastd.ui import tabs
ba.set_analytics_screen('Watch Window')
scale_origin: Optional[Tuple[float, float]]
if origin_widget is not None:
self._transition_out = 'out_scale'
scale_origin = origin_widget.get_screen_space_center()
transition = 'in_scale'
else:
self._transition_out = 'out_right'
scale_origin = None
ba.app.ui.set_main_menu_location('Watch')
self._tab_data: Dict[str, Any] = {}
self._my_replays_scroll_width: Optional[float] = None
self._my_replays_watch_replay_button: Optional[ba.Widget] = None
self._scrollwidget: Optional[ba.Widget] = None
self._columnwidget: Optional[ba.Widget] = None
self._my_replay_selected: Optional[str] = None
self._my_replays_rename_window: Optional[ba.Widget] = None
self._my_replay_rename_text: Optional[ba.Widget] = None
self._r = 'watchWindow'
uiscale = ba.app.ui.uiscale
self._width = 1240 if uiscale is ba.UIScale.SMALL else 1040
x_inset = 100 if uiscale is ba.UIScale.SMALL else 0
self._height = (578 if uiscale is ba.UIScale.SMALL else
670 if uiscale is ba.UIScale.MEDIUM else 800)
self._current_tab: Optional[str] = None
extra_top = 20 if uiscale is ba.UIScale.SMALL else 0
super().__init__(root_widget=ba.containerwidget(
size=(self._width, self._height + extra_top),
transition=transition,
toolbar_visibility='menu_minimal',
scale_origin_stack_offset=scale_origin,
scale=(1.3 if uiscale is ba.UIScale.SMALL else
0.97 if uiscale is ba.UIScale.MEDIUM else 0.8),
stack_offset=(0, -10) if uiscale is ba.UIScale.SMALL else (
0, 15) if uiscale is ba.UIScale.MEDIUM else (0, 0)))
if uiscale is ba.UIScale.SMALL and ba.app.ui.use_toolbars:
ba.containerwidget(edit=self._root_widget,
on_cancel_call=self._back)
self._back_button = None
else:
self._back_button = btn = ba.buttonwidget(
parent=self._root_widget,
autoselect=True,
position=(70 + x_inset, self._height - 74),
size=(140, 60),
scale=1.1,
label=ba.Lstr(resource='backText'),
button_type='back',
on_activate_call=self._back)
ba.containerwidget(edit=self._root_widget, cancel_button=btn)
ba.buttonwidget(edit=btn,
button_type='backSmall',
size=(60, 60),
label=ba.charstr(ba.SpecialChar.BACK))
ba.textwidget(parent=self._root_widget,
position=(self._width * 0.5, self._height - 38),
size=(0, 0),
color=ba.app.ui.title_color,
scale=1.5,
h_align='center',
v_align='center',
text=ba.Lstr(resource=self._r + '.titleText'),
maxwidth=400)
tabs_def = [('my_replays',
ba.Lstr(resource=self._r + '.myReplaysText'))]
scroll_buffer_h = 130 + 2 * x_inset
tab_buffer_h = 750 + 2 * x_inset
self._tab_buttons = tabs.create_tab_buttons(
self._root_widget,
tabs_def,
pos=(tab_buffer_h * 0.5, self._height - 130),
size=(self._width - tab_buffer_h, 50),
on_select_call=self._set_tab)
if ba.app.ui.use_toolbars:
ba.widget(edit=self._tab_buttons[tabs_def[-1][0]],
right_widget=_ba.get_special_widget('party_button'))
if uiscale is ba.UIScale.SMALL:
bbtn = _ba.get_special_widget('back_button')
ba.widget(edit=self._tab_buttons[tabs_def[0][0]],
up_widget=bbtn,
left_widget=bbtn)
self._scroll_width = self._width - scroll_buffer_h
self._scroll_height = self._height - 180
# not actually using a scroll widget anymore; just an image
scroll_left = (self._width - self._scroll_width) * 0.5
scroll_bottom = self._height - self._scroll_height - 79 - 48
buffer_h = 10
buffer_v = 4
ba.imagewidget(parent=self._root_widget,
position=(scroll_left - buffer_h,
scroll_bottom - buffer_v),
size=(self._scroll_width + 2 * buffer_h,
self._scroll_height + 2 * buffer_v),
texture=ba.gettexture('scrollWidget'),
model_transparent=ba.getmodel('softEdgeOutside'))
self._tab_container: Optional[ba.Widget] = None
self._restore_state()
def _refresh(self, select_get_more_maps_button: bool = False) -> None:
# pylint: disable=too-many-statements
# pylint: disable=too-many-branches
# pylint: disable=too-many-locals
from ba.internal import (get_unowned_maps, get_map_class,
get_map_display_string)
# Kill old.
if self._subcontainer is not None:
self._subcontainer.delete()
model_opaque = ba.getmodel('level_select_button_opaque')
model_transparent = ba.getmodel('level_select_button_transparent')
self._maps = []
map_list = self._gameclass.get_supported_maps(self._sessiontype)
map_list_sorted = list(map_list)
map_list_sorted.sort()
unowned_maps = get_unowned_maps()
for mapname in map_list_sorted:
# Disallow ones we don't own.
if mapname in unowned_maps:
continue
map_tex_name = (get_map_class(mapname).get_preview_texture_name())
if map_tex_name is not None:
try:
map_tex = ba.gettexture(map_tex_name)
self._maps.append((mapname, map_tex))
except Exception:
print(f'Invalid map preview texture: "{map_tex_name}".')
else:
print('Error: no map preview texture for map:', mapname)
count = len(self._maps)
columns = 2
rows = int(math.ceil(float(count) / columns))
button_width = 220
button_height = button_width * 0.5
button_buffer_h = 16
button_buffer_v = 19
self._sub_width = self._scroll_width * 0.95
self._sub_height = 5 + rows * (button_height +
2 * button_buffer_v) + 100
self._subcontainer = ba.containerwidget(parent=self._scrollwidget,
size=(self._sub_width,
self._sub_height),
background=False)
index = 0
mask_texture = ba.gettexture('mapPreviewMask')
h_offs = 130 if len(self._maps) == 1 else 0
for y in range(rows):
for x in range(columns):
pos = (x * (button_width + 2 * button_buffer_h) +
button_buffer_h + h_offs, self._sub_height - (y + 1) *
(button_height + 2 * button_buffer_v) + 12)
btn = ba.buttonwidget(parent=self._subcontainer,
button_type='square',
size=(button_width, button_height),
autoselect=True,
texture=self._maps[index][1],
mask_texture=mask_texture,
model_opaque=model_opaque,
model_transparent=model_transparent,
label='',
color=(1, 1, 1),
on_activate_call=ba.Call(
self._select_with_delay,
self._maps[index][0]),
position=pos)
if x == 0:
ba.widget(edit=btn, left_widget=self._cancel_button)
if y == 0:
ba.widget(edit=btn, up_widget=self._cancel_button)
if x == columns - 1 and ba.app.ui.use_toolbars:
ba.widget(
edit=btn,
right_widget=_ba.get_special_widget('party_button'))
ba.widget(edit=btn, show_buffer_top=60, show_buffer_bottom=60)
if self._maps[index][0] == self._previous_map:
ba.containerwidget(edit=self._subcontainer,
selected_child=btn,
visible_child=btn)
name = get_map_display_string(self._maps[index][0])
ba.textwidget(parent=self._subcontainer,
text=name,
position=(pos[0] + button_width * 0.5,
pos[1] - 12),
size=(0, 0),
scale=0.5,
maxwidth=button_width,
draw_controller=btn,
h_align='center',
v_align='center',
color=(0.8, 0.8, 0.8, 0.8))
index += 1
if index >= count:
break
if index >= count:
break
self._get_more_maps_button = btn = ba.buttonwidget(
parent=self._subcontainer,
size=(self._sub_width * 0.8, 60),
position=(self._sub_width * 0.1, 30),
label=ba.Lstr(resource='mapSelectGetMoreMapsText'),
on_activate_call=self._on_store_press,
color=(0.6, 0.53, 0.63),
textcolor=(0.75, 0.7, 0.8),
autoselect=True)
ba.widget(edit=btn, show_buffer_top=30, show_buffer_bottom=30)
if select_get_more_maps_button:
ba.containerwidget(edit=self._subcontainer,
selected_child=btn,
visible_child=btn)
def on_transition_in(self) -> None:
super().on_transition_in()
random.seed(123)
self._logo_node: Optional[ba.Node] = None
self._custom_logo_tex_name: Optional[str] = None
self._word_actors: List[ba.Actor] = []
app = ba.app
# FIXME: We shouldn't be doing things conditionally based on whether
# the host is VR mode or not (clients may differ in that regard).
# Any differences need to happen at the engine level so everyone
# sees things in their own optimal way.
vr_mode = ba.app.vr_mode
if not ba.app.toolbar_test:
color = ((1.0, 1.0, 1.0, 1.0) if vr_mode else (0.5, 0.6, 0.5, 0.6))
# FIXME: Need a node attr for vr-specific-scale.
scale = (0.9 if
(app.ui.uiscale is ba.UIScale.SMALL or vr_mode) else 0.7)
self.my_name = ba.NodeActor(
ba.newnode('text',
attrs={
'v_attach': 'bottom',
'h_align': 'center',
'color': color,
'flatness': 1.0,
'shadow': 1.0 if vr_mode else 0.5,
'scale': scale,
'position': (0, 10),
'vr_depth': -10,
'text': '\xa9 2011-2020 Eric Froemling'
}))
# Throw up some text that only clients can see so they know that the
# host is navigating menus while they're just staring at an
# empty-ish screen.
tval = ba.Lstr(resource='hostIsNavigatingMenusText',
subs=[('${HOST}', _ba.get_account_display_string())])
self._host_is_navigating_text = ba.NodeActor(
ba.newnode('text',
attrs={
'text': tval,
'client_only': True,
'position': (0, -200),
'flatness': 1.0,
'h_align': 'center'
}))
if not ba.app.main_menu_did_initial_transition and hasattr(
self, 'my_name'):
assert self.my_name.node
ba.animate(self.my_name.node, 'opacity', {2.3: 0, 3.0: 1.0})
# FIXME: We shouldn't be doing things conditionally based on whether
# the host is vr mode or not (clients may not be or vice versa).
# Any differences need to happen at the engine level so everyone sees
# things in their own optimal way.
vr_mode = app.vr_mode
uiscale = app.ui.uiscale
# In cases where we're doing lots of dev work lets always show the
# build number.
force_show_build_number = False
if not ba.app.toolbar_test:
if app.debug_build or app.test_build or force_show_build_number:
if app.debug_build:
text = ba.Lstr(value='${V} (${B}) (${D})',
subs=[
('${V}', app.version),
('${B}', str(app.build_number)),
('${D}', ba.Lstr(resource='debugText')),
])
else:
text = ba.Lstr(value='${V} (${B})',
subs=[
('${V}', app.version),
('${B}', str(app.build_number)),
])
else:
text = ba.Lstr(value='${V}', subs=[('${V}', app.version)])
scale = 0.9 if (uiscale is ba.UIScale.SMALL or vr_mode) else 0.7
color = (1, 1, 1, 1) if vr_mode else (0.5, 0.6, 0.5, 0.7)
self.version = ba.NodeActor(
ba.newnode('text',
attrs={
'v_attach': 'bottom',
'h_attach': 'right',
'h_align': 'right',
'flatness': 1.0,
'vr_depth': -10,
'shadow': 1.0 if vr_mode else 0.5,
'color': color,
'scale': scale,
'position': (-260, 10) if vr_mode else
(-10, 10),
'text': text
}))
if not ba.app.main_menu_did_initial_transition:
assert self.version.node
ba.animate(self.version.node, 'opacity', {2.3: 0, 3.0: 1.0})
# Throw in test build info.
self.beta_info = self.beta_info_2 = None
if app.test_build and not (app.demo_mode or app.arcade_mode):
pos = ((230, 125) if (app.demo_mode or app.arcade_mode) else
(230, 35))
self.beta_info = ba.NodeActor(
ba.newnode('text',
attrs={
'v_attach': 'center',
'h_align': 'center',
'color': (1, 1, 1, 1),
'shadow': 0.5,
'flatness': 0.5,
'scale': 1,
'vr_depth': -60,
'position': pos,
'text': ba.Lstr(resource='testBuildText')
}))
if not ba.app.main_menu_did_initial_transition:
assert self.beta_info.node
ba.animate(self.beta_info.node, 'opacity', {1.3: 0, 1.8: 1.0})
model = ba.getmodel('thePadLevel')
trees_model = ba.getmodel('trees')
bottom_model = ba.getmodel('thePadLevelBottom')
color_texture = ba.gettexture('thePadLevelColor')
trees_texture = ba.gettexture('treesColor')
bgtex = ba.gettexture('menuBG')
bgmodel = ba.getmodel('thePadBG')
# Load these last since most platforms don't use them.
vr_bottom_fill_model = ba.getmodel('thePadVRFillBottom')
vr_top_fill_model = ba.getmodel('thePadVRFillTop')
gnode = self.globalsnode
gnode.camera_mode = 'rotate'
tint = (1.14, 1.1, 1.0)
gnode.tint = tint
gnode.ambient_color = (1.06, 1.04, 1.03)
gnode.vignette_outer = (0.45, 0.55, 0.54)
gnode.vignette_inner = (0.99, 0.98, 0.98)
self.bottom = ba.NodeActor(
ba.newnode('terrain',
attrs={
'model': bottom_model,
'lighting': False,
'reflection': 'soft',
'reflection_scale': [0.45],
'color_texture': color_texture
}))
self.vr_bottom_fill = ba.NodeActor(
ba.newnode('terrain',
attrs={
'model': vr_bottom_fill_model,
'lighting': False,
'vr_only': True,
'color_texture': color_texture
}))
self.vr_top_fill = ba.NodeActor(
ba.newnode('terrain',
attrs={
'model': vr_top_fill_model,
'vr_only': True,
'lighting': False,
'color_texture': bgtex
}))
self.terrain = ba.NodeActor(
ba.newnode('terrain',
attrs={
'model': model,
'color_texture': color_texture,
'reflection': 'soft',
'reflection_scale': [0.3]
}))
self.trees = ba.NodeActor(
ba.newnode('terrain',
attrs={
'model': trees_model,
'lighting': False,
'reflection': 'char',
'reflection_scale': [0.1],
'color_texture': trees_texture
}))
self.bgterrain = ba.NodeActor(
ba.newnode('terrain',
attrs={
'model': bgmodel,
'color': (0.92, 0.91, 0.9),
'lighting': False,
'background': True,
'color_texture': bgtex
}))
self._ts = 0.86
self._language: Optional[str] = None
self._update_timer = ba.Timer(1.0, self._update, repeat=True)
self._update()
# Hopefully this won't hitch but lets space these out anyway.
_ba.add_clean_frame_callback(ba.WeakCall(self._start_preloads))
random.seed()
# On the main menu, also show our news.
class News:
"""Wrangles news display."""
def __init__(self, activity: ba.Activity):
self._valid = True
self._message_duration = 10.0
self._message_spacing = 2.0
self._text: Optional[ba.NodeActor] = None
self._activity = weakref.ref(activity)
# If we're signed in, fetch news immediately.
# Otherwise wait until we are signed in.
self._fetch_timer: Optional[ba.Timer] = ba.Timer(
1.0, ba.WeakCall(self._try_fetching_news), repeat=True)
self._try_fetching_news()
# We now want to wait until we're signed in before fetching news.
def _try_fetching_news(self) -> None:
if _ba.get_account_state() == 'signed_in':
self._fetch_news()
self._fetch_timer = None
def _fetch_news(self) -> None:
ba.app.main_menu_last_news_fetch_time = time.time()
# UPDATE - We now just pull news from MRVs.
news = _ba.get_account_misc_read_val('n', None)
if news is not None:
self._got_news(news)
def _change_phrase(self) -> None:
from bastd.actor.text import Text
# If our news is way out of date, lets re-request it;
# otherwise, rotate our phrase.
assert ba.app.main_menu_last_news_fetch_time is not None
if time.time() - ba.app.main_menu_last_news_fetch_time > 600.0:
self._fetch_news()
self._text = None
else:
if self._text is not None:
if not self._phrases:
for phr in self._used_phrases:
self._phrases.insert(0, phr)
val = self._phrases.pop()
if val == '__ACH__':
vrmode = app.vr_mode
Text(ba.Lstr(resource='nextAchievementsText'),
color=((1, 1, 1, 1) if vrmode else
(0.95, 0.9, 1, 0.4)),
host_only=True,
maxwidth=200,
position=(-300, -35),
h_align=Text.HAlign.RIGHT,
transition=Text.Transition.FADE_IN,
scale=0.9 if vrmode else 0.7,
flatness=1.0 if vrmode else 0.6,
shadow=1.0 if vrmode else 0.5,
h_attach=Text.HAttach.CENTER,
v_attach=Text.VAttach.TOP,
transition_delay=1.0,
transition_out_delay=self._message_duration
).autoretain()
achs = [
a for a in app.achievements if not a.complete
]
if achs:
ach = achs.pop(
random.randrange(min(4, len(achs))))
ach.create_display(
-180,
-35,
1.0,
outdelay=self._message_duration,
style='news')
if achs:
ach = achs.pop(
random.randrange(min(8, len(achs))))
ach.create_display(
180,
-35,
1.25,
outdelay=self._message_duration,
style='news')
else:
spc = self._message_spacing
keys = {
spc: 0.0,
spc + 1.0: 1.0,
spc + self._message_duration - 1.0: 1.0,
spc + self._message_duration: 0.0
}
assert self._text.node
ba.animate(self._text.node, 'opacity', keys)
# {k: v
# for k, v in list(keys.items())})
self._text.node.text = val
def _got_news(self, news: str) -> None:
# Run this stuff in the context of our activity since we
# need to make nodes and stuff.. should fix the serverget
# call so it.
activity = self._activity()
if activity is None or activity.expired:
return
with ba.Context(activity):
self._phrases: List[str] = []
# Show upcoming achievements in non-vr versions
# (currently too hard to read in vr).
self._used_phrases = (
['__ACH__'] if not ba.app.vr_mode else
[]) + [s for s in news.split('<br>\n') if s != '']
self._phrase_change_timer = ba.Timer(
(self._message_duration + self._message_spacing),
ba.WeakCall(self._change_phrase),
repeat=True)
scl = 1.2 if (ba.app.ui.uiscale is ba.UIScale.SMALL
or ba.app.vr_mode) else 0.8
color2 = ((1, 1, 1, 1) if ba.app.vr_mode else
(0.7, 0.65, 0.75, 1.0))
shadow = (1.0 if ba.app.vr_mode else 0.4)
self._text = ba.NodeActor(
ba.newnode('text',
attrs={
'v_attach': 'top',
'h_attach': 'center',
'h_align': 'center',
'vr_depth': -20,
'shadow': shadow,
'flatness': 0.8,
'v_align': 'top',
'color': color2,
'scale': scl,
'maxwidth': 900.0 / scl,
'position': (0, -10)
}))
self._change_phrase()
if not (app.demo_mode or app.arcade_mode) and not app.toolbar_test:
self._news = News(self)
# Bring up the last place we were, or start at the main menu otherwise.
with ba.Context('ui'):
from bastd.ui import specialoffer
if bool(False):
uicontroller = ba.app.ui.controller
assert uicontroller is not None
uicontroller.show_main_menu()
else:
main_menu_location = ba.app.ui.get_main_menu_location()
# When coming back from a kiosk-mode game, jump to
# the kiosk start screen.
if ba.app.demo_mode or ba.app.arcade_mode:
# pylint: disable=cyclic-import
from bastd.ui.kiosk import KioskWindow
ba.app.ui.set_main_menu_window(
KioskWindow().get_root_widget())
# ..or in normal cases go back to the main menu
else:
if main_menu_location == 'Gather':
# pylint: disable=cyclic-import
from bastd.ui.gather import GatherWindow
ba.app.ui.set_main_menu_window(
GatherWindow(transition=None).get_root_widget())
elif main_menu_location == 'Watch':
# pylint: disable=cyclic-import
from bastd.ui.watch import WatchWindow
ba.app.ui.set_main_menu_window(
WatchWindow(transition=None).get_root_widget())
elif main_menu_location == 'Team Game Select':
# pylint: disable=cyclic-import
from bastd.ui.playlist.browser import (
PlaylistBrowserWindow)
ba.app.ui.set_main_menu_window(
PlaylistBrowserWindow(
sessiontype=ba.DualTeamSession,
transition=None).get_root_widget())
elif main_menu_location == 'Free-for-All Game Select':
# pylint: disable=cyclic-import
from bastd.ui.playlist.browser import (
PlaylistBrowserWindow)
ba.app.ui.set_main_menu_window(
PlaylistBrowserWindow(
sessiontype=ba.FreeForAllSession,
transition=None).get_root_widget())
elif main_menu_location == 'Coop Select':
# pylint: disable=cyclic-import
from bastd.ui.coop.browser import CoopBrowserWindow
ba.app.ui.set_main_menu_window(
CoopBrowserWindow(
transition=None).get_root_widget())
else:
# pylint: disable=cyclic-import
from bastd.ui.mainmenu import MainMenuWindow
ba.app.ui.set_main_menu_window(
MainMenuWindow(transition=None).get_root_widget())
# attempt to show any pending offers immediately.
# If that doesn't work, try again in a few seconds
# (we may not have heard back from the server)
# ..if that doesn't work they'll just have to wait
# until the next opportunity.
if not specialoffer.show_offer():
def try_again() -> None:
if not specialoffer.show_offer():
# Try one last time..
ba.timer(2.0,
specialoffer.show_offer,
timetype=ba.TimeType.REAL)
ba.timer(2.0, try_again, timetype=ba.TimeType.REAL)
ba.app.main_menu_did_initial_transition = True
def _make_logo(self,
x: float,
y: float,
scale: float,
delay: float,
custom_texture: str = None,
jitter_scale: float = 1.0,
rotate: float = 0.0,
vr_depth_offset: float = 0.0) -> None:
# Temp easter goodness.
if custom_texture is None:
custom_texture = self._get_custom_logo_tex_name()
self._custom_logo_tex_name = custom_texture
ltex = ba.gettexture(
custom_texture if custom_texture is not None else 'logo')
mopaque = (None if custom_texture is not None else ba.getmodel('logo'))
mtrans = (None if custom_texture is not None else
ba.getmodel('logoTransparent'))
logo = ba.NodeActor(
ba.newnode('image',
attrs={
'texture': ltex,
'model_opaque': mopaque,
'model_transparent': mtrans,
'vr_depth': -10 + vr_depth_offset,
'rotate': rotate,
'attach': 'center',
'tilt_translate': 0.21,
'absolute_scale': True
}))
self._logo_node = logo.node
self._word_actors.append(logo)
# Add a bit of stop-motion-y jitter to the logo
# (unless we're in VR mode in which case its best to
# leave things still).
assert logo.node
if not ba.app.vr_mode:
cmb = ba.newnode('combine', owner=logo.node, attrs={'size': 2})
cmb.connectattr('output', logo.node, 'position')
keys = {}
time_v = 0.0
# Gen some random keys for that stop-motion-y look
for _i in range(10):
keys[time_v] = x + (random.random() - 0.5) * 0.7 * jitter_scale
time_v += random.random() * 0.1
ba.animate(cmb, 'input0', keys, loop=True)
keys = {}
time_v = 0.0
for _i in range(10):
keys[time_v * self._ts] = y + (random.random() -
0.5) * 0.7 * jitter_scale
time_v += random.random() * 0.1
ba.animate(cmb, 'input1', keys, loop=True)
else:
logo.node.position = (x, y)
cmb = ba.newnode('combine', owner=logo.node, attrs={'size': 2})
keys = {
delay: 0.0,
delay + 0.1: 700.0 * scale,
delay + 0.2: 600.0 * scale
}
ba.animate(cmb, 'input0', keys)
ba.animate(cmb, 'input1', keys)
cmb.connectattr('output', logo.node, 'scale')
def __init__(self,
fade_time: float = 0.5,
start_faded: bool = False,
show_logo: bool = False):
super().__init__()
self._dying = False
self.fade_time = fade_time
# We're special in that we create our node in the session
# scene instead of the activity scene.
# This way we can overlap multiple activities for fades
# and whatnot.
session = ba.getsession()
self._session = weakref.ref(session)
with ba.Context(session):
self.node = ba.newnode('image',
delegate=self,
attrs={
'fill_screen': True,
'texture': ba.gettexture('bg'),
'tilt_translate': -0.3,
'has_alpha_channel': False,
'color': (1, 1, 1)
})
if not start_faded:
ba.animate(self.node,
'opacity', {
0.0: 0.0,
self.fade_time: 1.0
},
loop=False)
if show_logo:
logo_texture = ba.gettexture('logo')
logo_model = ba.getmodel('logo')
logo_model_transparent = ba.getmodel('logoTransparent')
self.logo = ba.newnode('image',
owner=self.node,
attrs={
'texture': logo_texture,
'model_opaque': logo_model,
'model_transparent':
logo_model_transparent,
'scale': (0.7, 0.7),
'vr_depth': -250,
'color': (0.15, 0.15, 0.15),
'position': (0, 0),
'tilt_translate': -0.05,
'absolute_scale': False
})
self.node.connectattr('opacity', self.logo, 'opacity')
# add jitter/pulse for a stop-motion-y look unless we're in VR
# in which case stillness is better
if not ba.app.vr_mode:
self.cmb = ba.newnode('combine',
owner=self.node,
attrs={'size': 2})
for attr in ['input0', 'input1']:
ba.animate(self.cmb,
attr, {
0.0: 0.693,
0.05: 0.7,
0.5: 0.693
},
loop=True)
self.cmb.connectattr('output', self.logo, 'scale')
cmb = ba.newnode('combine',
owner=self.node,
attrs={'size': 2})
cmb.connectattr('output', self.logo, 'position')
# Gen some random keys for that stop-motion-y look.
keys = {}
timeval = 0.0
for _i in range(10):
keys[timeval] = (random.random() - 0.5) * 0.0015
timeval += random.random() * 0.1
ba.animate(cmb, "input0", keys, loop=True)
keys = {}
timeval = 0.0
for _i in range(10):
keys[timeval] = (random.random() - 0.5) * 0.0015 + 0.05
timeval += random.random() * 0.1
ba.animate(cmb, "input1", keys, loop=True)
def _refresh(self) -> None:
# FIXME: Should tidy this up.
# pylint: disable=too-many-statements
# pylint: disable=too-many-branches
# pylint: disable=too-many-locals
# pylint: disable=too-many-nested-blocks
from ba.internal import (get_map_class,
get_default_free_for_all_playlist,
get_default_teams_playlist, filter_playlist)
if not self._root_widget:
return
if self._subcontainer is not None:
self._save_state()
self._subcontainer.delete()
# Make sure config exists.
if self._config_name_full not in ba.app.config:
ba.app.config[self._config_name_full] = {}
items = list(ba.app.config[self._config_name_full].items())
# Make sure everything is unicode.
items = [(i[0].decode(), i[1]) if not isinstance(i[0], str) else i
for i in items]
items.sort(key=lambda x2: x2[0].lower())
items = [['__default__', None]] + items # default is always first
count = len(items)
columns = 3
rows = int(math.ceil(float(count) / columns))
button_width = 230
button_height = 230
button_buffer_h = -3
button_buffer_v = 0
self._sub_width = self._scroll_width
self._sub_height = 40 + rows * (button_height +
2 * button_buffer_v) + 90
assert self._sub_width is not None
assert self._sub_height is not None
self._subcontainer = ba.containerwidget(parent=self._scrollwidget,
size=(self._sub_width,
self._sub_height),
background=False)
children = self._subcontainer.get_children()
for child in children:
child.delete()
ba.textwidget(parent=self._subcontainer,
text=ba.Lstr(resource='playlistsText'),
position=(40, self._sub_height - 26),
size=(0, 0),
scale=1.0,
maxwidth=400,
color=ba.app.ui.title_color,
h_align='left',
v_align='center')
index = 0
appconfig = ba.app.config
model_opaque = ba.getmodel('level_select_button_opaque')
model_transparent = ba.getmodel('level_select_button_transparent')
mask_tex = ba.gettexture('mapPreviewMask')
h_offs = 225 if count == 1 else 115 if count == 2 else 0
h_offs_bottom = 0
uiscale = ba.app.ui.uiscale
for y in range(rows):
for x in range(columns):
name = items[index][0]
assert name is not None
pos = (x * (button_width + 2 * button_buffer_h) +
button_buffer_h + 8 + h_offs, self._sub_height - 47 -
(y + 1) * (button_height + 2 * button_buffer_v))
btn = ba.buttonwidget(parent=self._subcontainer,
button_type='square',
size=(button_width, button_height),
autoselect=True,
label='',
position=pos)
if (x == 0 and ba.app.ui.use_toolbars
and uiscale is ba.UIScale.SMALL):
ba.widget(
edit=btn,
left_widget=_ba.get_special_widget('back_button'))
if (x == columns - 1 and ba.app.ui.use_toolbars
and uiscale is ba.UIScale.SMALL):
ba.widget(
edit=btn,
right_widget=_ba.get_special_widget('party_button'))
ba.buttonwidget(
edit=btn,
on_activate_call=ba.Call(self._on_playlist_press, btn,
name),
on_select_call=ba.Call(self._on_playlist_select, name))
ba.widget(edit=btn, show_buffer_top=50, show_buffer_bottom=50)
if self._selected_playlist == name:
ba.containerwidget(edit=self._subcontainer,
selected_child=btn,
visible_child=btn)
if self._back_button is not None:
if y == 0:
ba.widget(edit=btn, up_widget=self._back_button)
if x == 0:
ba.widget(edit=btn, left_widget=self._back_button)
print_name: Optional[Union[str, ba.Lstr]]
if name == '__default__':
print_name = self._pvars.default_list_name
else:
print_name = name
ba.textwidget(parent=self._subcontainer,
text=print_name,
position=(pos[0] + button_width * 0.5,
pos[1] + button_height * 0.79),
size=(0, 0),
scale=button_width * 0.003,
maxwidth=button_width * 0.7,
draw_controller=btn,
h_align='center',
v_align='center')
# Poke into this playlist and see if we can display some of
# its maps.
map_images = []
try:
map_textures = []
map_texture_entries = []
if name == '__default__':
if self._sessiontype is ba.FreeForAllSession:
playlist = (get_default_free_for_all_playlist())
elif self._sessiontype is ba.DualTeamSession:
playlist = get_default_teams_playlist()
else:
raise Exception('unrecognized session-type: ' +
str(self._sessiontype))
else:
if name not in appconfig[self._pvars.config_name +
' Playlists']:
print(
'NOT FOUND ERR',
appconfig[self._pvars.config_name +
' Playlists'])
playlist = appconfig[self._pvars.config_name +
' Playlists'][name]
playlist = filter_playlist(playlist,
self._sessiontype,
remove_unowned=False,
mark_unowned=True)
for entry in playlist:
mapname = entry['settings']['map']
maptype: Optional[Type[ba.Map]]
try:
maptype = get_map_class(mapname)
except ba.NotFoundError:
maptype = None
if maptype is not None:
tex_name = maptype.get_preview_texture_name()
if tex_name is not None:
map_textures.append(tex_name)
map_texture_entries.append(entry)
if len(map_textures) >= 6:
break
if len(map_textures) > 4:
img_rows = 3
img_columns = 2
scl = 0.33
h_offs_img = 30
v_offs_img = 126
elif len(map_textures) > 2:
img_rows = 2
img_columns = 2
scl = 0.35
h_offs_img = 24
v_offs_img = 110
elif len(map_textures) > 1:
img_rows = 2
img_columns = 1
scl = 0.5
h_offs_img = 47
v_offs_img = 105
else:
img_rows = 1
img_columns = 1
scl = 0.75
h_offs_img = 20
v_offs_img = 65
v = None
for row in range(img_rows):
for col in range(img_columns):
tex_index = row * img_columns + col
if tex_index < len(map_textures):
entry = map_texture_entries[tex_index]
owned = not (('is_unowned_map' in entry
and entry['is_unowned_map']) or
('is_unowned_game' in entry
and entry['is_unowned_game']))
tex_name = map_textures[tex_index]
h = pos[0] + h_offs_img + scl * 250 * col
v = pos[1] + v_offs_img - scl * 130 * row
map_images.append(
ba.imagewidget(
parent=self._subcontainer,
size=(scl * 250.0, scl * 125.0),
position=(h, v),
texture=ba.gettexture(tex_name),
opacity=1.0 if owned else 0.25,
draw_controller=btn,
model_opaque=model_opaque,
model_transparent=model_transparent,
mask_texture=mask_tex))
if not owned:
ba.imagewidget(
parent=self._subcontainer,
size=(scl * 100.0, scl * 100.0),
position=(h + scl * 75, v + scl * 10),
texture=ba.gettexture('lock'),
draw_controller=btn)
if v is not None:
v -= scl * 130.0
except Exception:
ba.print_exception('Error listing playlist maps.')
if not map_images:
ba.textwidget(parent=self._subcontainer,
text='???',
scale=1.5,
size=(0, 0),
color=(1, 1, 1, 0.5),
h_align='center',
v_align='center',
draw_controller=btn,
position=(pos[0] + button_width * 0.5,
pos[1] + button_height * 0.5))
index += 1
if index >= count:
break
if index >= count:
break
self._customize_button = btn = ba.buttonwidget(
parent=self._subcontainer,
size=(100, 30),
position=(34 + h_offs_bottom, 50),
text_scale=0.6,
label=ba.Lstr(resource='customizeText'),
on_activate_call=self._on_customize_press,
color=(0.54, 0.52, 0.67),
textcolor=(0.7, 0.65, 0.7),
autoselect=True)
ba.widget(edit=btn, show_buffer_top=22, show_buffer_bottom=28)
self._restore_state()
def __init__(self,
sessiontype: type[ba.Session],
playlist: str,
scale_origin: tuple[float, float],
delegate: Any = None):
# FIXME: Tidy this up.
# pylint: disable=too-many-branches
# pylint: disable=too-many-statements
# pylint: disable=too-many-locals
from ba.internal import get_map_class, getclass, filter_playlist
from bastd.ui.playlist import PlaylistTypeVars
self._r = 'gameListWindow'
self._delegate = delegate
self._pvars = PlaylistTypeVars(sessiontype)
self._transitioning_out = False
# We behave differently if we're being used for playlist selection
# vs starting a game directly (should make this more elegant).
self._selecting_mode = ba.app.ui.selecting_private_party_playlist
self._do_randomize_val = (ba.app.config.get(
self._pvars.config_name + ' Playlist Randomize', 0))
self._sessiontype = sessiontype
self._playlist = playlist
self._width = 500.0
self._height = 330.0 - 50.0
# In teams games, show the custom names/colors button.
if self._sessiontype is ba.DualTeamSession:
self._height += 50.0
self._row_height = 45.0
# Grab our maps to display.
model_opaque = ba.getmodel('level_select_button_opaque')
model_transparent = ba.getmodel('level_select_button_transparent')
mask_tex = ba.gettexture('mapPreviewMask')
# Poke into this playlist and see if we can display some of its maps.
map_textures = []
map_texture_entries = []
rows = 0
columns = 0
game_count = 0
scl = 0.35
c_width_total = 0.0
try:
max_columns = 5
name = playlist
if name == '__default__':
plst = self._pvars.get_default_list_call()
else:
try:
plst = ba.app.config[self._pvars.config_name +
' Playlists'][name]
except Exception:
print('ERROR INFO: self._config_name is:',
self._pvars.config_name)
print(
'ERROR INFO: playlist names are:',
list(ba.app.config[self._pvars.config_name +
' Playlists'].keys()))
raise
plst = filter_playlist(plst,
self._sessiontype,
remove_unowned=False,
mark_unowned=True)
game_count = len(plst)
for entry in plst:
mapname = entry['settings']['map']
maptype: Optional[type[ba.Map]]
try:
maptype = get_map_class(mapname)
except ba.NotFoundError:
maptype = None
if maptype is not None:
tex_name = maptype.get_preview_texture_name()
if tex_name is not None:
map_textures.append(tex_name)
map_texture_entries.append(entry)
rows = (max(0, len(map_textures) - 1) // max_columns) + 1
columns = min(max_columns, len(map_textures))
if len(map_textures) == 1:
scl = 1.1
elif len(map_textures) == 2:
scl = 0.7
elif len(map_textures) == 3:
scl = 0.55
else:
scl = 0.35
self._row_height = 128.0 * scl
c_width_total = scl * 250.0 * columns
if map_textures:
self._height += self._row_height * rows
except Exception:
ba.print_exception('Error listing playlist maps.')
show_shuffle_check_box = game_count > 1
if show_shuffle_check_box:
self._height += 40
# Creates our _root_widget.
uiscale = ba.app.ui.uiscale
scale = (1.69 if uiscale is ba.UIScale.SMALL else
1.1 if uiscale is ba.UIScale.MEDIUM else 0.85)
super().__init__(position=scale_origin,
size=(self._width, self._height),
scale=scale)
playlist_name: Union[str, ba.Lstr] = (self._pvars.default_list_name
if playlist == '__default__' else
playlist)
self._title_text = ba.textwidget(parent=self.root_widget,
position=(self._width * 0.5,
self._height - 89 + 51),
size=(0, 0),
text=playlist_name,
scale=1.4,
color=(1, 1, 1),
maxwidth=self._width * 0.7,
h_align='center',
v_align='center')
self._cancel_button = ba.buttonwidget(
parent=self.root_widget,
position=(25, self._height - 53),
size=(50, 50),
scale=0.7,
label='',
color=(0.42, 0.73, 0.2),
on_activate_call=self._on_cancel_press,
autoselect=True,
icon=ba.gettexture('crossOut'),
iconscale=1.2)
h_offs_img = self._width * 0.5 - c_width_total * 0.5
v_offs_img = self._height - 118 - scl * 125.0 + 50
bottom_row_buttons = []
self._have_at_least_one_owned = False
for row in range(rows):
for col in range(columns):
tex_index = row * columns + col
if tex_index < len(map_textures):
tex_name = map_textures[tex_index]
h = h_offs_img + scl * 250 * col
v = v_offs_img - self._row_height * row
entry = map_texture_entries[tex_index]
owned = not (('is_unowned_map' in entry
and entry['is_unowned_map']) or
('is_unowned_game' in entry
and entry['is_unowned_game']))
if owned:
self._have_at_least_one_owned = True
try:
desc = getclass(entry['type'],
subclassof=ba.GameActivity
).get_settings_display_string(entry)
if not owned:
desc = ba.Lstr(
value='${DESC}\n${UNLOCK}',
subs=[
('${DESC}', desc),
('${UNLOCK}',
ba.Lstr(
resource='unlockThisInTheStoreText'))
])
desc_color = (0, 1, 0) if owned else (1, 0, 0)
except Exception:
desc = ba.Lstr(value='(invalid)')
desc_color = (1, 0, 0)
btn = ba.buttonwidget(
parent=self.root_widget,
size=(scl * 240.0, scl * 120.0),
position=(h, v),
texture=ba.gettexture(tex_name if owned else 'empty'),
model_opaque=model_opaque if owned else None,
on_activate_call=ba.Call(ba.screenmessage, desc,
desc_color),
label='',
color=(1, 1, 1),
autoselect=True,
extra_touch_border_scale=0.0,
model_transparent=model_transparent if owned else None,
mask_texture=mask_tex if owned else None)
if row == 0 and col == 0:
ba.widget(edit=self._cancel_button, down_widget=btn)
if row == rows - 1:
bottom_row_buttons.append(btn)
if not owned:
# Ewww; buttons don't currently have alpha so in this
# case we draw an image over our button with an empty
# texture on it.
ba.imagewidget(parent=self.root_widget,
size=(scl * 260.0, scl * 130.0),
position=(h - 10.0 * scl,
v - 4.0 * scl),
draw_controller=btn,
color=(1, 1, 1),
texture=ba.gettexture(tex_name),
model_opaque=model_opaque,
opacity=0.25,
model_transparent=model_transparent,
mask_texture=mask_tex)
ba.imagewidget(parent=self.root_widget,
size=(scl * 100, scl * 100),
draw_controller=btn,
position=(h + scl * 70, v + scl * 10),
texture=ba.gettexture('lock'))
# Team names/colors.
self._custom_colors_names_button: Optional[ba.Widget]
if self._sessiontype is ba.DualTeamSession:
y_offs = 50 if show_shuffle_check_box else 0
self._custom_colors_names_button = ba.buttonwidget(
parent=self.root_widget,
position=(100, 200 + y_offs),
size=(290, 35),
on_activate_call=ba.WeakCall(self._custom_colors_names_press),
autoselect=True,
textcolor=(0.8, 0.8, 0.8),
label=ba.Lstr(resource='teamNamesColorText'))
if not ba.app.accounts.have_pro():
ba.imagewidget(
parent=self.root_widget,
size=(30, 30),
position=(95, 202 + y_offs),
texture=ba.gettexture('lock'),
draw_controller=self._custom_colors_names_button)
else:
self._custom_colors_names_button = None
# Shuffle.
def _cb_callback(val: bool) -> None:
self._do_randomize_val = val
cfg = ba.app.config
cfg[self._pvars.config_name +
' Playlist Randomize'] = self._do_randomize_val
cfg.commit()
if show_shuffle_check_box:
self._shuffle_check_box = ba.checkboxwidget(
parent=self.root_widget,
position=(110, 200),
scale=1.0,
size=(250, 30),
autoselect=True,
text=ba.Lstr(resource=self._r + '.shuffleGameOrderText'),
maxwidth=300,
textcolor=(0.8, 0.8, 0.8),
value=self._do_randomize_val,
on_value_change_call=_cb_callback)
# Show tutorial.
show_tutorial = bool(ba.app.config.get('Show Tutorial', True))
def _cb_callback_2(val: bool) -> None:
cfg = ba.app.config
cfg['Show Tutorial'] = val
cfg.commit()
self._show_tutorial_check_box = ba.checkboxwidget(
parent=self.root_widget,
position=(110, 151),
scale=1.0,
size=(250, 30),
autoselect=True,
text=ba.Lstr(resource=self._r + '.showTutorialText'),
maxwidth=300,
textcolor=(0.8, 0.8, 0.8),
value=show_tutorial,
on_value_change_call=_cb_callback_2)
# Grumble: current autoselect doesn't do a very good job
# with checkboxes.
if self._custom_colors_names_button is not None:
for btn in bottom_row_buttons:
ba.widget(edit=btn,
down_widget=self._custom_colors_names_button)
if show_shuffle_check_box:
ba.widget(edit=self._custom_colors_names_button,
down_widget=self._shuffle_check_box)
ba.widget(edit=self._shuffle_check_box,
up_widget=self._custom_colors_names_button)
else:
ba.widget(edit=self._custom_colors_names_button,
down_widget=self._show_tutorial_check_box)
ba.widget(edit=self._show_tutorial_check_box,
up_widget=self._custom_colors_names_button)
self._ok_button = ba.buttonwidget(
parent=self.root_widget,
position=(70, 44),
size=(200, 45),
scale=1.8,
text_res_scale=1.5,
on_activate_call=self._on_ok_press,
autoselect=True,
label=ba.Lstr(
resource='okText' if self._selecting_mode else 'playText'))
ba.widget(edit=self._ok_button,
up_widget=self._show_tutorial_check_box)
ba.containerwidget(edit=self.root_widget,
start_button=self._ok_button,
cancel_button=self._cancel_button,
selected_child=self._ok_button)
# Update now and once per second.
self._update_timer = ba.Timer(1.0,
ba.WeakCall(self._update),
timetype=ba.TimeType.REAL,
repeat=True)
self._update()
def __init__(self,
gametype: type[ba.GameActivity],
sessiontype: type[ba.Session],
config: Optional[dict[str, Any]],
completion_call: Callable[[Optional[dict[str, Any]]], Any],
default_selection: str = None,
transition: str = 'in_right',
edit_info: dict[str, Any] = None):
# pylint: disable=too-many-branches
# pylint: disable=too-many-statements
# pylint: disable=too-many-locals
from ba.internal import (get_unowned_maps, get_filtered_map_name,
get_map_class, get_map_display_string)
self._gametype = gametype
self._sessiontype = sessiontype
# If we're within an editing session we get passed edit_info
# (returning from map selection window, etc).
if edit_info is not None:
self._edit_info = edit_info
# ..otherwise determine whether we're adding or editing a game based
# on whether an existing config was passed to us.
else:
if config is None:
self._edit_info = {'editType': 'add'}
else:
self._edit_info = {'editType': 'edit'}
self._r = 'gameSettingsWindow'
valid_maps = gametype.get_supported_maps(sessiontype)
if not valid_maps:
ba.screenmessage(ba.Lstr(resource='noValidMapsErrorText'))
raise Exception('No valid maps')
self._settings_defs = gametype.get_available_settings(sessiontype)
self._completion_call = completion_call
# To start with, pick a random map out of the ones we own.
unowned_maps = get_unowned_maps()
valid_maps_owned = [m for m in valid_maps if m not in unowned_maps]
if valid_maps_owned:
self._map = valid_maps[random.randrange(len(valid_maps_owned))]
# Hmmm.. we own none of these maps.. just pick a random un-owned one
# I guess.. should this ever happen?
else:
self._map = valid_maps[random.randrange(len(valid_maps))]
is_add = (self._edit_info['editType'] == 'add')
# If there's a valid map name in the existing config, use that.
try:
if (config is not None and 'settings' in config
and 'map' in config['settings']):
filtered_map_name = get_filtered_map_name(
config['settings']['map'])
if filtered_map_name in valid_maps:
self._map = filtered_map_name
except Exception:
ba.print_exception('Error getting map for editor.')
if config is not None and 'settings' in config:
self._settings = config['settings']
else:
self._settings = {}
self._choice_selections: dict[str, int] = {}
uiscale = ba.app.ui.uiscale
width = 720 if uiscale is ba.UIScale.SMALL else 620
x_inset = 50 if uiscale is ba.UIScale.SMALL else 0
height = (365 if uiscale is ba.UIScale.SMALL else
460 if uiscale is ba.UIScale.MEDIUM else 550)
spacing = 52
y_extra = 15
y_extra2 = 21
map_tex_name = (get_map_class(self._map).get_preview_texture_name())
if map_tex_name is None:
raise Exception('no map preview tex found for' + self._map)
map_tex = ba.gettexture(map_tex_name)
top_extra = 20 if uiscale is ba.UIScale.SMALL else 0
super().__init__(root_widget=ba.containerwidget(
size=(width, height + top_extra),
transition=transition,
scale=(2.19 if uiscale is ba.UIScale.SMALL else
1.35 if uiscale is ba.UIScale.MEDIUM else 1.0),
stack_offset=(0, -17) if uiscale is ba.UIScale.SMALL else (0, 0)))
btn = ba.buttonwidget(
parent=self._root_widget,
position=(45 + x_inset, height - 82 + y_extra2),
size=(180, 70) if is_add else (180, 65),
label=ba.Lstr(resource='backText') if is_add else ba.Lstr(
resource='cancelText'),
button_type='back' if is_add else None,
autoselect=True,
scale=0.75,
text_scale=1.3,
on_activate_call=ba.Call(self._cancel))
ba.containerwidget(edit=self._root_widget, cancel_button=btn)
add_button = ba.buttonwidget(
parent=self._root_widget,
position=(width - (193 + x_inset), height - 82 + y_extra2),
size=(200, 65),
scale=0.75,
text_scale=1.3,
label=ba.Lstr(resource=self._r +
'.addGameText') if is_add else ba.Lstr(
resource='doneText'))
if ba.app.ui.use_toolbars:
pbtn = _ba.get_special_widget('party_button')
ba.widget(edit=add_button, right_widget=pbtn, up_widget=pbtn)
ba.textwidget(parent=self._root_widget,
position=(-8, height - 70 + y_extra2),
size=(width, 25),
text=gametype.get_display_string(),
color=ba.app.ui.title_color,
maxwidth=235,
scale=1.1,
h_align='center',
v_align='center')
map_height = 100
scroll_height = map_height + 10 # map select and margin
# Calc our total height we'll need
scroll_height += spacing * len(self._settings_defs)
scroll_width = width - (86 + 2 * x_inset)
self._scrollwidget = ba.scrollwidget(parent=self._root_widget,
position=(44 + x_inset,
35 + y_extra),
size=(scroll_width, height - 116),
highlight=False,
claims_left_right=True,
claims_tab=True,
selection_loops_to_parent=True)
self._subcontainer = ba.containerwidget(parent=self._scrollwidget,
size=(scroll_width,
scroll_height),
background=False,
claims_left_right=True,
claims_tab=True,
selection_loops_to_parent=True)
v = scroll_height - 5
h = -40
# Keep track of all the selectable widgets we make so we can wire
# them up conveniently.
widget_column: list[list[ba.Widget]] = []
# Map select button.
ba.textwidget(parent=self._subcontainer,
position=(h + 49, v - 63),
size=(100, 30),
maxwidth=110,
text=ba.Lstr(resource='mapText'),
h_align='left',
color=(0.8, 0.8, 0.8, 1.0),
v_align='center')
ba.imagewidget(
parent=self._subcontainer,
size=(256 * 0.7, 125 * 0.7),
position=(h + 261 - 128 + 128.0 * 0.56, v - 90),
texture=map_tex,
model_opaque=ba.getmodel('level_select_button_opaque'),
model_transparent=ba.getmodel('level_select_button_transparent'),
mask_texture=ba.gettexture('mapPreviewMask'))
map_button = btn = ba.buttonwidget(
parent=self._subcontainer,
size=(140, 60),
position=(h + 448, v - 72),
on_activate_call=ba.Call(self._select_map),
scale=0.7,
label=ba.Lstr(resource='mapSelectText'))
widget_column.append([btn])
ba.textwidget(parent=self._subcontainer,
position=(h + 363 - 123, v - 114),
size=(100, 30),
flatness=1.0,
shadow=1.0,
scale=0.55,
maxwidth=256 * 0.7 * 0.8,
text=get_map_display_string(self._map),
h_align='center',
color=(0.6, 1.0, 0.6, 1.0),
v_align='center')
v -= map_height
for setting in self._settings_defs:
value = setting.default
value_type = type(value)
# Now, if there's an existing value for it in the config,
# override with that.
try:
if (config is not None and 'settings' in config
and setting.name in config['settings']):
value = value_type(config['settings'][setting.name])
except Exception:
ba.print_exception()
# Shove the starting value in there to start.
self._settings[setting.name] = value
name_translated = self._get_localized_setting_name(setting.name)
mw1 = 280
mw2 = 70
# Handle types with choices specially:
if isinstance(setting, ba.ChoiceSetting):
for choice in setting.choices:
if len(choice) != 2:
raise ValueError(
"Expected 2-member tuples for 'choices'; got: " +
repr(choice))
if not isinstance(choice[0], str):
raise TypeError(
'First value for choice tuple must be a str; got: '
+ repr(choice))
if not isinstance(choice[1], value_type):
raise TypeError(
'Choice type does not match default value; choice:'
+ repr(choice) + '; setting:' + repr(setting))
if value_type not in (int, float):
raise TypeError(
'Choice type setting must have int or float default; '
'got: ' + repr(setting))
# Start at the choice corresponding to the default if possible.
self._choice_selections[setting.name] = 0
for index, choice in enumerate(setting.choices):
if choice[1] == value:
self._choice_selections[setting.name] = index
break
v -= spacing
ba.textwidget(parent=self._subcontainer,
position=(h + 50, v),
size=(100, 30),
maxwidth=mw1,
text=name_translated,
h_align='left',
color=(0.8, 0.8, 0.8, 1.0),
v_align='center')
txt = ba.textwidget(
parent=self._subcontainer,
position=(h + 509 - 95, v),
size=(0, 28),
text=self._get_localized_setting_name(setting.choices[
self._choice_selections[setting.name]][0]),
editable=False,
color=(0.6, 1.0, 0.6, 1.0),
maxwidth=mw2,
h_align='right',
v_align='center',
padding=2)
btn1 = ba.buttonwidget(parent=self._subcontainer,
position=(h + 509 - 50 - 1, v),
size=(28, 28),
label='<',
autoselect=True,
on_activate_call=ba.Call(
self._choice_inc, setting.name, txt,
setting, -1),
repeat=True)
btn2 = ba.buttonwidget(parent=self._subcontainer,
position=(h + 509 + 5, v),
size=(28, 28),
label='>',
autoselect=True,
on_activate_call=ba.Call(
self._choice_inc, setting.name, txt,
setting, 1),
repeat=True)
widget_column.append([btn1, btn2])
elif isinstance(setting, (ba.IntSetting, ba.FloatSetting)):
v -= spacing
min_value = setting.min_value
max_value = setting.max_value
increment = setting.increment
ba.textwidget(parent=self._subcontainer,
position=(h + 50, v),
size=(100, 30),
text=name_translated,
h_align='left',
color=(0.8, 0.8, 0.8, 1.0),
v_align='center',
maxwidth=mw1)
txt = ba.textwidget(parent=self._subcontainer,
position=(h + 509 - 95, v),
size=(0, 28),
text=str(value),
editable=False,
color=(0.6, 1.0, 0.6, 1.0),
maxwidth=mw2,
h_align='right',
v_align='center',
padding=2)
btn1 = ba.buttonwidget(parent=self._subcontainer,
position=(h + 509 - 50 - 1, v),
size=(28, 28),
label='-',
autoselect=True,
on_activate_call=ba.Call(
self._inc, txt, min_value,
max_value, -increment, value_type,
setting.name),
repeat=True)
btn2 = ba.buttonwidget(parent=self._subcontainer,
position=(h + 509 + 5, v),
size=(28, 28),
label='+',
autoselect=True,
on_activate_call=ba.Call(
self._inc, txt, min_value,
max_value, increment, value_type,
setting.name),
repeat=True)
widget_column.append([btn1, btn2])
elif value_type == bool:
v -= spacing
ba.textwidget(parent=self._subcontainer,
position=(h + 50, v),
size=(100, 30),
text=name_translated,
h_align='left',
color=(0.8, 0.8, 0.8, 1.0),
v_align='center',
maxwidth=mw1)
txt = ba.textwidget(
parent=self._subcontainer,
position=(h + 509 - 95, v),
size=(0, 28),
text=ba.Lstr(resource='onText') if value else ba.Lstr(
resource='offText'),
editable=False,
color=(0.6, 1.0, 0.6, 1.0),
maxwidth=mw2,
h_align='right',
v_align='center',
padding=2)
cbw = ba.checkboxwidget(parent=self._subcontainer,
text='',
position=(h + 505 - 50 - 5, v - 2),
size=(200, 30),
autoselect=True,
textcolor=(0.8, 0.8, 0.8),
value=value,
on_value_change_call=ba.Call(
self._check_value_change,
setting.name, txt))
widget_column.append([cbw])
else:
raise Exception()
# Ok now wire up the column.
try:
# pylint: disable=unsubscriptable-object
prev_widgets: Optional[list[ba.Widget]] = None
for cwdg in widget_column:
if prev_widgets is not None:
# Wire our rightmost to their rightmost.
ba.widget(edit=prev_widgets[-1], down_widget=cwdg[-1])
ba.widget(cwdg[-1], up_widget=prev_widgets[-1])
# Wire our leftmost to their leftmost.
ba.widget(edit=prev_widgets[0], down_widget=cwdg[0])
ba.widget(cwdg[0], up_widget=prev_widgets[0])
prev_widgets = cwdg
except Exception:
ba.print_exception(
'Error wiring up game-settings-select widget column.')
ba.buttonwidget(edit=add_button, on_activate_call=ba.Call(self._add))
ba.containerwidget(edit=self._root_widget,
selected_child=add_button,
start_button=add_button)
if default_selection == 'map':
ba.containerwidget(edit=self._root_widget,
selected_child=self._scrollwidget)
ba.containerwidget(edit=self._subcontainer,
selected_child=map_button)
def __init__(self, queue_id: str, address: str, port: int):
ba.app.ui.have_party_queue_window = True
self._address = address
self._port = port
self._queue_id = queue_id
self._width = 800
self._height = 400
self._last_connect_attempt_time: Optional[float] = None
self._last_transaction_time: Optional[float] = None
self._boost_button: Optional[ba.Widget] = None
self._boost_price: Optional[ba.Widget] = None
self._boost_label: Optional[ba.Widget] = None
self._field_shown = False
self._dudes: List[PartyQueueWindow.Dude] = []
self._dudes_by_id: Dict[int, PartyQueueWindow.Dude] = {}
self._line_left = 40.0
self._line_width = self._width - 190
self._line_bottom = self._height * 0.4
self.lineup_tex = ba.gettexture('playerLineup')
self._smoothing = 0.0
self._initial_offset = 0.0
self._boost_tickets = 0
self._boost_strength = 0.0
self._angry_computer_transparent_model = ba.getmodel(
'angryComputerTransparent')
self._angry_computer_image: Optional[ba.Widget] = None
self.lineup_1_transparent_model = ba.getmodel(
'playerLineup1Transparent')
self._lineup_2_transparent_model = ba.getmodel(
'playerLineup2Transparent')
self._lineup_3_transparent_model = ba.getmodel(
'playerLineup3Transparent')
self._lineup_4_transparent_model = ba.getmodel(
'playerLineup4Transparent')
self._line_image: Optional[ba.Widget] = None
self.eyes_model = ba.getmodel('plasticEyesTransparent')
self._white_tex = ba.gettexture('white')
uiscale = ba.app.ui.uiscale
super().__init__(root_widget=ba.containerwidget(
size=(self._width, self._height),
color=(0.45, 0.63, 0.15),
transition='in_scale',
scale=(1.4 if uiscale is ba.UIScale.SMALL else
1.2 if uiscale is ba.UIScale.MEDIUM else 1.0)))
self._cancel_button = ba.buttonwidget(parent=self._root_widget,
scale=1.0,
position=(60, self._height - 80),
size=(50, 50),
label='',
on_activate_call=self.close,
autoselect=True,
color=(0.45, 0.63, 0.15),
icon=ba.gettexture('crossOut'),
iconscale=1.2)
ba.containerwidget(edit=self._root_widget,
cancel_button=self._cancel_button)
self._title_text = ba.textwidget(
parent=self._root_widget,
position=(self._width * 0.5, self._height * 0.55),
size=(0, 0),
color=(1.0, 3.0, 1.0),
scale=1.3,
h_align='center',
v_align='center',
text=ba.Lstr(resource='internal.connectingToPartyText'),
maxwidth=self._width * 0.65)
self._tickets_text = ba.textwidget(parent=self._root_widget,
position=(self._width - 180,
self._height - 20),
size=(0, 0),
color=(0.2, 1.0, 0.2),
scale=0.7,
h_align='center',
v_align='center',
text='')
# update at roughly 30fps
self._update_timer = ba.Timer(0.033,
ba.WeakCall(self.update),
repeat=True,
timetype=ba.TimeType.REAL)
self.update()
def __init__(self,
transition: str = 'in_right',
origin_widget: ba.Widget = None):
# pylint: disable=too-many-statements
# pylint: disable=too-many-locals
import threading
# Preload some modules we use in a background thread so we won't
# have a visual hitch when the user taps them.
threading.Thread(target=self._preload_modules).start()
# We can currently be used either for main menu duty or for selecting
# playlists (should make this more elegant/general).
self._is_main_menu = not ba.app.ui.selecting_private_party_playlist
uiscale = ba.app.ui.uiscale
width = 1000 if uiscale is ba.UIScale.SMALL else 800
x_offs = 100 if uiscale is ba.UIScale.SMALL else 0
height = 550
button_width = 400
scale_origin: Optional[Tuple[float, float]]
if origin_widget is not None:
self._transition_out = 'out_scale'
scale_origin = origin_widget.get_screen_space_center()
transition = 'in_scale'
else:
self._transition_out = 'out_right'
scale_origin = None
self._r = 'playWindow'
super().__init__(root_widget=ba.containerwidget(
size=(width, height),
transition=transition,
toolbar_visibility='menu_full',
scale_origin_stack_offset=scale_origin,
scale=(1.6 if uiscale is ba.UIScale.SMALL else
0.9 if uiscale is ba.UIScale.MEDIUM else 0.8),
stack_offset=(0, 0) if uiscale is ba.UIScale.SMALL else (0, 0)))
self._back_button = back_button = btn = ba.buttonwidget(
parent=self._root_widget,
position=(55 + x_offs, height - 132),
size=(120, 60),
scale=1.1,
text_res_scale=1.5,
text_scale=1.2,
autoselect=True,
label=ba.Lstr(resource='backText'),
button_type='back')
txt = ba.textwidget(
parent=self._root_widget,
position=(width * 0.5, height - 101),
# position=(width * 0.5, height -
# (101 if main_menu else 61)),
size=(0, 0),
text=ba.Lstr(resource=(
self._r +
'.titleText') if self._is_main_menu else 'playlistsText'),
scale=1.7,
res_scale=2.0,
maxwidth=400,
color=ba.app.ui.heading_color,
h_align='center',
v_align='center')
ba.buttonwidget(edit=btn,
button_type='backSmall',
size=(60, 60),
label=ba.charstr(ba.SpecialChar.BACK))
if ba.app.ui.use_toolbars and uiscale is ba.UIScale.SMALL:
ba.textwidget(edit=txt, text='')
v = height - (110 if self._is_main_menu else 90)
v -= 100
clr = (0.6, 0.7, 0.6, 1.0)
v -= 280 if self._is_main_menu else 180
v += (30
if ba.app.ui.use_toolbars and uiscale is ba.UIScale.SMALL else 0)
hoffs = x_offs + 80 if self._is_main_menu else x_offs - 100
scl = 1.13 if self._is_main_menu else 0.68
self._lineup_tex = ba.gettexture('playerLineup')
angry_computer_transparent_model = ba.getmodel(
'angryComputerTransparent')
self._lineup_1_transparent_model = ba.getmodel(
'playerLineup1Transparent')
self._lineup_2_transparent_model = ba.getmodel(
'playerLineup2Transparent')
self._lineup_3_transparent_model = ba.getmodel(
'playerLineup3Transparent')
self._lineup_4_transparent_model = ba.getmodel(
'playerLineup4Transparent')
self._eyes_model = ba.getmodel('plasticEyesTransparent')
self._coop_button: Optional[ba.Widget] = None
# Only show coop button in main-menu variant.
if self._is_main_menu:
self._coop_button = btn = ba.buttonwidget(
parent=self._root_widget,
position=(hoffs, v + (scl * 15 if self._is_main_menu else 0)),
size=(scl * button_width,
scl * (300 if self._is_main_menu else 360)),
extra_touch_border_scale=0.1,
autoselect=True,
label='',
button_type='square',
text_scale=1.13,
on_activate_call=self._coop)
if ba.app.ui.use_toolbars and uiscale is ba.UIScale.SMALL:
ba.widget(edit=btn,
left_widget=_ba.get_special_widget('back_button'))
ba.widget(edit=btn,
up_widget=_ba.get_special_widget('account_button'))
ba.widget(
edit=btn,
down_widget=_ba.get_special_widget('settings_button'))
self._draw_dude(0,
btn,
hoffs,
v,
scl,
position=(140, 30),
color=(0.72, 0.4, 1.0))
self._draw_dude(1,
btn,
hoffs,
v,
scl,
position=(185, 53),
color=(0.71, 0.5, 1.0))
self._draw_dude(2,
btn,
hoffs,
v,
scl,
position=(220, 27),
color=(0.67, 0.44, 1.0))
self._draw_dude(3,
btn,
hoffs,
v,
scl,
position=(255, 57),
color=(0.7, 0.3, 1.0))
ba.imagewidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * 230, v + scl * 153),
size=(scl * 115, scl * 115),
texture=self._lineup_tex,
model_transparent=angry_computer_transparent_model)
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * (-10), v + scl * 95),
size=(scl * button_width, scl * 50),
text=ba.Lstr(
resource='playModes.singlePlayerCoopText',
fallback_resource='playModes.coopText'),
maxwidth=scl * button_width * 0.7,
res_scale=1.5,
h_align='center',
v_align='center',
color=(0.7, 0.9, 0.7, 1.0),
scale=scl * 2.3)
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * (-10), v + (scl * 54)),
size=(scl * button_width, scl * 30),
text=ba.Lstr(resource=self._r +
'.oneToFourPlayersText'),
h_align='center',
v_align='center',
scale=0.83 * scl,
flatness=1.0,
maxwidth=scl * button_width * 0.7,
color=clr)
scl = 0.5 if self._is_main_menu else 0.68
hoffs += 440 if self._is_main_menu else 216
v += 180 if self._is_main_menu else -68
self._teams_button = btn = ba.buttonwidget(
parent=self._root_widget,
position=(hoffs, v + (scl * 15 if self._is_main_menu else 0)),
size=(scl * button_width,
scl * (300 if self._is_main_menu else 360)),
extra_touch_border_scale=0.1,
autoselect=True,
label='',
button_type='square',
text_scale=1.13,
on_activate_call=self._team_tourney)
if ba.app.ui.use_toolbars:
ba.widget(edit=btn,
up_widget=_ba.get_special_widget('tickets_plus_button'),
right_widget=_ba.get_special_widget('party_button'))
xxx = -14
self._draw_dude(2,
btn,
hoffs,
v,
scl,
position=(xxx + 148, 30),
color=(0.2, 0.4, 1.0))
self._draw_dude(3,
btn,
hoffs,
v,
scl,
position=(xxx + 181, 53),
color=(0.3, 0.4, 1.0))
self._draw_dude(1,
btn,
hoffs,
v,
scl,
position=(xxx + 216, 33),
color=(0.3, 0.5, 1.0))
self._draw_dude(0,
btn,
hoffs,
v,
scl,
position=(xxx + 245, 57),
color=(0.3, 0.5, 1.0))
xxx = 155
self._draw_dude(0,
btn,
hoffs,
v,
scl,
position=(xxx + 151, 30),
color=(1.0, 0.5, 0.4))
self._draw_dude(1,
btn,
hoffs,
v,
scl,
position=(xxx + 189, 53),
color=(1.0, 0.58, 0.58))
self._draw_dude(3,
btn,
hoffs,
v,
scl,
position=(xxx + 223, 27),
color=(1.0, 0.5, 0.5))
self._draw_dude(2,
btn,
hoffs,
v,
scl,
position=(xxx + 257, 57),
color=(1.0, 0.5, 0.5))
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * (-10), v + scl * 95),
size=(scl * button_width, scl * 50),
text=ba.Lstr(resource='playModes.teamsText',
fallback_resource='teamsText'),
res_scale=1.5,
maxwidth=scl * button_width * 0.7,
h_align='center',
v_align='center',
color=(0.7, 0.9, 0.7, 1.0),
scale=scl * 2.3)
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * (-10), v + (scl * 54)),
size=(scl * button_width, scl * 30),
text=ba.Lstr(resource=self._r +
'.twoToEightPlayersText'),
h_align='center',
v_align='center',
res_scale=1.5,
scale=0.9 * scl,
flatness=1.0,
maxwidth=scl * button_width * 0.7,
color=clr)
hoffs += 0 if self._is_main_menu else 300
v -= 155 if self._is_main_menu else 0
self._free_for_all_button = btn = ba.buttonwidget(
parent=self._root_widget,
position=(hoffs, v + (scl * 15 if self._is_main_menu else 0)),
size=(scl * button_width,
scl * (300 if self._is_main_menu else 360)),
extra_touch_border_scale=0.1,
autoselect=True,
label='',
button_type='square',
text_scale=1.13,
on_activate_call=self._free_for_all)
xxx = -5
self._draw_dude(0,
btn,
hoffs,
v,
scl,
position=(xxx + 140, 30),
color=(0.4, 1.0, 0.4))
self._draw_dude(3,
btn,
hoffs,
v,
scl,
position=(xxx + 185, 53),
color=(1.0, 0.4, 0.5))
self._draw_dude(1,
btn,
hoffs,
v,
scl,
position=(xxx + 220, 27),
color=(0.4, 0.5, 1.0))
self._draw_dude(2,
btn,
hoffs,
v,
scl,
position=(xxx + 255, 57),
color=(0.5, 1.0, 0.4))
xxx = 140
self._draw_dude(2,
btn,
hoffs,
v,
scl,
position=(xxx + 148, 30),
color=(1.0, 0.9, 0.4))
self._draw_dude(0,
btn,
hoffs,
v,
scl,
position=(xxx + 182, 53),
color=(0.7, 1.0, 0.5))
self._draw_dude(3,
btn,
hoffs,
v,
scl,
position=(xxx + 233, 27),
color=(0.7, 0.5, 0.9))
self._draw_dude(1,
btn,
hoffs,
v,
scl,
position=(xxx + 266, 53),
color=(0.4, 0.5, 0.8))
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * (-10), v + scl * 95),
size=(scl * button_width, scl * 50),
text=ba.Lstr(resource='playModes.freeForAllText',
fallback_resource='freeForAllText'),
maxwidth=scl * button_width * 0.7,
h_align='center',
v_align='center',
color=(0.7, 0.9, 0.7, 1.0),
scale=scl * 1.9)
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * (-10), v + (scl * 54)),
size=(scl * button_width, scl * 30),
text=ba.Lstr(resource=self._r +
'.twoToEightPlayersText'),
h_align='center',
v_align='center',
scale=0.9 * scl,
flatness=1.0,
maxwidth=scl * button_width * 0.7,
color=clr)
if ba.app.ui.use_toolbars and uiscale is ba.UIScale.SMALL:
back_button.delete()
ba.containerwidget(edit=self._root_widget,
on_cancel_call=self._back,
selected_child=self._coop_button
if self._is_main_menu else self._teams_button)
else:
ba.buttonwidget(edit=back_button, on_activate_call=self._back)
ba.containerwidget(edit=self._root_widget,
cancel_button=back_button,
selected_child=self._coop_button
if self._is_main_menu else self._teams_button)
self._restore_state()
def __init__(self, scoreboard: Scoreboard, team: ba.Team, do_cover: bool,
scale: float, label: Optional[ba.Lstr], flash_length: float):
# pylint: disable=too-many-statements
self._scoreboard = weakref.ref(scoreboard)
self._do_cover = do_cover
self._scale = scale
self._flash_length = flash_length
self._width = 140.0 * self._scale
self._height = 32.0 * self._scale
self._bar_width = 2.0 * self._scale
self._bar_height = 32.0 * self._scale
self._bar_tex = self._backing_tex = ba.gettexture('bar')
self._cover_tex = ba.gettexture('uiAtlas')
self._model = ba.getmodel('meterTransparent')
self._pos: Optional[Sequence[float]] = None
self._flash_timer: Optional[ba.Timer] = None
self._flash_counter: Optional[int] = None
self._flash_colors: Optional[bool] = None
self._score: Optional[float] = None
safe_team_color = ba.safecolor(team.color, target_intensity=1.0)
# FIXME: Should not do things conditionally for vr-mode, as there may
# be non-vr clients connected which will also get these value.
vrmode = ba.app.vr_mode
if self._do_cover:
if vrmode:
self._backing_color = [0.1 + c * 0.1 for c in safe_team_color]
else:
self._backing_color = [
0.05 + c * 0.17 for c in safe_team_color
]
else:
self._backing_color = [0.05 + c * 0.1 for c in safe_team_color]
opacity = (0.8 if vrmode else 0.8) if self._do_cover else 0.5
self._backing = ba.NodeActor(
ba.newnode('image',
attrs={
'scale': (self._width, self._height),
'opacity': opacity,
'color': self._backing_color,
'vr_depth': -3,
'attach': 'topLeft',
'texture': self._backing_tex
}))
self._barcolor = safe_team_color
self._bar = ba.NodeActor(
ba.newnode('image',
attrs={
'opacity': 0.7,
'color': self._barcolor,
'attach': 'topLeft',
'texture': self._bar_tex
}))
self._bar_scale = ba.newnode('combine',
owner=self._bar.node,
attrs={
'size': 2,
'input0': self._bar_width,
'input1': self._bar_height
})
assert self._bar.node
self._bar_scale.connectattr('output', self._bar.node, 'scale')
self._bar_position = ba.newnode('combine',
owner=self._bar.node,
attrs={
'size': 2,
'input0': 0,
'input1': 0
})
self._bar_position.connectattr('output', self._bar.node, 'position')
self._cover_color = safe_team_color
if self._do_cover:
self._cover = ba.NodeActor(
ba.newnode('image',
attrs={
'scale':
(self._width * 1.15, self._height * 1.6),
'opacity': 1.0,
'color': self._cover_color,
'vr_depth': 2,
'attach': 'topLeft',
'texture': self._cover_tex,
'model_transparent': self._model
}))
clr = safe_team_color
maxwidth = 130.0 * (1.0 - scoreboard.score_split)
flatness = ((1.0 if vrmode else 0.5) if self._do_cover else 1.0)
self._score_text = ba.NodeActor(
ba.newnode('text',
attrs={
'h_attach': 'left',
'v_attach': 'top',
'h_align': 'right',
'v_align': 'center',
'maxwidth': maxwidth,
'vr_depth': 2,
'scale': self._scale * 0.9,
'text': '',
'shadow': 1.0 if vrmode else 0.5,
'flatness': flatness,
'color': clr
}))
clr = safe_team_color
team_name_label: Union[str, ba.Lstr]
if label is not None:
team_name_label = label
else:
team_name_label = team.name
# We do our own clipping here; should probably try to tap into some
# existing functionality.
if isinstance(team_name_label, ba.Lstr):
# Hmmm; if the team-name is a non-translatable value lets go
# ahead and clip it otherwise we leave it as-is so
# translation can occur..
if team_name_label.is_flat_value():
val = team_name_label.evaluate()
if len(val) > 10:
team_name_label = ba.Lstr(value=val[:10] + '...')
else:
if len(team_name_label) > 10:
team_name_label = team_name_label[:10] + '...'
team_name_label = ba.Lstr(value=team_name_label)
flatness = ((1.0 if vrmode else 0.5) if self._do_cover else 1.0)
self._name_text = ba.NodeActor(
ba.newnode('text',
attrs={
'h_attach': 'left',
'v_attach': 'top',
'h_align': 'left',
'v_align': 'center',
'vr_depth': 2,
'scale': self._scale * 0.9,
'shadow': 1.0 if vrmode else 0.5,
'flatness': flatness,
'maxwidth': 130 * scoreboard.score_split,
'text': team_name_label,
'color': clr + (1.0, )
}))
def __init__(self) -> None:
"""Instantiate a BombFactory.
You shouldn't need to do this; call bastd.actor.bomb.get_factory()
to get a shared instance.
"""
shared = SharedObjects.get()
self.bomb_model = ba.getmodel('bomb')
self.sticky_bomb_model = ba.getmodel('bombSticky')
self.impact_bomb_model = ba.getmodel('impactBomb')
self.land_mine_model = ba.getmodel('landMine')
self.tnt_model = ba.getmodel('tnt')
self.regular_tex = ba.gettexture('bombColor')
self.ice_tex = ba.gettexture('bombColorIce')
self.sticky_tex = ba.gettexture('bombStickyColor')
self.impact_tex = ba.gettexture('impactBombColor')
self.impact_lit_tex = ba.gettexture('impactBombColorLit')
self.land_mine_tex = ba.gettexture('landMine')
self.land_mine_lit_tex = ba.gettexture('landMineLit')
self.tnt_tex = ba.gettexture('tnt')
self.hiss_sound = ba.getsound('hiss')
self.debris_fall_sound = ba.getsound('debrisFall')
self.wood_debris_fall_sound = ba.getsound('woodDebrisFall')
self.explode_sounds = (ba.getsound('explosion01'),
ba.getsound('explosion02'),
ba.getsound('explosion03'),
ba.getsound('explosion04'),
ba.getsound('explosion05'))
self.freeze_sound = ba.getsound('freeze')
self.fuse_sound = ba.getsound('fuse01')
self.activate_sound = ba.getsound('activateBeep')
self.warn_sound = ba.getsound('warnBeep')
# Set up our material so new bombs don't collide with objects
# that they are initially overlapping.
self.bomb_material = ba.Material()
self.normal_sound_material = ba.Material()
self.sticky_material = ba.Material()
self.bomb_material.add_actions(
conditions=(
(
('we_are_younger_than', 100),
'or',
('they_are_younger_than', 100),
),
'and',
('they_have_material', shared.object_material),
),
actions=('modify_node_collision', 'collide', False),
)
# We want pickup materials to always hit us even if we're currently
# not colliding with their node. (generally due to the above rule)
self.bomb_material.add_actions(
conditions=('they_have_material', shared.pickup_material),
actions=('modify_part_collision', 'use_node_collide', False),
)
self.bomb_material.add_actions(actions=('modify_part_collision',
'friction', 0.3))
self.land_mine_no_explode_material = ba.Material()
self.land_mine_blast_material = ba.Material()
self.land_mine_blast_material.add_actions(
conditions=(
('we_are_older_than', 200),
'and',
('they_are_older_than', 200),
'and',
('eval_colliding', ),
'and',
(
('they_dont_have_material',
self.land_mine_no_explode_material),
'and',
(
('they_have_material', shared.object_material),
'or',
('they_have_material', shared.player_material),
),
),
),
actions=('message', 'our_node', 'at_connect', ImpactMessage()),
)
self.impact_blast_material = ba.Material()
self.impact_blast_material.add_actions(
conditions=(
('we_are_older_than', 200),
'and',
('they_are_older_than', 200),
'and',
('eval_colliding', ),
'and',
(
('they_have_material', shared.footing_material),
'or',
('they_have_material', shared.object_material),
),
),
actions=('message', 'our_node', 'at_connect', ImpactMessage()),
)
self.blast_material = ba.Material()
self.blast_material.add_actions(
conditions=('they_have_material', shared.object_material),
actions=(
('modify_part_collision', 'collide', True),
('modify_part_collision', 'physical', False),
('message', 'our_node', 'at_connect', ExplodeHitMessage()),
),
)
self.dink_sounds = (ba.getsound('bombDrop01'),
ba.getsound('bombDrop02'))
self.sticky_impact_sound = ba.getsound('stickyImpact')
self.roll_sound = ba.getsound('bombRoll01')
# Collision sounds.
self.normal_sound_material.add_actions(
conditions=('they_have_material', shared.footing_material),
actions=(
('impact_sound', self.dink_sounds, 2, 0.8),
('roll_sound', self.roll_sound, 3, 6),
))
self.sticky_material.add_actions(actions=(('modify_part_collision',
'stiffness', 0.1),
('modify_part_collision',
'damping', 1.0)))
self.sticky_material.add_actions(
conditions=(
('they_have_material', shared.player_material),
'or',
('they_have_material', shared.footing_material),
),
actions=('message', 'our_node', 'at_connect', SplatMessage()),
)
def __init__(self,
transition: str = 'in_right',
origin_widget: ba.Widget = None):
# pylint: disable=too-many-statements
# pylint: disable=too-many-locals
new_style = True
width = 1000 if ba.app.small_ui else 800
x_offs = 100 if ba.app.small_ui else 0
height = 550 if new_style else 400
button_width = 400
scale_origin: Optional[Tuple[float, float]]
if origin_widget is not None:
self._transition_out = 'out_scale'
scale_origin = origin_widget.get_screen_space_center()
transition = 'in_scale'
else:
self._transition_out = 'out_right'
scale_origin = None
self._r = 'playWindow'
super().__init__(root_widget=ba.containerwidget(
size=(width, height),
transition=transition,
toolbar_visibility='menu_full',
scale_origin_stack_offset=scale_origin,
scale=(1.6 if new_style else 1.52
) if ba.app.small_ui else 0.9 if ba.app.med_ui else 0.8,
stack_offset=((0, 0) if new_style else (
10, 7)) if ba.app.small_ui else (0, 0)))
self._back_button = back_button = btn = ba.buttonwidget(
parent=self._root_widget,
position=(55 + x_offs, height - 132) if new_style else
(55, height - 92),
size=(120, 60),
scale=1.1,
text_res_scale=1.5,
text_scale=1.2,
autoselect=True,
label=ba.Lstr(resource='backText'),
button_type='back')
txt = ba.textwidget(parent=self._root_widget,
position=(width * 0.5,
height - (101 if new_style else 61)),
size=(0, 0),
text=ba.Lstr(resource=self._r + '.titleText'),
scale=1.7,
res_scale=2.0,
maxwidth=400,
color=ba.app.heading_color,
h_align='center',
v_align='center')
ba.buttonwidget(edit=btn,
button_type='backSmall',
size=(60, 60),
label=ba.charstr(ba.SpecialChar.BACK))
if ba.app.toolbars and ba.app.small_ui:
ba.textwidget(edit=txt, text='')
v = height - (110 if new_style else 60)
v -= 100
clr = (0.6, 0.7, 0.6, 1.0)
v -= 280 if new_style else 180
v += 30 if ba.app.toolbars and ba.app.small_ui else 0
hoffs = x_offs + 80 if new_style else 0
scl = 1.13 if new_style else 0.68
self._lineup_tex = ba.gettexture('playerLineup')
angry_computer_transparent_model = ba.getmodel(
'angryComputerTransparent')
self._lineup_1_transparent_model = ba.getmodel(
'playerLineup1Transparent')
self._lineup_2_transparent_model = ba.getmodel(
'playerLineup2Transparent')
self._lineup_3_transparent_model = ba.getmodel(
'playerLineup3Transparent')
self._lineup_4_transparent_model = ba.getmodel(
'playerLineup4Transparent')
self._eyes_model = ba.getmodel('plasticEyesTransparent')
self._coop_button = btn = ba.buttonwidget(
parent=self._root_widget,
position=(hoffs, v + (scl * 15 if new_style else 0)),
size=(scl * button_width, scl * (300 if new_style else 360)),
extra_touch_border_scale=0.1,
autoselect=True,
label='',
button_type='square',
text_scale=1.13,
on_activate_call=self._coop)
if ba.app.toolbars and ba.app.small_ui:
ba.widget(edit=btn,
left_widget=_ba.get_special_widget('back_button'))
ba.widget(edit=btn,
up_widget=_ba.get_special_widget('account_button'))
ba.widget(edit=btn,
down_widget=_ba.get_special_widget('settings_button'))
self._draw_dude(0,
btn,
hoffs,
v,
scl,
position=(140, 30),
color=(0.72, 0.4, 1.0))
self._draw_dude(1,
btn,
hoffs,
v,
scl,
position=(185, 53),
color=(0.71, 0.5, 1.0))
self._draw_dude(2,
btn,
hoffs,
v,
scl,
position=(220, 27),
color=(0.67, 0.44, 1.0))
self._draw_dude(3,
btn,
hoffs,
v,
scl,
position=(255, 57),
color=(0.7, 0.3, 1.0))
ba.imagewidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * 230, v + scl * 153),
size=(scl * 115, scl * 115),
texture=self._lineup_tex,
model_transparent=angry_computer_transparent_model)
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * (-10), v + scl * 95),
size=(scl * button_width, scl * 50),
text=ba.Lstr(resource='playModes.singlePlayerCoopText',
fallback_resource='playModes.coopText'),
maxwidth=scl * button_width * 0.7,
res_scale=1.5,
h_align='center',
v_align='center',
color=(0.7, 0.9, 0.7, 1.0),
scale=scl * 2.3)
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * (-10), v + (scl * 54)),
size=(scl * button_width, scl * 30),
text=ba.Lstr(resource=self._r + '.oneToFourPlayersText'),
h_align='center',
v_align='center',
scale=0.83 * scl,
flatness=1.0,
maxwidth=scl * button_width * 0.7,
color=clr)
scl = 0.5 if new_style else 0.68
hoffs += 440 if new_style else 260
v += 180 if new_style else 0
self._teams_button = btn = ba.buttonwidget(
parent=self._root_widget,
position=(hoffs, v + (scl * 15 if new_style else 0)),
size=(scl * button_width, scl * (300 if new_style else 360)),
extra_touch_border_scale=0.1,
autoselect=True,
label='',
button_type='square',
text_scale=1.13,
on_activate_call=self._team_tourney)
if ba.app.toolbars:
ba.widget(edit=btn,
up_widget=_ba.get_special_widget('tickets_plus_button'),
right_widget=_ba.get_special_widget('party_button'))
xxx = -14
self._draw_dude(2,
btn,
hoffs,
v,
scl,
position=(xxx + 148, 30),
color=(0.2, 0.4, 1.0))
self._draw_dude(3,
btn,
hoffs,
v,
scl,
position=(xxx + 181, 53),
color=(0.3, 0.4, 1.0))
self._draw_dude(1,
btn,
hoffs,
v,
scl,
position=(xxx + 216, 33),
color=(0.3, 0.5, 1.0))
self._draw_dude(0,
btn,
hoffs,
v,
scl,
position=(xxx + 245, 57),
color=(0.3, 0.5, 1.0))
xxx = 155
self._draw_dude(0,
btn,
hoffs,
v,
scl,
position=(xxx + 151, 30),
color=(1.0, 0.5, 0.4))
self._draw_dude(1,
btn,
hoffs,
v,
scl,
position=(xxx + 189, 53),
color=(1.0, 0.58, 0.58))
self._draw_dude(3,
btn,
hoffs,
v,
scl,
position=(xxx + 223, 27),
color=(1.0, 0.5, 0.5))
self._draw_dude(2,
btn,
hoffs,
v,
scl,
position=(xxx + 257, 57),
color=(1.0, 0.5, 0.5))
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * (-10), v + scl * 95),
size=(scl * button_width, scl * 50),
text=ba.Lstr(resource='playModes.teamsText',
fallback_resource='teamsText'),
res_scale=1.5,
maxwidth=scl * button_width * 0.7,
h_align='center',
v_align='center',
color=(0.7, 0.9, 0.7, 1.0),
scale=scl * 2.3)
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * (-10), v + (scl * 54)),
size=(scl * button_width, scl * 30),
text=ba.Lstr(resource=self._r +
'.twoToEightPlayersText'),
h_align='center',
v_align='center',
res_scale=1.5,
scale=0.9 * scl,
flatness=1.0,
maxwidth=scl * button_width * 0.7,
color=clr)
hoffs += 0 if new_style else 260
v -= 155 if new_style else 0
self._free_for_all_button = btn = ba.buttonwidget(
parent=self._root_widget,
position=(hoffs, v + (scl * 15 if new_style else 0)),
size=(scl * button_width, scl * (300 if new_style else 360)),
extra_touch_border_scale=0.1,
autoselect=True,
label='',
button_type='square',
text_scale=1.13,
on_activate_call=self._free_for_all)
xxx = -5
self._draw_dude(0,
btn,
hoffs,
v,
scl,
position=(xxx + 140, 30),
color=(0.4, 1.0, 0.4))
self._draw_dude(3,
btn,
hoffs,
v,
scl,
position=(xxx + 185, 53),
color=(1.0, 0.4, 0.5))
self._draw_dude(1,
btn,
hoffs,
v,
scl,
position=(xxx + 220, 27),
color=(0.4, 0.5, 1.0))
self._draw_dude(2,
btn,
hoffs,
v,
scl,
position=(xxx + 255, 57),
color=(0.5, 1.0, 0.4))
xxx = 140
self._draw_dude(2,
btn,
hoffs,
v,
scl,
position=(xxx + 148, 30),
color=(1.0, 0.9, 0.4))
self._draw_dude(0,
btn,
hoffs,
v,
scl,
position=(xxx + 182, 53),
color=(0.7, 1.0, 0.5))
self._draw_dude(3,
btn,
hoffs,
v,
scl,
position=(xxx + 233, 27),
color=(0.7, 0.5, 0.9))
self._draw_dude(1,
btn,
hoffs,
v,
scl,
position=(xxx + 266, 53),
color=(0.4, 0.5, 0.8))
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * (-10), v + scl * 95),
size=(scl * button_width, scl * 50),
text=ba.Lstr(resource='playModes.freeForAllText',
fallback_resource='freeForAllText'),
maxwidth=scl * button_width * 0.7,
h_align='center',
v_align='center',
color=(0.7, 0.9, 0.7, 1.0),
scale=scl * 1.9)
ba.textwidget(parent=self._root_widget,
draw_controller=btn,
position=(hoffs + scl * (-10), v + (scl * 54)),
size=(scl * button_width, scl * 30),
text=ba.Lstr(resource=self._r +
'.twoToEightPlayersText'),
h_align='center',
v_align='center',
scale=0.9 * scl,
flatness=1.0,
maxwidth=scl * button_width * 0.7,
color=clr)
if ba.app.toolbars and ba.app.small_ui:
back_button.delete()
ba.containerwidget(edit=self._root_widget,
on_cancel_call=self._back,
selected_child=self._coop_button)
else:
ba.buttonwidget(edit=back_button, on_activate_call=self._back)
ba.containerwidget(edit=self._root_widget,
cancel_button=back_button,
selected_child=self._coop_button)
self._restore_state()
