def _gotNews(self, news):
# run this stuff in the context of our activity since we need
# to make nodes and stuff.. should fix the serverGet call so it
activity = self._activity()
if activity is None or activity.isFinalized(): return
with bs.Context(activity):
self._phrases = []
# show upcoming achievements in non-vr versions
# (currently too hard to read in vr)
self._usedPhrases = (
['__ACH__'] if not bs.getEnvironment()['vrMode']
else []) + [s for s in news.split('<br>\n') if s != '']
self._phraseChangeTimer = bs.Timer(
self._messageDuration+self._messageSpacing,
bs.WeakCall(self._changePhrase), repeat=True)
sc = 1.2 if (bs.getEnvironment()['interfaceType'] == 'small'
or bs.getEnvironment()['vrMode']) else 0.8
self._text = bs.NodeActor(bs.newNode('text', attrs={
'vAttach':'top',
'hAttach':'center',
'hAlign':'center',
'vrDepth':-20,
'shadow':1.0 if bs.getEnvironment()['vrMode'] else 0.4,
'flatness':0.8,
'vAlign':'top',
'color':((1, 1, 1, 1) if bs.getEnvironment()['vrMode']
else (0.7, 0.65, 0.75, 1.0)),
'scale':sc,
'maxWidth':900.0/sc,
'position':(0,-10)}))
self._changePhrase()
def __init__(self, position, team):
bsHockey.Puck.__init__(self, position)
self.team = team
self.tickrate = 100
self._timeout = 5000 / self.tickrate
self._count = self._timeout
self._tickTimer = bs.Timer(self.tickrate,
call=bs.WeakCall(self._tick),
repeat=True)
self._counter = bs.newNode('text',
owner=self.node,
attrs={
'inWorld': True,
'color': (1, 1, 1, 0.7),
'scale': 0.015,
'shadow': 0.5,
'flatness': 1.0,
'hAlign': 'center'
})
self.age = 0
self.scored = False
self.lastHoldingPlayer = None
self.light = None
self.movedSinceSpawn = False
def checkVal(val):
self._powersGiven = True
if val and spaz.isAlive():
m = bs.newNode('math',
owner=spaz,
attrs={
'input1': (0, 1.3, 0),
'operation': 'add'
})
spaz.node.connectAttr('torsoPosition', m,
'input2')
activatedText = bsUtils.PopupText(
"ACTIVATED",
color=(1, 1, 1),
scale=0.7,
offset=(0, -1, 0)).autoRetain()
m.connectAttr('output', activatedText.node,
'position')
bs.playSound(
bs.Powerup.getFactory().martyrdomPickSound,
position=spaz.node.position)
spaz.isDropped = True
spaz.dropss = bs.Timer(1,
bs.Call(checkDead),
repeat=True)
def __init__(self, pos=(0, 1, 0), sourcePlayer=None):
bs.Actor.__init__(self)
factory = self.getFactory()
self.targetSound = factory.targetSound
self.popSound = factory.popSound
if sourcePlayer is None:
self.sourcePlayers = [bs.Player(None)]
else:
self.sourcePlayers = [sourcePlayer]
self.node = bs.newNode(
'prop',
delegate=self,
attrs={
'body': 'sphere',
'position': pos,
'velocity': (0, 0, 1), # Не менять на (0, 0, 0)!
'model': factory.botModel,
'colorTexture': factory.botTexture,
'reflection': u'powerup',
'reflectionScale': (10, 10, 0),
'shadowSize': 0.5,
'extraAcceleration': (0, 20, 0),
'materials': [bs.getSharedObject("objectMaterial")]
})
bs.gameTimer(30000, bs.WeakCall(self.handleMessage, bs.DieMessage()))
self._updTimer = bs.Timer(500, bs.WeakCall(self._update), repeat=True)
def startMoving(
self
): #here we overload the default startMoving, which normally calls _update.
#self._botUpdateTimer = bs.Timer(50,bs.WeakCall(self._update),repeat=True)
self._botUpdateTimer = bs.Timer(50,
bs.WeakCall(self.zUpdate),
repeat=True)
def announceCompletion(self, sound=True):
# even though there are technically achievements when we're not signed in,
# lets not show them (otherwise we tend to get confusing 'controller connected'
# achievements popping up while waiting to log in which can be confusing..
if bsInternal._getAccountState() != 'SIGNED_IN':
return
# if we're being freshly complete, display/report it and whatnot
if not [self, sound] in gAchievementsToDisplay:
gAchievementsToDisplay.append([self, sound])
# if there's no achievement display timer going, kick one off
# (if one's already running it will pick this up before it dies)
global gAchievementDisplayTimer
global gLastAchievementDisplayTime
# need to check last time too; its possible our timer wasn't able to clear itself if an
# activity died and took it down with it..
if ((gAchievementDisplayTimer is None
or bs.getRealTime() - gLastAchievementDisplayTime > 2000)
and bs.getActivity(exceptionOnNone=False) is not None):
gAchievementDisplayTimer = bs.Timer(1000,
_displayNextAchievement,
repeat=True,
timeType='net')
_displayNextAchievement() # show the first immediately
def onBegin(self):
bs.TeamGameActivity.onBegin(self)
self._bots = bs.BotSet()
pt1 = (6.972673935, 4.380775486, -9.424407061)
pt2 = (-6.972673935, 4.380775486, -9.424407061)
pt3 = (6.972673935, 4.380775486, 3.424407061)
pt4 = (-6.972673935, 4.380775486, 3.424407061)
for i in range(self.settings['Bombers']):
bs.gameTimer(
1000,
bs.Call(self._bots.spawnBot,
bs.BomberBotStatic,
pos=random.choice([pt1, pt2, pt3, pt4]),
spawnTime=3000))
self._scoreRegions = []
self._scoreRegions.append(
bs.NodeActor(
bs.newNode('region',
attrs={
'position': (0.3, 4.044276501, -2.9),
'scale': (11.7, 15, 9.5),
'type': 'box',
'materials': (self.safeRegionMaterial, )
})))
self._timer = bs.OnScreenTimer()
bs.gameTimer(4000, self._timer.start)
self._updateTimer = bs.Timer(1000, self._onSpazBotDied, repeat=True)
def onPlayerJoin(self, player):
bs.TeamGameActivity.onPlayerJoin(self, player)
player.gameData['mines'] = []
if self.hasStarted:
call = bs.WeakCall(self._spawnMine, player)
self.mineTimers.append(
bs.Timer(int(self.mineDelay * 1000), call, repeat=True))
def giveBallz(self, spaz):
spaz.punchCallback = self.throwBall
spaz.lastBallTime = bs.getGameTime()
if self._powerExpire:
weakSpaz = weakref.ref(spaz)
spaz.snoExpireTimer = bs.Timer(
self._powerLife, bs.WeakCall(self.takeBallz, weakSpaz))
def _handleHitOwnFlag(self,team,val):
# keep track of when each player is touching their own flag so we can award points when returned
srcNode = bs.getCollisionInfo('sourceNode')
try: player = srcNode.getDelegate().getPlayer()
except Exception: player = None
if player is not None and player.exists():
if val: player.gameData['touchingOwnFlag'] += 1
else: player.gameData['touchingOwnFlag'] -= 1
# if return-time is zero, just kill it immediately.. otherwise keep track of touches and count down
if float(self.settings['Flag Touch Return Time']) <= 0.0:
if not team.gameData['homeFlagAtBase'] and team.gameData['flag']._heldCount == 0:
# use a node message to kill the flag instead of just killing our team's.
# (avoids redundantly killing new flags if multiple body parts generate callbacks in one step)
node = bs.getCollisionInfo("opposingNode")
if node is not None and node.exists():
self._awardPlayersTouchingOwnFlag(team)
node.handleMessage(bs.DieMessage())
# takes a non-zero amount of time to return
else:
if val:
team.gameData['flagReturnTouches'] += 1
if team.gameData['flagReturnTouches'] == 1:
team.gameData['touchReturnTimer'] = bs.Timer(100,call=bs.Call(self._touchReturnUpdate,team),repeat=True)
team.gameData['touchReturnTimerTicking'] = None
else:
team.gameData['flagReturnTouches'] -= 1
if team.gameData['flagReturnTouches'] == 0:
team.gameData['touchReturnTimer'] = None
team.gameData['touchReturnTimerTicking'] = None
if team.gameData['flagReturnTouches'] < 0:
bs.printError('CTF: flagReturnTouches < 0; this shouldn\'t happen.')
def setScoreText(self,text):
"""
Utility func to show a message over the flag; handy for scores.
"""
if not self.node.exists(): return
try: exists = self._scoreText.exists()
except Exception: exists = False
if not exists:
startScale = 0.0
math = bs.newNode('math',owner=self.node,attrs={'input1':(0,1.4,0),'operation':'add'})
self.node.connectAttr('position',math,'input2')
self._scoreText = bs.newNode('text',
owner=self.node,
attrs={'text':text,
'inWorld':True,
'scale':0.02,
'shadow':0.5,
'flatness':1.0,
'hAlign':'center'})
math.connectAttr('output',self._scoreText,'position')
else:
startScale = self._scoreText.scale
self._scoreText.text = text
self._scoreText.color = bs.getSafeColor(self.node.color)
bs.animate(self._scoreText,'scale',{0:startScale,200:0.02})
self._scoreTextHideTimer = bs.Timer(1000,bs.WeakCall(self._hideScoreText))
def __init__(self,
challengeID,
challengeActivity=None,
position=(0, 0),
delegate=None,
scale=None,
offset=(0, 0),
onCloseCall=None):
self._challengeID = challengeID
self._onCloseCall = onCloseCall
if scale is None:
scale = 2.3 if bsUI.gSmallUI else 1.65 if bsUI.gMedUI else 1.23
self._delegate = delegate
self._transitioningOut = False
self._challengeActivity = challengeActivity
self._width = 340
self._height = 290
self._canForfeit = False
self._forfeitButton = None
challenge = bsUI._getCachedChallenge(self._challengeID)
# this stuff shouldn't change..
if challenge is None:
self._canForfeit = False
self._prizeTickets = 0
self._prizeTrophy = None
self._level = 0
self._waitTickets = 0
else:
self._canForfeit = challenge['canForfeit']
self._prizeTrophy = challenge['prizeTrophy']
self._prizeTickets = challenge['prizeTickets']
self._level = challenge['level']
t = time.time()
self._waitTickets = max(
1,
int(challenge['waitTickets'] *
(1.0 - (t - challenge['waitStart']) /
(challenge['waitEnd'] - challenge['waitStart']))))
self._bgColor = (0.5, 0.4, 0.6)
# creates our _rootWidget
bsUI.PopupWindow.__init__(self,
position=position,
size=(self._width, self._height),
scale=scale,
bgColor=self._bgColor,
offset=offset)
self._state = None
self._updateTimer = bs.Timer(1000,
bs.WeakCall(self._update),
repeat=True,
timeType='real')
self._update()
def handleMessage(self, m):
# respawn dead players
if isinstance(m, bs.PlayerSpazDeathMessage):
bs.TeamGameActivity.handleMessage(self, m) # augment standard
self._aPlayerHasBeenKilled = True
player = m.spaz.getPlayer()
if not player.exists():
return
self.scoreSet.playerLostSpaz(player)
# respawn them shortly
respawnTime = 2000+len(self.initialPlayerInfo)*1000
player.gameData['respawnTimer'] = bs.Timer(
respawnTime, bs.Call(self.spawnPlayerIfExists, player))
player.gameData['respawnIcon'] = bs.RespawnIcon(player, respawnTime)
# whenever our evil bunny dies, respawn him and spew some eggs
elif isinstance(m, bs.SpazBotDeathMessage):
self._spawnEvilBunny()
pt = m.badGuy.node.position
for i in range(6):
s = 0.4
self._eggs.append(Egg(position=(pt[0]+random.uniform(-s, s),
pt[1]+random.uniform(-s, s),
pt[2]+random.uniform(-s, s))))
else:
# default handler:
bs.TeamGameActivity.handleMessage(self, m)
def onBegin(self):
bs.TeamGameActivity.onBegin(self)
self._updateScoreBoard()
self._targets = []
# number of targets is based on player count
numTargets = min(5,len(self.initialPlayerInfo)+2)
for i in range(numTargets):
bs.gameTimer(5000+i*1000,self._spawnTarget)
# this wrangles our bots
self._bots = bs.BotSet()
# start some timers to spawn bots
bs.gameTimer(1000,bs.Call(self._bots.spawnBot,bs.ToughGuyBot,pos=(3,3,-2),spawnTime=3000))
#bs.gameTimer(2000,bs.Call(self._bots.spawnBot,bs.ToughGuyBot,pos=(-3,3,-2),spawnTime=3000))
#bs.gameTimer(3000,bs.Call(self._bots.spawnBot,bs.NinjaBot,pos=(5,3,-2),spawnTime=3000))
#bs.gameTimer(4000,bs.Call(self._bots.spawnBot,bs.NinjaBot,pos=(-5,3,-2),spawnTime=3000))
# add a few extras for multiplayer
if len(self.initialPlayerInfo) > 2:
bs.gameTimer(5000,bs.Call(self._bots.spawnBot,bs.ToughGuyBot,pos=(0,3,-5),spawnTime=3000))
if len(self.initialPlayerInfo) > 3:
bs.gameTimer(6000,bs.Call(self._bots.spawnBot,bs.ToughGuyBot,pos=(0,3,1),spawnTime=3000))
# note: if spawns were spread out more we'd probably want to set some sort of flag on the
# last spawn to ensure we don't inadvertantly allow a 'win' before every bot is spawned.
# (ie: if bot 1, 2, and 3 got killed but 4 hadn't spawned yet, the game might end because
# it sees no remaining bots.
self._updateTimer = bs.Timer(1000,self._update,repeat=True)
self._countdown = bs.OnScreenCountdown(150,endCall=self.endGame)
bs.gameTimer(4000,self._countdown.start)
def __init__(self, position=(0, 1, 0), maxBalls=5):
bs.Actor.__init__(self)
self.balls = []
self.maxBalls = maxBalls
self.node = bs.newNode('prop',
delegate=self,
attrs={
'extraAcceleration': (0, 18, 0),
'position':
position,
'model':
bs.getModel('tnt'),
'lightModel':
bs.getModel('tnt'),
'body':
'crate',
'shadowSize':
0.5,
'colorTexture':
bs.getTexture('achievementFlawlessVictory'),
'reflection':
'soft',
'reflectionScale': [1],
'materials':
[bs.getSharedObject('objectMaterial')]
})
self.timer = bs.Timer(5000, bs.Call(self.spawnBall), repeat=True)
def spawn_hold_node(self):
if self.node is None or not self.node.exists(): return
self.delete_hold_node()
t = self.node.position
t = (t[0], t[1] + 1, t[2])
self.hold_node = bs.newNode('prop',
owner=self.node,
delegate=self,
attrs={
'position': t,
'body': 'box',
'bodyScale': 0.000001,
'model': None,
'modelScale': 0.000001,
'colorTexture': None,
'maxSpeed': 0,
'sticky': True,
'stickToOwner': True,
'owner': self.node,
'materials': []
})
self._c = c = bs.newNode('combine',
owner=self.hold_node,
attrs={'size': 3})
self._c_move = [0, 0, 0]
c.input0, c.input1, c.input2 = t
self._c.connectAttr('output', self.hold_node, 'position')
self._fly_timer = bs.Timer(100,
bs.WeakCall(self.move_hold_node, 'all'),
repeat=True)
def __init__(self,position = (0,0.5,0),owner = None,prefix = 'ADMIN',prefixColor = (1,1,1),prefixAnim = {0:(1,1,1),500:(0.5,0.5,0.5)},prefixAnimate = True,particles = True):
self.position = position
self.owner = owner
###
def a():
self.emit()
##
if particles:
self.timer = bs.Timer(10,bs.Call(a),repeat = True)
#prefix
m = bs.newNode('math', owner=self.owner, attrs={'input1': (0, 1.35, 0), 'operation': 'add'})
self.owner.connectAttr('position', m, 'input2')
self._Text = bs.newNode('text',
owner=self.owner,
attrs={'text':prefix, #prefix text
'inWorld':True,
'shadow':1.2,
'flatness':1.0,
'color':prefixColor,
'scale':0.0,
'hAlign':'center'})
m.connectAttr('output', self._Text, 'position')
bs.animate(self._Text, 'scale', {0: 0.0, 1000: 0.01}) #smooth prefix spawn
#animate prefix
if prefixAnimate:
bsUtils.animateArray(self._Text, 'color',3, prefixAnim,True) #animate prefix color
def _startBotUpdates(self):
self._botUpdateInterval = 3300 - 300*(len(self.players))
self._updateBots()
self._updateBots()
if len(self.players) > 2: self._updateBots()
if len(self.players) > 3: self._updateBots()
self._botUpdateTimer = bs.Timer(int(self._botUpdateInterval),bs.WeakCall(self._updateBots))
def onBegin(self):
bs.TeamGameActivity.onBegin(self)
# drop a wave every few seconds.. and every so often drop the time between waves
# ..lets have things increase faster if we have fewer players
#self._meteorTime = 3000
t = 7500 if len(self.players) > 2 else 4000
if self.settings['Epic Mode']: t /= 4
#bs.gameTimer(t,self._decrementMeteorTime,repeat=True)
# kick off the first wave in a few seconds
t = 3000
if self.settings['Epic Mode']: t /= 4
#bs.gameTimer(t,self._setMeteorTimer)
# this wrangles our bots
self._bots = bs.BotSet()
for i in range(self.settings['Max Bots']):
bPos = (-7.3+15.3*random.random(),10,-5.5+2.1*random.random())
bs.gameTimer(4000,bs.Call(self._bots.spawnBot,self._getRandomBotType(),pos=bPos,spawnTime=0))
self._updateTimer = bs.Timer(1000,self._onSpazBotDied,repeat=True)
self._timer = bs.OnScreenTimer()
bs.gameTimer(4000,self._timer.start)
def onBegin(self): bs.TeamGameActivity.onBegin(self) self.setupStandardTimeLimit(self.settings['Time Limit']) self.setupStandardPowerupDrops(enableTNT=True) self._boxSpawnPos = self.getMap().getFlagPosition(None) self._spawnBox() self._updateTimer = bs.Timer(1000, call=self._tick, repeat=True) self._updateBoxState()
def __init__(self,activity):
self._valid = True
self._messageDuration = 10000
self._messageSpacing = 2000
self._text = None
self._activity = weakref.ref(activity)
self._fetchTimer = bs.Timer(1000,bs.WeakCall(self._tryFetchingNews),repeat=True)
self._tryFetchingNews()
def flash(self, countdown, extraFlash):
self._flashTimer = bs.Timer(100,
bs.WeakCall(self._doFlash),
repeat=True)
if countdown: self._flashCounter = 10
else: self._flashCounter = int(20.0 * self._flashLength)
if extraFlash: self._flashCounter *= 4
self._setFlashColors(True)
def flex(actor=None):
def work(node=None):
if node is not None and node.exists(): node.handleMessage('celebrate', 1000)
if actor is not None and actor.exists():
if not hasattr(actor, '_flex') or (hasattr(actor, '_flex') and actor._flex is None):
actor._flex = bs.Timer(1000, bs.Call(work, actor.node), repeat=True)
work(node=actor.node)
else: actor._flex = None
def onBegin(self):
bs.TeamGameActivity.onBegin(self)
self.setupStandardTimeLimit(self.settings['Time Limit'])
self.setupStandardPowerupDrops(enableTNT=False)
self._pow = None
self._tntDropTimer = bs.Timer(1000 * 30, bs.WeakCall(self._dropPowBox), repeat=True)
self._updateIcons()
bs.gameTimer(1000, self._update, repeat=True)
def _update(self):
# if we're down to 1 or fewer living teams, start a timer to end the game
# (allows the dust to settle and draws to occur if deaths are close enough)
if (len([
team for team in self.teams
if team.gameData['score'] < self.settings['Score to Win']
]) < 2) or len(self.winners) > 2:
self._roundEndTimer = bs.Timer(500, self.endGame)
def handleMessage(self, m):
if isinstance(m, bs.PlayerScoredMessage):
self._score.add(m.score)
self._updateScores()
# respawn dead players
elif isinstance(m, bs.PlayerSpazDeathMessage):
self._aPlayerHasBeenKilled = True
player = m.spaz.getPlayer()
if player is None:
bs.printError('FIXME: getPlayer() should no'
' longer ever be returning None')
return
if not player.exists():
return
self.scoreSet.playerLostSpaz(player)
# respawn them shortly
respawnTime = 2000 + len(self.initialPlayerInfo) * 1000
player.gameData['respawnTimer'] = bs.Timer(
respawnTime, bs.Call(self.spawnPlayerIfExists, player))
player.gameData['respawnIcon'] = bs.RespawnIcon(
player, respawnTime)
elif isinstance(m, bs.SpazBotDeathMessage):
if m.how == 'goal':
return
pts, importance = m.badGuy.getDeathPoints(m.how)
if m.killerPlayer is not None:
try:
target = m.badGuy.node.position
except Exception:
target = None
try:
if m.killerPlayer is not None and m.killerPlayer.exists():
self.scoreSet.playerScored(m.killerPlayer,
pts,
target=target,
kill=True,
screenMessage=False,
importance=importance)
bs.playSound(self._dingSound if importance == 1 else
self._dingSoundHigh,
volume=0.6)
except Exception as e:
print 'EXC in Runaround handling SpazBotDeathMessage:', e
# normally we pull scores from the score-set, but if there's no
# player lets be explicit..
else:
self._score.add(pts)
self._updateScores()
else:
self.__superHandleMessage(m)
def onBegin(self):
bs.TeamGameActivity.onBegin(self)
self.setupStandardTimeLimit(self.settings['Time Limit'])
self.setupStandardPowerupDrops()
self._flagSpawnPos = self.getMap().getFlagPosition(None)
self._spawnFlag()
self._updateTimer = bs.Timer(1000, call=self._tick, repeat=True)
self._updateFlagState()
self.projectFlagStand(self._flagSpawnPos)
def __init__(self, position=(0, 1, 0), team=None):
bs.Actor.__init__(self)
self.errorSound = bs.getSound('error')
self.position = position
self._team = team
# Where do we place block?
self.loc = bs.newNode('shield',
attrs={
'position': position,
'radius': 0.01,
'color': (-8, -2, -2)
})
# Block.
self.body = bs.newNode('prop',
delegate=self,
attrs={
'body':
'box',
'modelScale':
1,
'bodyScale':
1,
'model':
bs.getModel('tnt'),
'colorTexture':
bs.getTexture('powerupCurse'),
'materials': [
bs.getSharedObject('footingMaterial'),
bs.getSharedObject('objectMaterial')
]
})
self.loc.connectAttr('position', self.body, 'position')
self.hp = 8000
self.frozen = False # On freeze block don't spawn enemies.
self.position = position # For spawn bots.
if self._team is None:
self._bots = bs.BotSet()
self._botSpawnCooldown = 5000
self.spawner = bs.Timer(self._botSpawnCooldown,
self._spawnBot,
repeat=True)
self._scoreText = bs.newNode('text',
owner=self.body,
attrs={
'text': 'HP: ' + str(self.hp),
'inWorld': True,
'shadow': 1.0,
'flatness': 1.0,
'color': (0, 1, 0),
'scale': 0.01,
'hAlign': 'center',
'position': self.position
})
bs.gameTimer(1000, self._scoreText.delete)
def __init__(
self, position=(0, 1, 0),
color=(1, 1, 1),
materials=[],
touchable=True, droppedTimeout=None):
"""
Instantiate a flag.
If 'touchable' is False, the flag will only touch terrain;
useful for things like king-of-the-hill where players should
not be moving the flag around.
'materials is a list of extra bs.Materials to apply to the flag.
If 'droppedTimeout' is provided (in seconds), the flag will die
after remaining untouched for that long once it has been moved
from its initial position.
"""
bs.Actor.__init__(self)
self._initialPosition = None
self._hasMoved = False
factory = self.getFactory()
if type(materials) is not list:
# in case they passed a tuple or whatnot..
materials = list(materials)
if not touchable:
materials = [factory.noHitMaterial]+materials
self.node = bs.newNode(
"flag",
attrs={'position': (position[0],
position[1] + 0.75, position[2]),
'colorTexture': factory.flagTexture, 'color': color,
'materials':
[bs.getSharedObject('objectMaterial'),
factory.flagMaterial] + materials},
delegate=self)
self._droppedTimeout = droppedTimeout
if self._droppedTimeout is not None:
self._count = self._droppedTimeout
self._tickTimer = bs.Timer(
1000, call=bs.WeakCall(self._tick),
repeat=True)
self._counter = bs.newNode(
'text', owner=self.node,
attrs={'inWorld': True, 'color': (1, 1, 1, 0.7),
'scale': 0.015, 'shadow': 0.5, 'flatness': 1.0,
'hAlign': 'center'})
else:
self._counter = None
self._heldCount = 0
def onBegin(self):
bs.TeamGameActivity.onBegin(self)
self.dropShield()
self._shieldDropper = bs.Timer(8001,
bs.WeakCall(self.dropShield),
repeat=True)
self.setupStandardTimeLimit(self.settings['Time Limit'])
bsGlobals = bs.getSharedObject('globals')
if self.settings['Obstacles']:
count = self.settings['Obstacles count']
map = bs.getActivity()._map.getName()
for i in range(count):
if map == 'Football Stadium':
radius = (random.uniform(-10, 1),
6,
random.uniform(-4.5, 4.5)) \
if i > count/2 else (random.uniform(10, 1), 6, random.uniform(-4.5, 4.5))
else:
radius = (random.uniform(-10,1),
6,
random.uniform(-8,8)) \
if i > count/2 else (random.uniform(10, 1), 6, random.uniform(-8, 8))
Boxes(position=radius,
graphics=self.settings['Graphics'],
randomColor=self.settings['Random obstacles color'],
mirror=self.settings['Obstacles mirror shots'],
form=self.settings['Obstacles form']).autoRetain()
if self.settings['Graphics'] == 2:
bsGlobals.tint = (bsGlobals.tint[0] - 0.6, bsGlobals.tint[1] - 0.6,
bsGlobals.tint[2] - 0.6)
light = bs.newNode('light', attrs={
'position': (9, 10, 0) if map == 'Football Stadium' else (6, 7, -2) \
if not map == 'Rampage' else (6, 11, -2) if not map == 'The Pad' else (6, 8.5, -2),
'color': (0.4, 0.4, 0.45),
'radius': 1,
'intensity': 6,
'volumeIntensityScale': 10.0})
light2 = bs.newNode('light', attrs={
'position': (-9, 10, 0) if map == 'Football Stadium' else (-6, 7, -2) \
if not map == 'Rampage' else (-6, 11, -2) if not map == 'The Pad' else (-6, 8.5, -2),
'color': (0.4, 0.4, 0.45),
'radius': 1,
'intensity': 6,
'volumeIntensityScale': 10.0})
if len(self.teams) > 0:
self._scoreToWin = self.settings['Kills to Win Per Player'] * max(
1, max(len(t.players) for t in self.teams))
else:
self._scoreToWin = self.settings['Kills to Win Per Player']
self._updateScoreBoard()
self._dingSound = bs.getSound('dingSmall')