def handleMessage(self,m):
if isinstance(m,bsBomb.ArmMessage):
self.arm()#This is all the main bs.Bomb does. All below is extra
self.activateArea()
elif isinstance(m, bs.HitMessage):
#print m.hitType, m.hitSubType
if self.isHome: return True
if m.sourcePlayer == self.sourcePlayer:
return True #I think this should stop mines from exploding due to self activity or chain reactions?.
if not self.activated: return True
else:
super(self.__class__, self).handleMessage(m)
elif isinstance(m,bsBomb.ImpactMessage):
if self.isHome: return True #Never explode the home bomb.
super(self.__class__, self).handleMessage(m)
elif isinstance(m,bs.DieMessage):
if self.isHome: return True #Home never dies (even if player leaves, I guess...)
if self.exists() and not self.died:
self.died = True
self.rad = 0.0
if self.zone.exists():
bs.animateArray(self.zone,'size',1,{0:[2*self.rad],1:[0]})
self.zone = None
super(self.__class__, self).handleMessage(m)
else:
super(self.__class__, self).handleMessage(m)
def mineUpdate(self):
#print self.mineCount
#purge dead mines, update their animantion, check if players died
for m in self.mines:
if not m.exists():
self.mines.remove(m)
else:
#First, check if any player is within the current death zone
for player in self.players:
if not player.actor is None:
if player.actor.isAlive():
p1 = player.actor.node.position
p2 = m.node.position
diff = (bs.Vector(p1[0] - p2[0], 0.0,
p1[2] - p2[2]))
dist = (diff.length())
if dist < m.rad:
player.actor.handleMessage(bs.DieMessage())
#Now tell the circle to grow to the new size
if m.rad < self.maxSize:
bs.animateArray(
m.zone, 'size', 1, {
0: [m.rad * 2],
self.updateRate: [(m.rad + self.growthRate) * 2]
})
#Tell the circle to be the new size. This will be the new check radius next time.
m.rad += self.growthRate
#make a new mine if needed.
if self.mineCount < self.maxMines:
pos = self.getRandomPowerupPoint()
self.mineCount += 1
self._flashMine(pos)
bs.gameTimer(950, bs.Call(self._makeMine, pos))
def updateFloatyness(self):
oldY = self.node.extraAcceleration[1]
newY = {0: 0, 1: 39, 2: 19+20*2, 3: 19+20*3}.get(self.heldBy, 0)# needs more science
time = 300 if (oldY >= newY) else 1000
keys = {0: (0, oldY, 0),
time: (0, newY, 0)}
bs.animateArray(self.node, 'extraAcceleration', 3, keys)
def __init__(self,pos):
bs.Bomb.__init__(self,position=pos,bombType='landMine')
showInSpace = False
self.died = False
self.rad = 0.3
self.zone = bs.newNode('locator',attrs={'shape':'circle','position':self.node.position,'color':(1,0,0),'opacity':0.5,'drawBeauty':showInSpace,'additive':True})
bs.animateArray(self.zone,'size',1,{0:[0.0],50:[2*self.rad]})
def handleMessage(self,m):
if isinstance(m,bs.DieMessage):
if not self.died:
self.getActivity().mineCount -= 1
self.died = True
bs.animateArray(self.zone,'size',1,{0:[2*self.rad],50:[0]})
self.zone = None
super(self.__class__, self).handleMessage(m)
else:
super(self.__class__, self).handleMessage(m)
def updateFloatyness(self):
oldY = self.node.extraAcceleration[1]
newY = {
0: 0,
1: 39,
2: 19 + 20 * 2,
3: 19 + 20 * 3
}.get(self.heldBy, 0) # needs more science
time = 300 if (oldY >= newY) else 1000
keys = {0: (0, oldY, 0), time: (0, newY, 0)}
bs.animateArray(self.node, 'extraAcceleration', 3, keys)
def __init__(self):
bs.Actor.__init__(self)
r1 = 6
n1 = bs.newNode('locator',
attrs={
'shape': 'circleOutline',
'position': (0, 4, -8),
'color': (1, 1, 1),
'opacity': .3,
'drawBeauty': False,
'additive': True
})
self._nodes = [n1]
bs.animateArray(n1, 'size', 1, {50: [0.0], 250: [r1 * 2.0]})
def __init__(self, position=(0, 0, 0), color=(0, 0, 0), radius=(.5)):
bs.Actor.__init__(self)
self._r1 = radius
if radius < 0: self._r1 = 0
self.position = position
self.color = color
n1 = bs.newNode('locator',
attrs={
'shape': 'circle',
'position': position,
'color': self.color,
'opacity': 1,
'drawBeauty': True,
'additive': True
})
bs.animateArray(n1, 'size', 1, {0: [0.0], 200: [self._r1 * 2.0]})
self._node = [n1]
def activateArea(self):
mineOK = False
if self.exists():
r = self.defRad
fudge = self.getActivity().minOverlap #This is the minimum overlap to join owner's territory (not used to check enemy overlap)
p1 = self.node.position
self.node.maxSpeed = 0.0 #We don't want mines moving around. They could leave their zone.
self.damping = 100
#First, confirm that this mine "touches" owner's mines
if self.sourcePlayer.exists():
for m in self.sourcePlayer.gameData['mines']:
if m.exists() and not m.died:
if m.rad != 0: #Don't check un-activated mines
p2 = m.node.position
diff = (bs.Vector(p1[0]-p2[0],0.0,p1[2]-p2[2]))
dist = (diff.length())
if dist < (m.rad + r)-fudge: #We check m.rad just in case it's somehow different. However, this probably shouldn't happen. Unless I change gameplay later.
mineOK = True #mine adjoins owner's territory. Will set to false if it also adjoin's enemy though.
break #Get out of the loop
takeovers = []
if mineOK:
for p in self.getActivity().players:
if not p is self.sourcePlayer:
if p.exists():
for m in p.gameData['mines']:
if m.rad != 0.0: #Don't check un-activated mines
p2 = m.node.position
diff = (bs.Vector(p1[0]-p2[0],0.0,p1[2]-p2[2]))
dist = (diff.length())
if dist < m.rad + r: #We check m.rad just in case it's somehowdifferent. However, this probably shouldn't happen. Unless I change gameplay later.
mineOK = False
takeovers = []
break
#If we made it to here and mineOK is true, we can activate. Otherwise, we'll flash red and die.
self.zone = bs.newNode('locator',attrs={'shape':'circle','position':self.node.position,'color':self.sourcePlayer.color,'opacity':0.5,'drawBeauty':False,'additive':True})
bs.animateArray(self.zone,'size',1,{0:[0.0],150:[2*r]}) #Make circle at the default radius to show players where it would go if OK
if mineOK or self.isHome:
self.activated = True
self.rad = r #Immediately set this mine's radius
else: #mine was not OK
keys = {0:(1,0,0),49:(1,0,0),50:(1,1,1),100:(0,1,0)}
bs.animateArray(self.zone,'color',3,keys,loop=True)
bs.gameTimer(800, bs.WeakCall(self.handleMessage, bs.DieMessage()), repeat=False)
def __init__(self, spaz, normalColor=(0.1, 0.5, 0.7),
maxColor=(1.0, 0.6, 0.4), maxThreshold=0.9,
minRadius=0.2,
maxRadius=1.0, timeTakes=400, willDecrease=True,
decreaseFinishCallback=None):
bs.Actor.__init__(self)
try:
if spaz is None or spaz.node is None:
return
except:
return
self.node = bs.newNode('locator', attrs={'shape': 'circle',
'color': normalColor,
'opacity': 0.5,
'drawBeauty': False,
'additive': True})
self.maxRadius = maxRadius
self.minRadius = minRadius
self.timeTakes = timeTakes
self.willDecrease = willDecrease
self.decreaseFinishCallback = decreaseFinishCallback
self._died = False
spaz.node.connectAttr('position', self.node, 'position')
bs.animateArray(self.node, 'size', 1, {0: [2 * minRadius], timeTakes: [2 * maxRadius]})
arriveMaxTime = int(maxThreshold * timeTakes)
maxRemainTime = 2 * (timeTakes - arriveMaxTime)
self.changeColorMaxTimer = bs.Timer(
arriveMaxTime, bs.WeakCall(self.changeNodeColor, maxColor))
self.startDecreaseTimer = None
self.changeColorNormalTimer = None
self.decreaseFinishTimer = None
if willDecrease:
self.changeColorNormalTimer = bs.Timer(
arriveMaxTime + maxRemainTime, bs.WeakCall(self.changeNodeColor, normalColor))
self.startDecreaseTimer = bs.Timer(timeTakes + 1, self.doDecrease)
self.decreaseFinishTimer = bs.Timer(
2 * (timeTakes + 1), bs.WeakCall(self.handleMessage, BarTooSmallToFinishMessage()))
def __init__(self, position=(0, 5, -8), color=(1, 1, 1)):
self._r1 = 0.7
self._rFudge = 0.15
bs.Actor.__init__(self)
self._position = bs.Vector(*position)
self.color = color
p1 = position
p2 = (position[0] + 1, position[1], position[2])
p3 = (position[0] - 1, position[1], position[2])
showInSpace = False
self._hit = False
n1 = bs.newNode('locator',
attrs={
'shape': 'circle',
'position': p1,
'color': self.color,
'opacity': 0.5,
'drawBeauty': showInSpace,
'additive': True
})
n2 = bs.newNode('locator',
attrs={
'shape': 'circle',
'position': p2,
'color': self.color,
'opacity': 0.5,
'drawBeauty': showInSpace,
'additive': True
})
n3 = bs.newNode('locator',
attrs={
'shape': 'circle',
'position': p3,
'color': self.color,
'opacity': 0.5,
'drawBeauty': showInSpace,
'additive': True
})
n4 = bs.newNode('light',
attrs={
'color': self.color,
'position': p1,
'intensity': .5
})
bs.animateArray(n1, 'size', 1, {0: [0.0], 200: [self._r1 * 2.0]})
bs.animateArray(n2, 'size', 1, {0: [0.0], 200: [self._r1 * 2.0]})
bs.animateArray(n3, 'size', 1, {0: [0.0], 200: [self._r1 * 2.0]})
self._nodes = [n1, n2, n3, n4]
def __init__(self,position):
self._r1 = 0.45
self._r2 = 1.1
self._r3 = 2.0
self._rFudge = 0.15
bs.Actor.__init__(self)
self._position = bs.Vector(*position)
self._hit = False
showInSpace = False # it can be handy to test with this on to make sure the projection isn't too far off from the actual object..
n1 = bs.newNode('locator',attrs={'shape':'circle','position':position,'color':(0,1,0),'opacity':0.5,'drawBeauty':showInSpace,'additive':True})
n2 = bs.newNode('locator',attrs={'shape':'circleOutline','position':position,'color':(0,1,0),'opacity':0.3,'drawBeauty':False,'additive':True})
n3 = bs.newNode('locator',attrs={'shape':'circleOutline','position':position,'color':(0,1,0),'opacity':0.1,'drawBeauty':False,'additive':True})
self._nodes = [n1,n2,n3]
bs.animateArray(n1,'size',1,{0:[0.0],200:[self._r1*2.0]})
bs.animateArray(n2,'size',1,{50:[0.0],250:[self._r2*2.0]})
bs.animateArray(n3,'size',1,{100:[0.0],300:[self._r3*2.0]})
bs.playSound(bs.getSound('laserReverse'))
def __init__(self, position=(0,1,0), velocity=(5,0,5), sourcePlayer=None, owner=None, explode=False):
bs.Actor.__init__(self)
activity = bs.getActivity()
factory = self.getFactory()
# spawn at the provided point
#random = randint(0,2)
self._spawnPos = (position[0], position[1]+0.1, position[2])
self.node = bs.newNode("prop",
attrs={'model': factory.snoModel,
'body':'sphere',
'colorTexture': factory.texSno,
'reflection':'soft',
'modelScale':0.0,
'bodyScale':0.8,
'density':1,
'reflectionScale':(0,0,1),
'shadowSize': 0.6,
'position':self._spawnPos,
'velocity':velocity,
'materials': [bs.getSharedObject('objectMaterial'), factory.ballMaterial]
},
delegate=self)
self.sourcePlayer = sourcePlayer
self.owner = owner
if factory._ballsMelt: #defaults to True.
#Snowballs should melt after some time
bs.gameTimer(1500, bs.WeakCall(self._disappear))
self._hitNodes = set()
self._exploded = False
if factory._ballsBust:
self.shouldBust = True
else:
self.shouldBust = False
if explode:
self.shouldExplode = True
else:
self.shouldExplode = False
prefixAnim = {0: (1, 0, 0), 250: (1, 1, 0), 250 * 2: (0, 1, 0), 250 * 3: (0, 1, 1), 250 * 4: (1, 0, 1),
250 * 5: (0, 0, 1), 250 * 6: (1, 0, 0)}
self.nodeShield = bs.newNode('shield', owner=self.node, attrs={'color': ((0+random.random()*4.5),(0+random.random()*4.5),(0+random.random()*4.5)),
'position': (
self.node.position[0],
self.node.position[1],
self.node.position[2] + 0.5),
'radius': 0.65})
self.node.connectAttr('position', self.nodeShield, 'position')
bs.animate(self.nodeShield,'radius',{0:0.9,200:1,400:0.9},True)
self.nodeShield2 = bs.newNode('shield', owner=self.node, attrs={'color': ((0+random.random()*4.5),(0+random.random()*4.5),(0+random.random()*4.5)),
'position': (
self.node.position[0],
self.node.position[1],
self.node.position[2] + 0.5),
'radius': 0.65})
self.node.connectAttr('position', self.nodeShield2, 'position')
m = bs.newNode('math', owner=self.node, attrs={'input1': (0, 0.7, 0), 'operation': 'add'})
self.node.connectAttr('position', m, 'input2')
self.nodeText = bs.newNode('text',
owner=self.node,
attrs={'text': 'ShieldBall',
'inWorld': True,
'shadow': 1.0,
'flatness': 1.0,
'color': (0,0,1),
'scale': 0.0,
'hAlign': 'center'})
m.connectAttr('output', self.nodeText, 'position')
bs.animate(self.nodeText, 'scale', {0: 0, 140: 0.016, 200: 0.01})
bs.animateArray(self.nodeText,'color',3,{0:(0,0,2),500:(0,2,0),1000:(2,0,0),1500:(2,2,0),2000:(2,0,2),2500:(0,1,6),3000:(1,2,0)},True)
bs.emitBGDynamics(position=self.nodeText.position, velocity=self.node.position, count=200, scale=1.4, spread=2.01, chunkType='sweat')
self.nodeLight = bs.newNode('light',
attrs={'position': self.node.position,
'color': (0,0,1),
'radius': 0.4,
'volumeIntensityScale': 0.5})
self.node.connectAttr('position', self.nodeLight, 'position')
bs.gameTimer(7000,self.nodeLight.delete)
bsUtils.animateArray(self.nodeLight, 'color', 3, prefixAnim, True)
bs.animate(self.nodeLight, "intensity", {0:1.0, 1000:1.8, 2000:1.0}, loop = True)
def doHitAtPosition(self, pos, player):
activity = self.getActivity()
# ignore hits if the game is over or if we've already been hit
if activity.hasEnded() or self._hit or not self._nodes: return 0
diff = (bs.Vector(*pos) - self._position)
diff[
1] = 0.0 # disregard y difference (our target point probably isnt exactly on the ground anyway)
dist = diff.length()
bullsEye = False
points = 0
if dist <= self._r3 + self._rFudge:
# inform our activity that we were hit
self._hit = True
self.getActivity().handleMessage(self.TargetHitMessage())
keys = {0: (1, 0, 0), 49: (1, 0, 0), 50: (1, 1, 1), 100: (0, 1, 0)}
cDull = (0.3, 0.3, 0.3)
if dist <= self._r1 + self._rFudge:
bullsEye = True
self._nodes[1].color = cDull
self._nodes[2].color = cDull
bs.animateArray(self._nodes[0], 'color', 3, keys, loop=True)
popupScale = 1.8
popupColor = (1, 1, 0, 1)
streak = player.gameData['streak']
points = 10 + min(20, streak * 2)
bs.playSound(bs.getSound('bellHigh'))
if streak > 0:
bs.playSound(
bs.getSound(
'orchestraHit4' if streak > 3 else
'orchestraHit3' if streak > 2 else
'orchestraHit2' if streak > 1 else 'orchestraHit'))
elif dist <= self._r2 + self._rFudge:
self._nodes[0].color = cDull
self._nodes[2].color = cDull
bs.animateArray(self._nodes[1], 'color', 3, keys, loop=True)
popupScale = 1.25
popupColor = (1, 0.5, 0.2, 1)
points = 4
bs.playSound(bs.getSound('bellMed'))
else:
self._nodes[0].color = cDull
self._nodes[1].color = cDull
bs.animateArray(self._nodes[2], 'color', 3, keys, loop=True)
popupScale = 1.0
popupColor = (0.8, 0.3, 0.3, 1)
points = 2
bs.playSound(bs.getSound('bellLow'))
# award points/etc.. (technically should probably leave this up to the activity)
popupStr = "+" + str(points)
# if there's more than 1 player in the game, include their names and colors
# so they know who got the hit
if len(activity.players) > 1:
popupColor = bs.getSafeColor(player.color,
targetIntensity=0.75)
popupStr += ' ' + player.getName()
bs.PopupText(popupStr,
position=self._position,
color=popupColor,
scale=popupScale).autoRetain()
# give this player's team points and update the score-board
player.getTeam().gameData['score'].add(points)
activity._updateScoreBoard()
# also give this individual player points (only applies in teams mode)
activity.scoreSet.playerScored(player,
points,
showPoints=False,
screenMessage=False)
bs.animateArray(self._nodes[0], 'size', 1, {
800: self._nodes[0].size,
1000: [0.0]
})
bs.animateArray(self._nodes[1], 'size', 1, {
850: self._nodes[1].size,
1050: [0.0]
})
bs.animateArray(self._nodes[2], 'size', 1, {
900: self._nodes[2].size,
1100: [0.0]
})
bs.gameTimer(1100, bs.Call(self.handleMessage, bs.DieMessage()))
return bullsEye
def __init__(self,
position=(0, 1, 0),
powerupType='tripleBombs',
expire=True):
"""
Create a powerup-box of the requested type at the requested position.
see bs.Powerup.powerupType for valid type strings.
"""
bs.Actor.__init__(self)
factory = self.getFactory()
self.powerupType = powerupType
self._powersGiven = False
if powerupType == 'tripleBombs': tex = factory.texBomb
elif powerupType == 'punch': tex = factory.texPunch
elif powerupType == 'iceBombs': tex = factory.texIceBombs
elif powerupType == 'impactBombs': tex = factory.texImpactBombs
elif powerupType == 'landMines': tex = factory.texLandMines
elif powerupType == 'stickyBombs': tex = factory.texStickyBombs
elif powerupType == 'shield': tex = factory.texShield
elif powerupType == 'health': tex = factory.texHealth
elif powerupType == 'curse': tex = factory.texCurse
elif powerupType == 'sloMo': tex = factory.texSloMo
elif powerupType == 'TNT': tex = factory.texTNT
elif powerupType == 'strongICE': tex = factory.texStrongICE
elif powerupType == 'speedBoots': tex = factory.texSpeedBoots
elif powerupType == 'champ': tex = factory.texChamp
elif powerupType == 'troll': tex = factory.texTroll
elif powerupType == 'spazColor': tex = factory.texSpazColor
elif powerupType == 'character': tex = factory.texCharacter
elif powerupType == 'invisible': tex = factory.texInvisible
else: raise Exception("invalid powerupType: " + str(powerupType))
if len(position) != 3:
raise Exception("expected 3 floats for position")
self.node = bs.newNode('prop',
delegate=self,
attrs={
'body':
'box',
'position':
position,
'model':
factory.model,
'lightModel':
factory.modelSimple,
'shadowSize':
0.5,
'colorTexture':
tex,
'reflection':
'powerup',
'reflectionScale': [1.0],
'materials':
(factory.powerupMaterial,
bs.getSharedObject('objectMaterial'))
})
prefixAnim = {
0: (1, 0, 0),
250: (1, 1, 0),
250 * 2: (0, 1, 0),
250 * 3: (0, 1, 1),
250 * 4: (1, 0, 1),
250 * 5: (0, 0, 1),
250 * 6: (1, 0, 0)
}
color = (0, 0, 1)
if fire.powerupName:
m = bs.newNode('math',
owner=self.node,
attrs={
'input1': (0, 0.7, 0),
'operation': 'add'
})
self.node.connectAttr('position', m, 'input2')
self.nodeText = bs.newNode('text',
owner=self.node,
attrs={
'text': powerupType,
'inWorld': True,
'shadow': 1.0,
'flatness': 1.0,
'color': color,
'scale': 0.0,
'hAlign': 'center'
})
m.connectAttr('output', self.nodeText, 'position')
bs.animate(self.nodeText, 'scale', {0: 0, 140: 0.016, 200: 0.01})
bs.animateArray(
self.nodeText, 'color', 3, {
0: (0, 0, 2),
500: (0, 2, 0),
1000: (2, 0, 0),
1500: (2, 2, 0),
2000: (2, 0, 2),
2500: (0, 1, 6),
3000: (1, 2, 0)
}, True)
bs.emitBGDynamics(position=self.nodeText.position,
velocity=self.node.position,
count=75,
scale=1.0,
spread=1.3,
chunkType='spark')
if fire.powerupShield:
self.nodeShield = bs.newNode('shield',
owner=self.node,
attrs={
'color':
color,
'position':
(self.node.position[0],
self.node.position[1],
self.node.position[2] + 0.5),
'radius':
1.2
})
self.node.connectAttr('position', self.nodeShield, 'position')
bsUtils.animateArray(self.nodeShield, 'color', 3, prefixAnim, True)
if fire.discoLights:
self.nodeLight = bs.newNode(
'light',
attrs={
'position': self.node.position,
'color': color,
'radius': 0.25, #0.4 will make it nice and bright
'volumeIntensityScale': 0.5
})
self.node.connectAttr('position', self.nodeLight, 'position')
bsUtils.animateArray(self.nodeLight, 'color', 3, prefixAnim, True)
bs.animate(self.nodeLight,
"intensity", {
0: 1.0,
1000: 1.8,
2000: 1.0
},
loop=True)
bs.gameTimer(8000, self.nodeLight.delete)
# animate in..
curve = bs.animate(self.node, "modelScale", {0: 0, 140: 1.6, 200: 1})
bs.gameTimer(200, curve.delete)
if expire:
bs.gameTimer(defaultPowerupInterval - 2500,
bs.WeakCall(self._startFlashing))
bs.gameTimer(defaultPowerupInterval - 1000,
bs.WeakCall(self.handleMessage, bs.DieMessage()))
def __init__(self,settings):
bs.TeamGameActivity.__init__(self,settings)
if self.settings['Epic Mode']: self._isSlowMotion = True
self.info = bs.NodeActor(bs.newNode('text',
attrs={'vAttach': 'bottom',
'hAlign': 'center',
'vrDepth': 0,
'color': (0,.2,0),
'shadow': 1.0,
'flatness': 1.0,
'position': (0,0),
'scale': 0.8,
'text': "Created by MattZ45986 on Github",
}))
self.roundNum = 0
self.simon = False
self.time = 5000
self._r1 = 2
n1 = bs.newNode('locator',attrs={'shape':'circle','position':(-4,0,-6),
'color':(1,0,0),'opacity':0.5,
'drawBeauty':True,'additive':True})
n2 = bs.newNode('locator',attrs={'shape':'circle','position':(0,0,-6),
'color':(0,1,0),'opacity':0.5,
'drawBeauty':True,'additive':True})
n3 = bs.newNode('locator',attrs={'shape':'circle','position':(4,0,-6),
'color':(0,0,1),'opacity':0.5,
'drawBeauty':True,'additive':True})
n4 = bs.newNode('locator',attrs={'shape':'circle','position':(-4,0,-2),
'color':(1,1,0),'opacity':0.5,
'drawBeauty':True,'additive':True})
n5 = bs.newNode('locator',attrs={'shape':'circle','position':(0,0,-2),
'color':(0,1,1),'opacity':0.5,
'drawBeauty':True,'additive':True})
n6 = bs.newNode('locator',attrs={'shape':'circle','position':(4,0,-2),
'color':(1,0,1),'opacity':0.5,
'drawBeauty':True,'additive':True})
n7 = bs.newNode('locator',attrs={'shape':'circle','position':(-4,0,2),
'color':(.5,.5,.5),'opacity':0.5,
'drawBeauty':True,'additive':True})
n8 = bs.newNode('locator',attrs={'shape':'circle','position':(0,0,2),
'color':(.5,.325,0),'opacity':0.5,
'drawBeauty':True,'additive':True})
n9 = bs.newNode('locator',attrs={'shape':'circle','position':(4,0,2),
'color':(1,1,1),'opacity':0.5,
'drawBeauty':True,'additive':True})
bs.animateArray(n1,'size',1,{0:[0.0],200:[self._r1*2.0]})
bs.animateArray(n2,'size',1,{0:[0.0],200:[self._r1*2.0]})
bs.animateArray(n3,'size',1,{0:[0.0],200:[self._r1*2.0]})
bs.animateArray(n4,'size',1,{0:[0.0],200:[self._r1*2.0]})
bs.animateArray(n5,'size',1,{0:[0.0],200:[self._r1*2.0]})
bs.animateArray(n6,'size',1,{0:[0.0],200:[self._r1*2.0]})
bs.animateArray(n7,'size',1,{0:[0.0],200:[self._r1*2.0]})
bs.animateArray(n8,'size',1,{0:[0.0],200:[self._r1*2.0]})
bs.animateArray(n9,'size',1,{0:[0.0],200:[self._r1*2.0]})
self.options = ["red", "green", "blue", "yellow", "teal", "purple", "gray", "orange", "white", "top", "bottom", "middle row", "left", "right", "center column", "outside"]
def doDecrease(self):
bs.animateArray(self.node, 'size', 1, {0: [2 * self.maxRadius], self.timeTakes: [2 * self.minRadius]})
def __init__(self, settings):
bs.TeamGameActivity.__init__(self, settings)
self.info = bs.NodeActor(
bs.newNode('text',
attrs={
'vAttach': 'bottom',
'hAlign': 'center',
'vrDepth': 0,
'color': (0, .2, 0),
'shadow': 1.0,
'flatness': 1.0,
'position': (0, 0),
'scale': 0.8,
'text': "Created by MattZ45986 on Github",
}))
self._safeZoneMaterial = bs.Material()
self._scoredis = bs.ScoreBoard()
self._safeZoneMaterial.addActions(
conditions=("theyHaveMaterial",
bs.getSharedObject('playerMaterial')),
actions=(("modifyPartCollision", "collide",
True), ("modifyPartCollision", "physical", False),
("call", "atConnect", bs.Call(self.handleSafeZoneEnter))))
self.safeZone1 = bs.newNode(
'region',
attrs={
'position': (-11, 0, 0),
'scale': (1.8, 1.8, 1.8),
'type':
'sphere',
'materials':
[self._safeZoneMaterial,
bs.getSharedObject('regionMaterial')]
})
self.safeZone2 = bs.newNode(
'region',
attrs={
'position': (11, 0, 0),
'scale': (1.8, 1.8, 1.8),
'type':
'sphere',
'materials':
[self._safeZoneMaterial,
bs.getSharedObject('regionMaterial')]
})
self.zoneLocator1 = bs.newNode('locator',
attrs={
'shape': 'circle',
'position': (-11, 0, 0),
'color': (1, 1, 1),
'opacity': 1,
'drawBeauty': True,
'additive': True
})
bs.animateArray(self.zoneLocator1, 'size', 1, {
0: [0.0],
200: [1.8 * 2.0]
})
self.zoneLocator2 = bs.newNode('locator',
attrs={
'shape': 'circle',
'position': (11, 0, 0),
'color': (1, 1, 1),
'opacity': 1,
'drawBeauty': True,
'additive': True
})
bs.animateArray(self.zoneLocator2, 'size', 1, {
0: [0.0],
200: [1.8 * 2.0]
})
def __init__(self,
position=(0, 1, 0),
powerupType='tripleBombs',
expire=True):
bs.Actor.__init__(self)
factory = self.getFactory()
if gSettingsEnabled: settings = bs.get_settings()
else: settings = {}
self.powerupType = powerupType
self._powersGiven = False
if powerupType == 'tripleBombs':
tex = factory.texBomb
name = 'TripleBombs'
elif powerupType == 'multiBombs':
tex = factory.texMultiBombs
name = 'MultiBombs'
elif powerupType == 'punch':
tex = factory.texPunch
name = 'Gloves'
elif powerupType == 'speedPunch':
tex = factory.texSpeedPunch
name = 'Gloves 2.0'
elif powerupType == 'fireworkBombs':
tex = factory.texFireworkBomb
name = 'FireWorks'
elif powerupType == 'killLaKillBombs':
tex = factory.texKillLaKillBomb
name = 'KillAll'
elif powerupType == 'poisonBombs':
tex = factory.texPoisonBomb
name = 'PoisonBomb'
elif powerupType == 'pandoraBox':
tex = factory.texPandoraBox
name = 'PandoraBox'
elif powerupType == 'yellowShield':
tex = factory.texYellowShield
name = 'YellowShield'
elif powerupType == 'jumpingBombs':
tex = factory.texJumpingBomb
name = 'JumpingBomb'
elif powerupType == 'tpBombs':
tex = factory.texTpBombs
name = 'TPBomb'
elif powerupType == 'iceBombs':
tex = factory.texIceBombs
name = 'IcyBombs'
elif powerupType == 'impactBombs':
tex = factory.texImpactBombs
name = 'ImpactBombs'
elif powerupType == 'landMines':
tex = factory.texLandMines
name = 'LandMines'
elif powerupType == 'stickyBombs':
tex = factory.texStickyBombs
name = 'StickyBombs'
elif powerupType == 'shield':
tex = factory.texShield
name = 'Bubble'
elif powerupType == 'health':
tex = factory.texHealth
name = 'Health'
elif powerupType == 'curse':
tex = factory.texCurse
name = 'Pls Touch Me'
elif powerupType == 'unbreakable':
tex = factory.texUnb
name = 'Unbreakable'
elif powerupType == 'dirtBombs':
tex = factory.texDirt
name = 'DirtBomb'
elif powerupType == 'speed':
tex = factory.texSpeed # new powerups begin
elif powerupType == 'alan':
tex = factory.texAlan
name = 'Boss'
elif powerupType == 'rdm':
tex = factory.texRDM
name = 'RandomBomb'
elif powerupType == 'randomCharacter':
tex = factory.RandomCharacter
name = 'Random Char'
elif powerupType == 'troll':
tex = factory.Troll
name = 'FunPack'
elif powerupType == 'mj':
tex = factory.texmj
name = 'MJ'
elif powerupType == 'impactMess':
tex = factory.teximpactMess
name = 'ImpactMess'
elif powerupType == 'Motion':
tex = factory.texMotion
name = 'Motion'
elif powerupType == 'invisibility':
tex = factory.texInvisibility
name = 'Invisibile'
elif powerupType == 'hijump':
tex = factory.texHiJump
name = 'Hi-Jump'
elif powerupType == 'ballon':
tex = factory.texBallon
name = 'Ballon'
elif powerupType == 'BlockPowerup':
tex = factory.texBlock
name = 'Block'
elif powerupType == 'iceImpact':
tex = factory.texiceImpact
name = 'IceImpact'
elif powerupType == 'goldenBomb':
tex = factory.texGoldenBomb
name = 'BlastyBomb'
elif powerupType == 'tbomb':
tex = factory.textbomb
name = 'TBomb'
elif powerupType == 'gluebomb':
tex = factory.texgluebomb
name = 'Broken Glue'
elif powerupType == 'weedbomb':
tex = factory.texweedbomb
name = 'WeedBomb'
elif powerupType == 'bot':
tex = factory.texBot
name = 'Buddy Bot'
elif powerupType == 'celebrate':
tex = factory.texcelebrate
name = 'Celebrate'
elif powerupType == 'FloatingMine':
tex = factory.texFloatingMine
name = 'LandMines'
elif powerupType == 'TouchMe':
tex = factory.texTouchMe
name = 'TouchMe'
elif powerupType == 'radius':
tex = factory.texRadius
name = 'Radius'
elif powerupType == 'sleep':
tex = factory.texSleep
name = 'Sleepy'
elif powerupType == 'night':
tex = factory.texNight
name = 'NiteNite'
elif powerupType == 'spazBomb':
tex = factory.texSpazBomb
name = 'SpazBomb'
elif powerupType == 'curseBomb':
tex = factory.texcurseBomb
name = 'CurseBomb'
elif powerupType == 'characterBomb':
tex = factory.texcharacterBomb
name = 'CharBomb'
elif powerupType == 'mjBomb':
tex = factory.texmjBomb
name = 'MJBomb'
elif powerupType == 'trioBomb':
tex = factory.textrioBomb
name = 'ImpactTrio'
elif powerupType == 'speedBomb':
tex = factory.texspeedBomb
name = 'ShockWave'
elif powerupType == 'healBomb':
tex = factory.texhealBomb
name = 'HealthBomb'
elif powerupType == 'nightBomb':
tex = factory.texNightBomb
name = 'AtomBomb'
elif powerupType == 'revengeBomb':
tex = factory.texrevengeBomb
name = 'RevengeBomb'
elif powerupType == 'blastBomb':
tex = factory.texblastBomb
name = 'blastBomb'
elif powerupType == 'knockBomb':
tex = factory.texknockBomb
name = 'KnockBomb'
elif powerupType == 'stickyIce':
tex = factory.texstickyIce
name = 'StickyIce'
elif powerupType == 'stickyIceTrio':
tex = factory.texstickyIceTrio
name = 'StickyIceTrio'
elif powerupType == 'stickyIceMess':
tex = factory.texstickyIceMess
name = 'StickyIceMess'
elif powerupType == 'stickyMess':
tex = factory.texStickyMess
name = 'StickyMess'
elif powerupType == 'icyMess':
tex = factory.texIcyMess
name = 'IcyMess'
elif powerupType == 'icyTrio':
tex = factory.texicyTrio
name = 'IcyTrio'
elif powerupType == 'weee':
tex = factory.texWeee
name = 'Health'
elif powerupType == 'tnt':
tex = factory.texTnt
name = 'TNT'
elif powerupType == 'boomBomb':
tex = factory.texboomBomb
name = 'KaboomBomb'
elif powerupType == 'name':
tex = factory.texName
name = 'NewName'
elif powerupType == 'highlight':
tex = factory.texHighlight
name = 'HighLight'
elif powerupType == 'spotlight':
tex = factory.texSpotlight
name = 'Spotlight'
elif powerupType == 'jumpFly':
tex = factory.texjumpFly
name = 'FlyJump'
elif powerupType == 'use':
tex = factory.texuse
name = 'FlyBomb'
elif powerupType == "antiGrav":
tex = factory.texAntiGrav
name = 'AntiGrav'
elif powerupType == "BlackHole":
tex = factory.texBlackHole
name = 'BlackHole'
elif powerupType == "Slippery":
tex = factory.texSlippery
name = 'LuckyBlock'
elif powerupType == "Box":
tex = factory.texBox
name = 'Box'
elif powerupType == 'snoball':
tex = factory.texSno
mod = factory.snoModel
name = "shieldBall"
elif powerupType == 'pass':
return
else:
raise Exception("invalid powerupType: " + str(powerupType))
if len(position) != 3:
raise Exception("expected 3 floats for position")
if powerupType == 'poisonBombs':
refScale = (0, 3, 0)
ref = 'soft'
elif powerupType == 'pandoraBox':
ref = 'soft'
refScale = (1, 1, 1)
elif powerupType == 'dirtBombs':
ref = 'soft'
refScale = (1, 0.4, 0.16)
else:
refScale = [0.95]
ref = 'powerup'
self.node = bs.newNode('prop',
delegate=self,
attrs={
'body':
'box',
'position':
position,
'model':
factory.model,
'lightModel':
factory.modelSimple,
'shadowSize':
0.48,
'colorTexture':
tex,
'reflection':
ref,
'reflectionScale':
refScale,
'materials':
(factory.powerupMaterial,
bs.getSharedObject('objectMaterial'))
})
prefixAnim = {
0: (1, 0, 0),
250: (1, 1, 0),
250 * 2: (0, 1, 0),
250 * 3: (0, 1, 1),
250 * 4: (1, 0, 1),
250 * 5: (0, 0, 1),
250 * 6: (1, 0, 0)
}
color = (0, 0, 1)
if don.powerupName:
m = bs.newNode('math',
owner=self.node,
attrs={
'input1': (0, 0.7, 0),
'operation': 'add'
})
self.node.connectAttr('position', m, 'input2')
self.nodeText = bs.newNode('text',
owner=self.node,
attrs={
'text': str(name),
'inWorld': True,
'shadow': 1.0,
'flatness': 1.0,
'color': color,
'scale': 0.0,
'hAlign': 'center'
})
m.connectAttr('output', self.nodeText, 'position')
bs.animate(self.nodeText, 'scale', {0: 0, 140: 0.016, 200: 0.01})
bs.animateArray(
self.nodeText, 'color', 3, {
0: (0, 0, 2),
500: (0, 2, 0),
1000: (2, 0, 0),
1500: (2, 2, 0),
2000: (2, 0, 2),
2500: (0, 1, 6),
3000: (1, 2, 0)
}, True)
bs.emitBGDynamics(position=self.nodeText.position,
velocity=self.node.position,
count=200,
scale=1.4,
spread=2.01,
chunkType='sweat')
if don.shieldOnPowerUps:
self.nodeShield = bs.newNode('shield',
owner=self.node,
attrs={
'color':
color,
'position':
(self.node.position[0],
self.node.position[1],
self.node.position[2] + 0.5),
'radius':
1.2
})
self.node.connectAttr('position', self.nodeShield, 'position')
bsUtils.animateArray(self.nodeShield, 'color', 3, prefixAnim, True)
if don.discoLights:
self.nodeLight = bs.newNode('light',
attrs={
'position': self.node.position,
'color': color,
'radius': 0.2,
'volumeIntensityScale': 0.5
})
self.node.connectAttr('position', self.nodeLight, 'position')
bsUtils.animateArray(self.nodeLight, 'color', 3, prefixAnim, True)
bs.animate(self.nodeLight,
"intensity", {
0: 1.0,
1000: 1.8,
2000: 1.0
},
loop=True)
bs.gameTimer(8000, self.nodeLight.delete)
if don.powerupTimer:
self.powerupHurt = bs.newNode('shield',
owner=self.node,
attrs={
'color': (1, 1, 1),
'radius': 0.1,
'hurt': 1,
'alwaysShowHealthBar': True
})
self.node.connectAttr('position', self.powerupHurt, 'position')
bs.animate(self.powerupHurt, 'hurt', {
0: 0,
defaultPowerupInterval - 1000: 1
})
bs.gameTimer(defaultPowerupInterval - 1000, bs.Call(self.do_delete))
curve = bs.animate(self.node, "modelScale", {0: 0, 140: 1.6, 200: 1})
bs.gameTimer(200, curve.delete)
if expire:
bs.gameTimer(defaultPowerupInterval - 2500,
bs.WeakCall(self._startFlashing))
bs.gameTimer(defaultPowerupInterval - 1000,
bs.WeakCall(self.handleMessage, bs.DieMessage()))
def fadeToRed(self):
g = bs.getSharedObject('globals')
currentTint = g.tint
bs.animateArray(g, 'tint', 3, {1: currentTint, 6000: (1, 0, 0)})
