def update_from_profile(self, old_function):
self._gcinit()
from ba import _profile
try:
self._profilename = self._profilenames[self._profileindex]
character = self._profiles[self._profilename]['character']
if self._profilename[0] in self.glow_dict:
if (character not in self._character_names
and character in _ba.app.spaz_appearances):
self._character_names.append(character)
self._character_index = self._character_names.index(character)
player_glowing_dict = self.glow_dict[self._profilename[0]]
color_marker = player_glowing_dict[0]
color_marker = max(-999.0, min(color_marker, 50.0))
highlight_marker = float(player_glowing_dict[1])
highlight_marker = max(-999.0, min(highlight_marker, 50.0))
stabilize_color = int(player_glowing_dict[2]) > 0
stabilize_highlight = int(player_glowing_dict[3]) > 0
self._color, self._highlight = \
_profile.get_player_profile_colors(
self._profilename,
profiles=self._profiles)
if stabilize_color:
m = max(self._color)
self._color = list(self._color)
for i in (0, 1, 2):
if self._color[i] == m:
self._color[i] = self._color[i] * color_marker
self._color = tuple(self._color)
else:
self._color = (self._color[0] * color_marker,
self._color[1] * color_marker,
self._color[2] * color_marker)
if not stabilize_highlight:
self._highlight = (self._highlight[0] * highlight_marker,
self._highlight[1] * highlight_marker,
self._highlight[2] * highlight_marker)
else:
m = max(self._highlight)
self._highlight = list(self._highlight)
for i in (0, 1, 2):
if self._highlight[i] == m:
self._highlight[i] = \
self._highlight[i] * highlight_marker
self._highlight = tuple(self._highlight)
else:
old_function(self)
except KeyError:
self.character_index = self._random_character_index
self._color = self._random_color
self._highlight = self._random_highlight
self._update_icon()
self._update_text()
def update_from_profile(self) -> None:
"""Set character/colors based on the current profile."""
self._profilename = self._profilenames[self._profileindex]
if self._profilename == '_edit':
pass
elif self._profilename == '_random':
self._character_index = self._random_character_index
self._color = self._random_color
self._highlight = self._random_highlight
else:
character = self._profiles[self._profilename]['character']
# At the moment we're not properly pulling the list
# of available characters from clients, so profiles might use a
# character not in their list. For now, just go ahead and add
# a character name to their list as long as we're aware of it.
# This just means they won't always be able to override their
# character to others they own, but profile characters
# should work (and we validate profiles on the master server
# so no exploit opportunities)
if (character not in self._character_names
and character in _ba.app.spaz_appearances):
self._character_names.append(character)
self._character_index = self._character_names.index(character)
self._color, self._highlight = (get_player_profile_colors(
self._profilename, profiles=self._profiles))
self._update_icon()
self._update_text()
def update_from_player_profiles(self) -> None:
"""Set character based on profile; otherwise use pre-picked random."""
try:
from ba import _profile
# Store the name even though we usually use index (in case
# the profile list changes)
self._profilename = self._profilenames[self._profileindex]
character = self.profiles[self._profilename]['character']
# At the moment we're not properly pulling the list
# of available characters from clients, so profiles might use a
# character not in their list. For now, just go ahead and add
# a character name to their list as long as we're aware of it.
# This just means they won't always be able to override their
# character to others they own, but profile characters should work
# (and we validate profiles on the master server so no exploit
# opportunities)
if (character not in self.character_names
and character in _ba.app.spaz_appearances):
self.character_names.append(character)
self.character_index = self.character_names.index(character)
self._color, self._highlight = (_profile.get_player_profile_colors(
self._profilename, profiles=self.profiles))
except Exception:
# FIXME: Should never use top level Exception for logic; only
# error catching (and they should always be logged).
self.character_index = self._random_character_index
self._color = self._random_color
self._highlight = self._random_highlight
self._update_icon()
self._update_text()
def update_from_player_profiles(self) -> None:
"""Set character based on profile; otherwise use pre-picked random."""
try:
from ba import _profile
# Store the name even though we usually use index (in case
# the profile list changes)
self._profilename = self._profilenames[self._profileindex]
character = self.profiles[self._profilename]['character']
# Hmmm; at the moment we're not properly pulling the list
# of available characters from clients, so profiles might use a
# character not in their list. for now, just go ahead and add
# the character name to their list as long as we're aware of it
# UPDATE: actually we now should be getting their character list,
# so this should no longer be happening; adding warning print
# for now and can delete later.
if (character not in self.character_names
and character in _ba.app.spaz_appearances):
print('got remote character not in their character list:',
character, self.character_names)
self.character_names.append(character)
self.character_index = self.character_names.index(character)
self._color, self._highlight = (_profile.get_player_profile_colors(
self._profilename, profiles=self.profiles))
except Exception:
# FIXME: Should never use top level Exception for logic; only
# error catching (and they should always be logged).
self.character_index = self._random_character_index
self._color = self._random_color
self._highlight = self._random_highlight
self._update_icon()
self._update_text()
def update_from_profile(self) -> None:
"""Set character/colors based on the current profile."""
self._profilename = self._profilenames[self._profileindex]
self.get_glowing()
if self._profilename[0] in self._glowing:
m = self._profilename[0]
character = self._profiles[self._profilename]['character']
if (character not in self._character_names
and character in _ba.app.spaz_appearances):
self._character_names.append(character)
self._character_index = self._character_names.index(character)
color_multiple = self._glowing[m][0]
highlight_multiple = self._glowing[m][1]
self._color, self._highlight = (get_player_profile_colors(
self._profilename, profiles=self._profiles))
if not (self._glowing[m][2] > 0):
self._color = tuple(
[i * color_multiple for i in list(self._color)])
else:
self._color = list(self._color)
val = max(self._color)
for i, c in enumerate(self._color):
if c == val:
self._color[i] *= color_multiple
self._color = tuple(self._color)
if not (self._glowing[m][3] > 0):
self._highlight = tuple(
[i * highlight_multiple for i in list(self._highlight)])
else:
self._highlight = list(self._highlight)
val = max(self._highlight)
for i, c in enumerate(self._highlight):
if c == val:
self._highlight[i] *= highlight_multiple
self._highlight = tuple(self._highlight)
self._update_icon()
self._update_text()
else:
self.update_from_profile_old()
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
