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