def celeb(arguments):
if arguments == [] or arguments == ['']:
return
elif arguments[0] == 'all':
handlemsg_all(ba.CelebrateMessage())
else:
try:
player = int(arguments[0])
handlemsg(player, ba.CelebrateMessage())
except:
return
def _handle_score(self) -> None:
"""A point has been scored."""
assert self._puck is not None
assert self._score_regions is not None
# Our puck might stick around for a second or two
# we don't want it to be able to score again.
if self._puck.scored:
return
region = ba.get_collision_info("source_node")
index = 0
for index in range(len(self._score_regions)):
if region == self._score_regions[index].node:
break
for team in self.teams:
if team.get_id() == index:
scoring_team = team
team.gamedata['score'] += 1
# Tell all players to celebrate.
for player in team.players:
if player.actor:
player.actor.handlemessage(ba.CelebrateMessage(2.0))
# If we've got the player from the scoring team that last
# touched us, give them points.
if (scoring_team.get_id() in self._puck.last_players_to_touch
and self._puck.last_players_to_touch[
scoring_team.get_id()]):
self.stats.player_scored(self._puck.last_players_to_touch[
scoring_team.get_id()],
100,
big_message=True)
# End game if we won.
if team.gamedata['score'] >= self.settings['Score to Win']:
self.end_game()
ba.playsound(self._foghorn_sound)
ba.playsound(self._cheer_sound)
self._puck.scored = True
# Kill the puck (it'll respawn itself shortly).
ba.timer(1.0, self._kill_puck)
light = ba.newnode('light',
attrs={
'position': ba.get_collision_info('position'),
'height_attenuated': False,
'color': (1, 0, 0)
})
ba.animate(light, 'intensity', {0: 0, 0.5: 1, 1.0: 0}, loop=True)
ba.timer(1.0, light.delete)
ba.cameraflash(duration=10.0)
self._update_scoreboard()
def end_game(self) -> None:
# Stop our on-screen timer so players can see what they got.
assert self._timer is not None
self._timer.stop()
results = ba.TeamGameResults()
# If we won, set our score to the elapsed time
# (there should just be 1 team here since this is co-op).
# ..if we didn't win, leave scores as default (None) which means
# we lost.
if self._won:
curtime = ba.time(timeformat=ba.TimeFormat.MILLISECONDS)
assert isinstance(curtime, int)
starttime = self._timer.getstarttime(
timeformat=ba.TimeFormat.MILLISECONDS)
assert isinstance(starttime, int)
elapsed_time_ms = curtime - starttime
ba.cameraflash()
ba.playsound(self._winsound)
for team in self.teams:
for player in team.players:
if player.actor:
player.actor.handlemessage(ba.CelebrateMessage())
results.set_team_score(team, elapsed_time_ms)
# Ends the activity.
self.end(results)
def final_celebrate(self) -> None:
"""Tell all bots in the set to stop what they were doing and celebrate.
Use this when the bots have won a game.
"""
self._bot_update_timer = None
# At this point stop doing anything but jumping and celebrating.
for botlist in self._bot_lists:
for bot in botlist:
if bot:
assert bot.node # (should exist if 'if bot' was True)
bot.node.move_left_right = 0
bot.node.move_up_down = 0
ba.timer(0.5 * random.random(),
ba.Call(bot.handlemessage, ba.CelebrateMessage()))
jump_duration = random.randrange(400, 500)
j = random.randrange(0, 200)
for _i in range(10):
bot.node.jump_pressed = True
bot.node.jump_pressed = False
j += jump_duration
ba.timer(random.uniform(0.0, 1.0),
ba.Call(bot.node.handlemessage, 'attack_sound'))
ba.timer(random.uniform(1.0, 2.0),
ba.Call(bot.node.handlemessage, 'attack_sound'))
ba.timer(random.uniform(2.0, 3.0),
ba.Call(bot.node.handlemessage, 'attack_sound'))
def celebrate(self, duration: float) -> None:
"""Tell all living bots in the set to celebrate momentarily.
Duration is given in seconds.
"""
msg = ba.CelebrateMessage(duration=duration)
for botlist in self._bot_lists:
for bot in botlist:
if bot:
bot.handlemessage(msg)
def _handle_score(self) -> None:
"""A point has been scored."""
# Our flag might stick around for a second or two
# make sure it doesn't score again.
assert self._flag is not None
if self._flag.scored:
return
region = ba.getcollision().sourcenode
i = None
for i in range(len(self._score_regions)):
if region == self._score_regions[i].node:
break
for team in self.teams:
if team.id == i:
team.score += 7
# Tell all players to celebrate.
for player in team.players:
if player.actor:
player.actor.handlemessage(ba.CelebrateMessage(2.0))
# If someone on this team was last to touch it,
# give them points.
assert self._flag is not None
if (self._flag.last_holding_player
and team == self._flag.last_holding_player.team):
self.stats.player_scored(self._flag.last_holding_player,
50,
big_message=True)
# End the game if we won.
if team.score >= self._score_to_win:
self.end_game()
ba.playsound(self._score_sound)
ba.playsound(self._cheer_sound)
assert self._flag
self._flag.scored = True
# Kill the flag (it'll respawn shortly).
ba.timer(1.0, self._kill_flag)
light = ba.newnode('light',
attrs={
'position': ba.getcollision().position,
'height_attenuated': False,
'color': (1, 0, 0)
})
ba.animate(light, 'intensity', {0.0: 0, 0.5: 1, 1.0: 0}, loop=True)
ba.timer(1.0, light.delete)
ba.cameraflash(duration=10.0)
self._update_scoreboard()
def _score(self, team: ba.Team) -> None:
team.gamedata['score'] += 1
ba.playsound(self._score_sound)
self._flash_base(team)
self._update_scoreboard()
# Have teammates celebrate
for player in team.players:
if player.actor:
player.actor.handlemessage(ba.CelebrateMessage(2.0))
# Reset all flags/state.
for reset_team in self.teams:
if not reset_team.gamedata['home_flag_at_base']:
reset_team.gamedata['flag'].handlemessage(ba.DieMessage())
reset_team.gamedata['enemy_flag_at_base'] = False
if team.gamedata['score'] >= self.settings_raw['Score to Win']:
self.end_game()
def _score(self, team: Team) -> None:
team.score += 1
ba.playsound(self._score_sound)
self._flash_base(team)
self._update_scoreboard()
# Have teammates celebrate.
for player in team.players:
if player.actor:
player.actor.handlemessage(ba.CelebrateMessage(2.0))
# Reset all flags/state.
for reset_team in self.teams:
if not reset_team.home_flag_at_base:
assert reset_team.flag is not None
reset_team.flag.handlemessage(ba.DieMessage())
reset_team.enemy_flag_at_base = False
if team.score >= self._score_to_win:
self.end_game()
def end_game(self) -> None:
# Stop our on-screen timer so players can see what they got.
assert self._timer is not None
self._timer.stop()
results = ba.TeamGameResults()
# If we won, set our score to the elapsed time in milliseconds.
# (there should just be 1 team here since this is co-op).
# ..if we didn't win, leave scores as default (None) which means
# we lost.
if self._won:
elapsed_time_ms = int((ba.time() - self._timer.starttime) * 1000.0)
ba.cameraflash()
ba.playsound(self._winsound)
for team in self.teams:
for player in team.players:
if player.actor:
player.actor.handlemessage(ba.CelebrateMessage())
results.set_team_score(team, elapsed_time_ms)
# Ends the activity.
self.end(results)
def _handle_base_collide(self, team: Team) -> None:
try:
player = ba.getcollision().opposingnode.getdelegate(
PlayerSpaz, True).getplayer(Player, True)
except ba.NotFoundError:
return
if not player.is_alive():
return
# If its another team's player, they scored.
player_team = player.team
if player_team is not team:
# Prevent multiple simultaneous scores.
if ba.time() != self._last_score_time:
self._last_score_time = ba.time()
self.stats.player_scored(player, 50, big_message=True)
ba.playsound(self._score_sound)
self._flash_base(team)
# Move all players on the scoring team back to their start
# and add flashes of light so its noticeable.
for player in player_team.players:
if player.is_alive():
pos = player.node.position
light = ba.newnode('light',
attrs={
'position': pos,
'color': player_team.color,
'height_attenuated': False,
'radius': 0.4
})
ba.timer(0.5, light.delete)
ba.animate(light, 'intensity', {
0: 0,
0.1: 1.0,
0.5: 0
})
new_pos = (self.map.get_start_position(player_team.id))
light = ba.newnode('light',
attrs={
'position': new_pos,
'color': player_team.color,
'radius': 0.4,
'height_attenuated': False
})
ba.timer(0.5, light.delete)
ba.animate(light, 'intensity', {
0: 0,
0.1: 1.0,
0.5: 0
})
if player.actor:
player.actor.handlemessage(
ba.StandMessage(new_pos,
random.uniform(0, 360)))
# Have teammates celebrate.
for player in player_team.players:
if player.actor:
player.actor.handlemessage(ba.CelebrateMessage(2.0))
player_team.score += 1
self._update_scoreboard()
if player_team.score >= self._score_to_win:
self.end_game()
def _handle_score(self) -> None:
""" a point has been scored """
# FIXME tidy this up
# pylint: disable=too-many-branches
# Our flag might stick around for a second or two;
# we don't want it to be able to score again.
assert self._flag is not None
if self._flag.scored:
return
# See which score region it was.
region = ba.getcollision().sourcenode
i = None
for i in range(len(self._score_regions)):
if region == self._score_regions[i].node:
break
for team in [self.teams[0], self._bot_team]:
assert team is not None
if team.id == i:
team.score += 7
# Tell all players (or bots) to celebrate.
if i == 0:
for player in team.players:
if player.actor:
player.actor.handlemessage(
ba.CelebrateMessage(2.0))
else:
self._bots.celebrate(2.0)
# If the good guys scored, add more enemies.
if i == 0:
if self.teams[0].score == 7:
assert self._bot_types_7 is not None
for bottype in self._bot_types_7:
self._spawn_bot(bottype)
elif self.teams[0].score == 14:
assert self._bot_types_14 is not None
for bottype in self._bot_types_14:
self._spawn_bot(bottype)
ba.playsound(self._score_sound)
if i == 0:
ba.playsound(self._cheer_sound)
else:
ba.playsound(self._boo_sound)
# Kill the flag (it'll respawn shortly).
self._flag.scored = True
ba.timer(0.2, self._kill_flag)
self.update_scores()
light = ba.newnode('light',
attrs={
'position': ba.getcollision().position,
'height_attenuated': False,
'color': (1, 0, 0)
})
ba.animate(light, 'intensity', {0: 0, 0.5: 1, 1.0: 0}, loop=True)
ba.timer(1.0, light.delete)
if i == 0:
ba.cameraflash(duration=10.0)
def _handle_base_collide(self, team: ba.Team) -> None:
# Attempt to pull a living ba.Player from what we hit.
cnode = ba.get_collision_info('opposing_node')
assert isinstance(cnode, ba.Node)
actor = cnode.getdelegate()
if not isinstance(actor, playerspaz.PlayerSpaz):
return
player = actor.getplayer()
if not player or not player.is_alive():
return
# If its another team's player, they scored.
player_team = player.team
if player_team is not team:
# Prevent multiple simultaneous scores.
if ba.time() != self._last_score_time:
self._last_score_time = ba.time()
self.stats.player_scored(player, 50, big_message=True)
ba.playsound(self._score_sound)
self._flash_base(team)
# Move all players on the scoring team back to their start
# and add flashes of light so its noticeable.
for player in player_team.players:
if player.is_alive():
if player.node:
pos = player.node.position
light = ba.newnode('light',
attrs={
'position': pos,
'color': player_team.color,
'height_attenuated': False,
'radius': 0.4
})
ba.timer(0.5, light.delete)
ba.animate(light, 'intensity', {
0: 0,
0.1: 1.0,
0.5: 0
})
new_pos = (self.map.get_start_position(
player_team.get_id()))
light = ba.newnode('light',
attrs={
'position': new_pos,
'color': player_team.color,
'radius': 0.4,
'height_attenuated': False
})
ba.timer(0.5, light.delete)
ba.animate(light, 'intensity', {
0: 0,
0.1: 1.0,
0.5: 0
})
if player.actor:
player.actor.handlemessage(
ba.StandMessage(new_pos,
random.uniform(0, 360)))
# Have teammates celebrate.
for player in player_team.players:
if player.actor:
player.actor.handlemessage(ba.CelebrateMessage(2.0))
player_team.gamedata['score'] += 1
self._update_scoreboard()
if (player_team.gamedata['score'] >=
self.settings_raw['Score to Win']):
self.end_game()
