def _update_text(self) -> None:
assert self._text_node is not None
if self._ready:
# Once we're ready, we've saved the name, so lets ask the system
# for it so we get appended numbers and stuff.
text = Lstr(value=self._sessionplayer.getname(full=True))
text = Lstr(value='${A} (${B})',
subs=[('${A}', text),
('${B}', Lstr(resource='readyText'))])
else:
text = Lstr(value=self._getname(full=True))
can_switch_teams = len(self.lobby.sessionteams) > 1
# Flash as we're coming in.
fin_color = _ba.safecolor(self.get_color()) + (1, )
if not self._inited:
animate_array(self._text_node, 'color', 4, {
0.15: fin_color,
0.25: (2, 2, 2, 1),
0.35: fin_color
})
else:
# Blend if we're in teams mode; switch instantly otherwise.
if can_switch_teams:
animate_array(self._text_node, 'color', 4, {
0: self._text_node.color,
0.1: fin_color
})
else:
self._text_node.color = fin_color
self._text_node.text = text
def _update_icon(self) -> None:
from ba import _gameutils
if self._profilenames[self._profileindex] == '_edit':
tex = _ba.gettexture('black')
tint_tex = _ba.gettexture('black')
self.icon.color = (1, 1, 1)
self.icon.texture = tex
self.icon.tint_texture = tint_tex
self.icon.tint_color = (0, 1, 0)
return
try:
tex_name = (_ba.app.spaz_appearances[self.character_names[
self.character_index]].icon_texture)
tint_tex_name = (_ba.app.spaz_appearances[self.character_names[
self.character_index]].icon_mask_texture)
except Exception:
from ba import _error
_error.print_exception('Error updating char icon list')
tex_name = 'neoSpazIcon'
tint_tex_name = 'neoSpazIconColorMask'
tex = _ba.gettexture(tex_name)
tint_tex = _ba.gettexture(tint_tex_name)
self.icon.color = (1, 1, 1)
self.icon.texture = tex
self.icon.tint_texture = tint_tex
clr = self.get_color()
clr2 = self.get_highlight()
can_switch_teams = len(self.lobby.teams) > 1
# If we're initing, flash.
if not self._inited:
_gameutils.animate_array(self.icon, 'color', 3, {
0.15: (1, 1, 1),
0.25: (2, 2, 2),
0.35: (1, 1, 1)
})
# Blend in teams mode; switch instantly in ffa-mode.
if can_switch_teams:
_gameutils.animate_array(self.icon, 'tint_color', 3, {
0: self.icon.tint_color,
0.1: clr
})
else:
self.icon.tint_color = clr
self.icon.tint2_color = clr2
# Store the icon info the the player.
self._player.set_icon_info(tex_name, tint_tex_name, clr, clr2)
def update_position(self) -> None:
"""Update this chooser's position."""
assert self._text_node
spacing = 350
sessionteams = self.lobby.sessionteams
offs = (spacing * -0.5 * len(sessionteams) +
spacing * self._selected_team_index + 250)
if len(sessionteams) > 1:
offs -= 35
animate_array(self._text_node, 'position', 2, {
0: self._text_node.position,
0.1: (-100 + offs, self._vpos + 23)
})
animate_array(self.icon, 'position', 2, {
0: self.icon.position,
0.1: (-130 + offs, self._vpos + 22)
})
def update_position(self) -> None:
"""Update this chooser's position."""
from ba import _gameutils
# Hmmm this shouldn't be happening.
if not self._text_node:
print('Error: chooser text nonexistent..')
import traceback
traceback.print_stack()
return
spacing = 350
teams = self.lobby.teams
offs = (spacing * -0.5 * len(teams) +
spacing * self._selected_team_index + 250)
if len(teams) > 1:
offs -= 35
_gameutils.animate_array(self._text_node, 'position', 2, {
0: self._text_node.position,
0.1: (-100 + offs, self._vpos + 23)
})
_gameutils.animate_array(self.icon, 'position', 2, {
0: self.icon.position,
0.1: (-130 + offs, self._vpos + 22)
})
def __init__(self, vpos: float, sessionplayer: _ba.SessionPlayer,
lobby: 'Lobby') -> None:
self._deek_sound = _ba.getsound('deek')
self._click_sound = _ba.getsound('click01')
self._punchsound = _ba.getsound('punch01')
self._swish_sound = _ba.getsound('punchSwish')
self._errorsound = _ba.getsound('error')
self._mask_texture = _ba.gettexture('characterIconMask')
self._vpos = vpos
self._lobby = weakref.ref(lobby)
self._sessionplayer = sessionplayer
self._inited = False
self._dead = False
self._text_node: Optional[ba.Node] = None
self._profilename = ''
self._profilenames: List[str] = []
self._ready: bool = False
self._character_names: List[str] = []
self._last_change: Sequence[Union[float, int]] = (0, 0)
self._profiles: Dict[str, Dict[str, Any]] = {}
app = _ba.app
# Load available player profiles either from the local config or
# from the remote device.
self.reload_profiles()
# Note: this is just our local index out of available teams; *not*
# the team-id!
self._selected_team_index: int = self.lobby.next_add_team
# Store a persistent random character index and colors; we'll use this
# for the '_random' profile. Let's use their input_device id to seed
# it. This will give a persistent character for them between games
# and will distribute characters nicely if everyone is random.
self._random_color, self._random_highlight = (
get_player_profile_colors(None))
# To calc our random character we pick a random one out of our
# unlocked list and then locate that character's index in the full
# list.
char_index_offset = app.lobby_random_char_index_offset
self._random_character_index = (
(sessionplayer.inputdevice.id + char_index_offset) %
len(self._character_names))
# Attempt to set an initial profile based on what was used previously
# for this input-device, etc.
self._profileindex = self._select_initial_profile()
self._profilename = self._profilenames[self._profileindex]
self._text_node = _ba.newnode('text',
delegate=self,
attrs={
'position': (-100, self._vpos),
'maxwidth': 160,
'shadow': 0.5,
'vr_depth': -20,
'h_align': 'left',
'v_align': 'center',
'v_attach': 'top'
})
animate(self._text_node, 'scale', {0: 0, 0.1: 1.0})
self.icon = _ba.newnode('image',
owner=self._text_node,
attrs={
'position': (-130, self._vpos + 20),
'mask_texture': self._mask_texture,
'vr_depth': -10,
'attach': 'topCenter'
})
animate_array(self.icon, 'scale', 2, {0: (0, 0), 0.1: (45, 45)})
# Set our initial name to '<choosing player>' in case anyone asks.
self._sessionplayer.setname(
Lstr(resource='choosingPlayerText').evaluate(), real=False)
# Init these to our rando but they should get switched to the
# selected profile (if any) right after.
self._character_index = self._random_character_index
self._color = self._random_color
self._highlight = self._random_highlight
self.update_from_profile()
self.update_position()
self._inited = True
self._set_ready(False)
def __init__(self, vpos: float, player: _ba.SessionPlayer,
lobby: 'Lobby') -> None:
# FIXME: Tidy up around here.
# pylint: disable=too-many-branches
# pylint: disable=too-many-statements
from ba import _gameutils
from ba import _profile
from ba import _lang
app = _ba.app
self._deek_sound = _ba.getsound('deek')
self._click_sound = _ba.getsound('click01')
self._punchsound = _ba.getsound('punch01')
self._swish_sound = _ba.getsound('punchSwish')
self._errorsound = _ba.getsound('error')
self._mask_texture = _ba.gettexture('characterIconMask')
self._vpos = vpos
self._lobby = weakref.ref(lobby)
self._player = player
self._inited = False
self._dead = False
self._text_node: Optional[ba.Node] = None
self._profilename = ''
self._profilenames: List[str] = []
self._ready: bool = False
self.character_names: List[str] = []
self.last_change: Sequence[Union[float, int]] = (0, 0)
# Hmm does this need to be public?
self.profiles: Dict[str, Dict[str, Any]] = {}
# Load available profiles either from the local config or from the
# remote device.
self.reload_profiles()
# Note: this is just our local index out of available teams; *not*
# the team-id!
self._selected_team_index: int = self.lobby.next_add_team
# Store a persistent random character index; we'll use this for the
# '_random' profile. Let's use their input_device id to seed it. This
# will give a persistent character for them between games and will
# distribute characters nicely if everyone is random.
try:
input_device_id = self._player.get_input_device().id
except Exception:
from ba import _error
_error.print_exception('Error getting device-id on chooser create')
input_device_id = 0
if app.lobby_random_char_index_offset is None:
# We want the first device that asks for a chooser to always get
# spaz as a random character..
# scratch that.. we now kinda accomplish the same thing with
# account profiles so lets just be fully random here.
app.lobby_random_char_index_offset = (random.randrange(1000))
# To calc our random index we pick a random character out of our
# unlocked list and then locate that character's index in the full
# list.
char_index_offset = app.lobby_random_char_index_offset
assert char_index_offset is not None
self._random_character_index = ((input_device_id + char_index_offset) %
len(self.character_names))
self._random_color, self._random_highlight = (
_profile.get_player_profile_colors(None))
# Attempt to pick an initial profile based on what's been stored
# for this input device.
input_device = self._player.get_input_device()
try:
name = input_device.name
unique_id = input_device.unique_identifier
self._profilename = (
app.config['Default Player Profiles'][name + ' ' + unique_id])
self._profileindex = self._profilenames.index(self._profilename)
# If this one is __account__ and is local and we haven't marked
# anyone as the account-profile device yet, mark this guy as it.
# (prevents the next joiner from getting the account profile too).
if (self._profilename == '__account__'
and not input_device.is_remote_client
and app.lobby_account_profile_device_id is None):
app.lobby_account_profile_device_id = input_device_id
# Well hmm that didn't work.. pick __account__, _random, or some
# other random profile.
except Exception:
profilenames = self._profilenames
# We want the first local input-device in the game to latch on to
# the account profile.
if (not input_device.is_remote_client
and not input_device.is_controller_app):
if (app.lobby_account_profile_device_id is None
and '__account__' in profilenames):
app.lobby_account_profile_device_id = input_device_id
# If this is the designated account-profile-device, try to default
# to the account profile.
if (input_device_id == app.lobby_account_profile_device_id
and '__account__' in profilenames):
self._profileindex = profilenames.index('__account__')
else:
# If this is the controller app, it defaults to using a random
# profile (since we can pull the random name from the app).
if input_device.is_controller_app:
self._profileindex = profilenames.index('_random')
else:
# If its a client connection, for now just force
# the account profile if possible.. (need to provide a
# way for clients to specify/remember their default
# profile on remote servers that do not already know them).
if (input_device.is_remote_client
and '__account__' in profilenames):
self._profileindex = profilenames.index('__account__')
else:
# Cycle through our non-random profiles once; after
# that, everyone gets random.
while (app.lobby_random_profile_index <
len(profilenames)
and profilenames[app.lobby_random_profile_index]
in ('_random', '__account__', '_edit')):
app.lobby_random_profile_index += 1
if (app.lobby_random_profile_index <
len(profilenames)):
self._profileindex = (
app.lobby_random_profile_index)
app.lobby_random_profile_index += 1
else:
self._profileindex = profilenames.index('_random')
self._profilename = profilenames[self._profileindex]
self.character_index = self._random_character_index
self._color = self._random_color
self._highlight = self._random_highlight
self._text_node = _ba.newnode('text',
delegate=self,
attrs={
'position': (-100, self._vpos),
'maxwidth': 160,
'shadow': 0.5,
'vr_depth': -20,
'h_align': 'left',
'v_align': 'center',
'v_attach': 'top'
})
_gameutils.animate(self._text_node, 'scale', {0: 0, 0.1: 1.0})
self.icon = _ba.newnode('image',
owner=self._text_node,
attrs={
'position': (-130, self._vpos + 20),
'mask_texture': self._mask_texture,
'vr_depth': -10,
'attach': 'topCenter'
})
_gameutils.animate_array(self.icon, 'scale', 2, {
0: (0, 0),
0.1: (45, 45)
})
self._set_ready(False)
# Set our initial name to '<choosing player>' in case anyone asks.
self._player.set_name(
_lang.Lstr(resource='choosingPlayerText').evaluate(), real=False)
self.update_from_player_profiles()
self.update_position()
self._inited = True
