def tint_callback(playerdata: PlayerData, args):
if len(args) < 2 or (len(args) < 4 and args[1] != 'r'):
chatmessage(get_locale('chat_command_not_args_error'))
elif args[1] == 'r':
m = 1.30 if len(args) < 3 else float(args[2])
s = 1000 if len(args) < 4 else float(args[3])
if m > 3 and playerdata.status != Status.ADMIN:
chatmessage(get_locale('too_big_arg_error'))
return
tint = {
s * 0: (m, 0, 0),
s * 1: (0, m, 0),
s * 2: (0, 0, m),
s * 3: (m, 0, 0),
}
ba.animate_array(ba.getactivity().globalsnode,
'tint',
3,
tint,
True,
suppress_format_warning=True,
timeformat=ba.TimeFormat.MILLISECONDS)
else:
color = (float(args[1]), float(args[2]), float(args[3]))
if max(map(abs, color)) > 3 and playerdata.status != Status.ADMIN:
chatmessage(get_locale('too_big_arg_error'))
return
ba.getactivity().globalsnode.tint = color
def start(self) -> None:
"""Start the timer."""
tval = ba.time(timeformat=ba.TimeFormat.MILLISECONDS)
assert isinstance(tval, int)
self._starttime_ms = tval
self.inputnode.time1 = self._starttime_ms
ba.getactivity().globalsnode.connectattr('time', self.inputnode,
'time2')
def _get_context(self, player: ba.Player) -> Tuple[bool, float, Dict]:
"""Return info on where we should be shown and stored."""
activity = ba.getactivity()
if isinstance(ba.getsession(), ba.DualTeamSession):
on_right = player.team.id % 2 == 1
# Store a list of icons in the team.
icons = player.team.gamedata.get('_spaz_respawn_icons')
if icons is None:
player.team.gamedata['_spaz_respawn_icons'] = icons = {}
assert isinstance(icons, dict)
offs_extra = -20
else:
on_right = False
# Store a list of icons in the activity.
icons = activity.gamedata.get('_spaz_respawn_icons')
if icons is None:
activity.gamedata['_spaz_respawn_icons'] = icons = {}
assert isinstance(icons, dict)
if isinstance(activity.session, ba.FreeForAllSession):
offs_extra = -150
else:
offs_extra = -20
return on_right, offs_extra, icons
def _get_context(self, player: ba.Player) -> Tuple[bool, float, Dict]:
"""Return info on where we should be shown and stored."""
activity = ba.getactivity()
if isinstance(ba.getsession(), ba.DualTeamSession):
on_right = player.team.get_id() % 2 == 1
# Store a list of icons in the team.
try:
respawn_icons = (
player.team.gamedata['_spaz_respawn_icons_right'])
except Exception:
respawn_icons = (
player.team.gamedata['_spaz_respawn_icons_right']) = {}
offs_extra = -20
else:
on_right = False
# Store a list of icons in the activity.
# FIXME: Need an elegant way to store our shared stuff with
# the activity.
try:
respawn_icons = activity.spaz_respawn_icons_right
except Exception:
respawn_icons = activity.spaz_respawn_icons_right = {}
if isinstance(activity.session, ba.FreeForAllSession):
offs_extra = -150
else:
offs_extra = -20
return on_right, offs_extra, respawn_icons
def start(self) -> None:
"""Start the timer."""
globalsnode = ba.getactivity().globalsnode
globalsnode.connectattr('time', self.inputnode, 'time1')
self.inputnode.time2 = (globalsnode.time +
(self._timeremaining + 1) * 1000)
self._timer = ba.Timer(1.0, self._update, repeat=True)
def box_callback(playerdata: PlayerData, args):
from bastd.actor.playerspaz import PlayerSpaz
def do_box(player):
if player.actor and isinstance(player.actor,
PlayerSpaz) and player.actor.node:
player.actor.node.torso_model = ba.getmodel('tnt')
player.actor.node.color_mask_texture = ba.gettexture('tnt')
player.actor.node.color_texture = ba.gettexture('tnt')
player.actor.node.highlight = (1, 1, 1)
player.actor.node.color = (1, 1, 1)
player.actor.node.head_model = None
player.actor.node.style = 'cyborg'
activity = ba.getactivity()
if len(args) < 2:
chatmessage(get_locale('chat_command_not_args_error'))
elif args[1] == 'all' and playerdata.status == Status.ADMIN:
for iplayer in activity.players:
do_box(iplayer)
else:
try:
iplayer = activity.players[int(args[1])]
do_box(iplayer)
except (IndexError, ValueError):
chatmessage(get_locale('not_player_error'))
def reflections_callback(playerdata: PlayerData, args):
activity = ba.getactivity()
assert isinstance(activity, ba.GameActivity)
try:
rs = [int(args[2])]
ref_type = 'soft' if int(args[1]) == 0 else 'powerup'
except (ValueError, IndexError):
chatmessage(get_locale('chat_command_not_args_error'))
return
activity.map.node.reflection = ref_type
activity.map.node.reflection_scale = rs
try:
activity.map.bg.reflection = ref_type
activity.map.bg.reflection_scale = rs
except AttributeError:
pass
try:
activity.map.floor.reflection = ref_type
activity.map.floor.reflection_scale = rs
except AttributeError:
pass
try:
activity.map.center.reflection = ref_type
activity.map.center.reflection_scale = rs
except AttributeError:
pass
def _update(self) -> None:
# Update one of our bot lists each time through.
# First off, remove dead bots from the list. Note that we check
# exists() here via the bool operator instead of dead; we want to
# keep them around even if they're just a corpse.
try:
bot_list = self._bot_lists[self._bot_update_list] = ([
b for b in self._bot_lists[self._bot_update_list] if b
])
except Exception:
bot_list = []
ba.print_exception('error updating bot list: ' +
str(self._bot_lists[self._bot_update_list]))
self._bot_update_list = (self._bot_update_list +
1) % self._bot_list_count
# Update our list of player points for the bots to use.
player_pts = []
for player in ba.getactivity().players:
assert isinstance(player, ba.Player)
try:
if player.is_alive():
assert isinstance(player.actor, Spaz)
assert player.actor.node
player_pts.append((ba.Vec3(player.actor.node.position),
ba.Vec3(player.actor.node.velocity)))
except Exception:
ba.print_exception('error on bot-set _update')
for bot in bot_list:
bot.set_player_points(player_pts)
bot.update_ai()
def _update(self) -> None:
# Update one of our bot lists each time through.
# First off, remove no-longer-existing bots from the list.
try:
bot_list = self._bot_lists[self._bot_update_list] = ([
b for b in self._bot_lists[self._bot_update_list] if b
])
except Exception:
bot_list = []
ba.print_exception('Error updating bot list: ' +
str(self._bot_lists[self._bot_update_list]))
self._bot_update_list = (self._bot_update_list +
1) % self._bot_list_count
# Update our list of player points for the bots to use.
player_pts = []
for player in ba.getactivity().players:
assert isinstance(player, ba.Player)
try:
# TODO: could use abstracted player.position here so we
# don't have to assume their actor type, but we have no
# abstracted velocity as of yet.
if player.is_alive():
assert isinstance(player.actor, Spaz)
assert player.actor.node
player_pts.append((ba.Vec3(player.actor.node.position),
ba.Vec3(player.actor.node.velocity)))
except Exception:
ba.print_exception('Error on bot-set _update.')
for bot in bot_list:
bot.set_player_points(player_pts)
bot.update_ai()
def ice_off_callback(playerdata: PlayerData, args):
from bastd.gameutils import SharedObjects
shared = SharedObjects.get()
activity = ba.getactivity()
assert isinstance(activity, ba.GameActivity)
activity.map.is_hockey = False
activity.map.node.materials = [shared.footing_material]
activity.map.floor.materials = [shared.footing_material]
def getFactory(cls):
activity = ba.getactivity()
if activity is None: raise Exception("no current activity")
try:
return activity._sharedSurroundBallFactory
except Exception:
f = activity._sharedSurroundBallFactory = SurroundBallFactory()
return f
def get(cls):
"""Get factory if exists else create new"""
activity = ba.getactivity()
if hasattr(activity, STORAGE_ATTR_NAME):
return getattr(activity, STORAGE_ATTR_NAME)
factory = cls()
setattr(activity, STORAGE_ATTR_NAME, factory)
return factory
def get(cls) -> SharedObjects:
"""Fetch/create the instance of this class for the current activity."""
activity = ba.getactivity()
shobs = activity.customdata.get(cls._STORENAME)
if shobs is None:
shobs = SharedObjects()
activity.customdata[cls._STORENAME] = shobs
assert isinstance(shobs, SharedObjects)
return shobs
def remove_callback(playerdata: PlayerData, args):
activity = ba.getactivity()
if len(args) < 2:
chatmessage(get_locale('chat_command_not_args_error'))
elif args[1] == 'all' and playerdata.status == Status.ADMIN:
for player in activity.players:
player.sessionplayer.remove_from_game()
else:
activity.players[int(args[1])].sessionplayer.remove_from_game()
def get(cls) -> FlagFactory:
"""Get/create a shared FlagFactory instance."""
activity = ba.getactivity()
factory = activity.customdata.get(cls._STORENAME)
if factory is None:
factory = FlagFactory()
activity.customdata[cls._STORENAME] = factory
assert isinstance(factory, FlagFactory)
return factory
def get() -> FlagFactory:
"""Get/create a shared FlagFactory instance."""
activity = ba.getactivity()
factory = getattr(activity, 'shared_flag_factory', None)
if factory is None:
factory = FlagFactory()
setattr(activity, 'shared_flag_factory', factory)
assert isinstance(factory, FlagFactory)
return factory
def get() -> BombFactory:
"""Get/create a shared bastd.actor.bomb.BombFactory object."""
activity = ba.getactivity()
factory = getattr(activity, STORAGE_ATTR_NAME, None)
if factory is None:
factory = BombFactory()
setattr(activity, STORAGE_ATTR_NAME, factory)
assert isinstance(factory, BombFactory)
return factory
def get() -> SharedObjects:
"""Fetch/create the instance of this class for the current activity."""
activity = ba.getactivity()
shobs = getattr(activity, STORAGE_ATTR_NAME, None)
if shobs is None:
shobs = SharedObjects()
setattr(activity, STORAGE_ATTR_NAME, shobs)
assert isinstance(shobs, SharedObjects)
return shobs
def get(cls) -> StickyGiftFactory:
activity = ba.getactivity()
factory: cls
try:
factory = activity.shared_sticky_gift_factory
except AttributeError:
factory = activity.shared_sticky_gift_factory = cls()
assert isinstance(factory, cls)
return factory
def get(cls) -> BombFactory:
"""Get/create a shared bastd.actor.bomb.BombFactory object."""
activity = ba.getactivity()
factory = activity.customdata.get(cls._STORENAME)
if factory is None:
factory = BombFactory()
activity.customdata[cls._STORENAME] = factory
assert isinstance(factory, BombFactory)
return factory
def get(cls) -> SpazFactory:
"""Return the shared ba.SpazFactory, creating it if necessary."""
# pylint: disable=cyclic-import
activity = ba.getactivity()
factory = activity.customdata.get(cls._STORENAME)
if factory is None:
factory = activity.customdata[cls._STORENAME] = SpazFactory()
assert isinstance(factory, SpazFactory)
return factory
def _spawn(self) -> None:
ba.timer(1.0, self._light.delete)
if self._spawn_callback is not None:
self._spawn_callback()
if self._send_spawn_message:
# only run if our activity still exists
activity = ba.getactivity()
if activity is not None:
activity.handlemessage(
self.SpawnMessage(self, self._data, self._pt))
def get(cls) -> PowerupBoxFactory:
"""Return a shared ba.PowerupBoxFactory object, creating if needed."""
activity = ba.getactivity()
if activity is None:
raise ba.ContextError('No current activity.')
factory = activity.customdata.get(cls._STORENAME)
if factory is None:
factory = activity.customdata[cls._STORENAME] = PowerupBoxFactory()
assert isinstance(factory, PowerupBoxFactory)
return factory
def get_factory() -> FlagFactory:
"""Get/create a shared bastd.actor.flag.FlagFactory object."""
activity = ba.getactivity()
factory: FlagFactory
try:
# FIXME: Find elegant way to handle shared data like this.
factory = activity.shared_flag_factory # type: ignore
except Exception:
factory = activity.shared_flag_factory = FlagFactory() # type: ignore
assert isinstance(factory, FlagFactory)
return factory
def clear(self) -> None:
"""Immediately clear out any bots in the set."""
# Don't do this if the activity is shutting down or dead.
activity: Optional[ba.Activity] = ba.getactivity(doraise=False)
if activity is None or activity.expired:
return
for i in range(len(self._bot_lists)):
for bot in self._bot_lists[i]:
bot.handlemessage(ba.DieMessage(immediate=True))
self._bot_lists[i] = []
def clear(self) -> None:
"""Immediately clear out any bots in the set."""
# Don't do this if the activity is shutting down or dead.
activity = ba.getactivity(doraise=False)
if activity is None or activity.expired:
return
for i, bot_list in enumerate(self._bot_lists):
for bot in bot_list:
bot.handlemessage(ba.DieMessage(immediate=True))
self._bot_lists[i] = []
def get_factory() -> BombFactory:
"""Get/create a shared bastd.actor.bomb.BombFactory object."""
activity = ba.getactivity()
# FIXME: Need to figure out an elegant way to store
# shared actor data with an activity.
factory: BombFactory
try:
factory = activity.shared_bomb_factory # type: ignore
except Exception:
factory = activity.shared_bomb_factory = BombFactory() # type: ignore
assert isinstance(factory, BombFactory)
return factory
def __init__(self) -> None:
activity = ba.getactivity()
if self._STORENAME in activity.customdata:
raise RuntimeError('Use SharedObjects.get() to fetch the'
' shared instance for this activity.')
self._object_material: Optional[ba.Material] = None
self._player_material: Optional[ba.Material] = None
self._pickup_material: Optional[ba.Material] = None
self._footing_material: Optional[ba.Material] = None
self._attack_material: Optional[ba.Material] = None
self._death_material: Optional[ba.Material] = None
self._region_material: Optional[ba.Material] = None
self._railing_material: Optional[ba.Material] = None
def drop_man():
botset: stdbot.SpazBotSet
activity = ba.getactivity()
if not hasattr(activity, 'botset'):
activity.botset = botset = stdbot.SpazBotSet()
botset = activity.botset
aoi_bounds = self.activity.globalsnode.area_of_interest_bounds
botset.spawn_bot(
stdbot.BrawlerBotLite,
(random.randrange(int(aoi_bounds[0]),
int(aoi_bounds[3]) + 1), aoi_bounds[4] - 1,
random.randrange(int(aoi_bounds[2]),
int(aoi_bounds[5]) + 1)),
spawn_time=0.001)
def get_factory() -> PowerupBoxFactory:
"""Return a shared ba.PowerupBoxFactory object, creating if necessary."""
activity = ba.getactivity()
if activity is None:
raise RuntimeError('no current activity')
try:
# FIXME: et better way to store stuff with activity
# pylint: disable=protected-access
# noinspection PyProtectedMember
return activity._shared_powerup_factory # type: ignore
except Exception:
factory = activity._shared_powerup_factory = ( # type: ignore
PowerupBoxFactory())
return factory
