def _updateText(self):
if self.ready:
# once we're ready, we've saved the name, so lets ask the system
# for it so we get appended numbers and stuff
text = bs.Lstr(value=self._player.getName(full=True))
text = bs.Lstr(value='${A} (${B})',
subs=[('${A}', text),
('${B}', bs.Lstr(resource='readyText'))])
else:
text = bs.Lstr(value=self._getName(full=True))
canSwitchTeams = len(self.getLobby()._teams) > 1
# flash as we're coming in
finColor = bs.getSafeColor(self.getColor()) + (1, )
if not self._inited:
bsUtils.animateArray(self._textNode, 'color', 4, {
150: finColor,
250: (2, 2, 2, 1),
350: finColor
})
else:
# blend if we're in teams mode; switch instantly otherwise
if canSwitchTeams:
bsUtils.animateArray(self._textNode, 'color', 4, {
0: self._textNode.color,
100: finColor
})
else:
self._textNode.color = finColor
self._textNode.text = text
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 powerUpImage(self,image,pos,color,alpha):
powerimage = bs.newNode('image', delegate=self, attrs={
'texture':image,
'position':pos,
'scale':(80,80),
'tiltTranslate':0,
'hasAlphaChannel':alpha,
#'opacity':0.5,
'color':color})
bsUtils.animateArray(powerimage, 'scale', 1, {2:(80,80), 550:(75, 75),1100:(80,80)},loop=True)
def dayCycle():
if bsInternal._getForegroundHostActivity() is not None:
tint = get_tint()
anim={0: tint, 7500:(1.25, 1.21, 1.075),
30000: (1.25, 1.21, 1.075), 57500: (1.1, 0.86, 0.74),
67500: (1.1, 0.86, 0.74), 90000: (0, 0.27, 0.51),
120000: (0, 0.27, 0.51), 142500: (1.3, 1.06, 1.02),
157500: (1.3, 1.06, 1.02), 180000: (1.3, 1.25, 1.2),
195500: (1.3, 1.25, 1.2), 220000: tint}
bsUtils.animateArray(bs.getSharedObject("globals"), "tint", 3, anim, loop=True)
def lightningBolt(self,position = (0,10,0),radius = 10):
bs.shakeCamera(3)
self.tint = bs.getSharedObject('globals').tint
light = bs.newNode('light',
attrs={'position':position,
'color': (0.2,0.2,0.4),
'volumeIntensityScale': 1.0,
'radius':radius})
bsUtils.animate(light,"intensity",{0:1,50:radius,150:radius/2,250:0,260:radius,410:radius/2,510:0})
bsUtils.animateArray(bs.getSharedObject('globals'),"tint",3,{0:self.tint,200:(0.2,0.2,0.2),510:self.tint})
bs.playSound(bs.getSound('grom'),volume = 10,position = (0,10,0))
def _updateIcon(self):
if self.profileNames[self.profileIndex] == '_edit':
tex = bs.getTexture('black')
tintTex = bs.getTexture('black')
self.icon.color = (1, 1, 1)
self.icon.texture = tex
self.icon.tintTexture = tintTex
self.icon.tintColor = (0, 1, 0)
return
try:
texName = bsSpaz.appearances[self.characterNames[
self.characterIndex]].iconTexture
tintTexName = bsSpaz.appearances[self.characterNames[
self.characterIndex]].iconMaskTexture
except Exception:
bs.printException('Error updating char icon list')
texName = 'neoSpazIcon'
tintTexName = 'neoSpazIconColorMask'
tex = bs.getTexture(texName)
tintTex = bs.getTexture(tintTexName)
self.icon.color = (1, 1, 1)
self.icon.texture = tex
self.icon.tintTexture = tintTex
c = self.getColor()
c2 = self.getHighlight()
canSwitchTeams = len(self.getLobby()._teams) > 1
# if we're initing, flash
if not self._inited:
bsUtils.animateArray(self.icon, 'color', 3, {
150: (1, 1, 1),
250: (2, 2, 2),
350: (1, 1, 1)
})
# blend in teams mode; switch instantly in ffa-mode
if canSwitchTeams:
bsUtils.animateArray(self.icon, 'tintColor', 3, {
0: self.icon.tintColor,
100: c
})
else:
self.icon.tintColor = c
self.icon.tint2Color = c2
# finColor = (0.2+0.8*c[0],0.2+0.8*c[1],0.2+0.8*c[2])
# store the icon info the the player
self._player._setIconInfo(texName, tintTexName, c, c2)
def doCirle():
if self.isAlive():
p = self.node.position
p2 = self.lastPos
diff = (bs.Vector(p[0]-p2[0],0.0,p[2]-p2[2]))
dist = (diff.length())
if dist > 0.2:
c = bs.getConfig()["effectsMod"]["color"]
r = bs.newNode('locator',attrs={'shape':'circle','position':p,'color':self.node.color if c else (5,5,5),'opacity':1,'drawBeauty':False,'additive':False,'size':[0.2]})
bsUtils.animateArray(r,'size',1,{0:[0.2],2500:[0.2],3000:[0]})
bs.gameTimer(3000,r.delete)
self.lastPos = self.node.position
def off():
op = 1
try:
bsInternal._getForegroundHostActivity().getMap(
).node.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).bg.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).bg.node.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).node1.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).node2.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).node3.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).steps.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).floor.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).center.opacity = op
except:
pass
bsUtils.animateArray(
bs.getSharedObject('globals'), 'vignetteOuter', 3,
{
0: bs.getSharedObject('globals').vignetteOuter,
100: std
})
def __init__(self,
position=(0, 2, 0),
owner=None,
kd=0.0,
prefix='smoothy',
prefixColor=(1, 1, 1),
prefixAnim={
0: (1, 1, 1),
500: (0.5, 0.5, 0.5)
},
prefixAnimate=False,
particles=False):
self.position = position
self.owner = owner
#particles
if particles:
self.timer = bs.Timer(10, bs.Call(a), repeat=True)
#prefix
n = bs.newNode('math',
owner=self.owner,
attrs={
'input1': (0, 1.3, 0),
'operation': 'add'
})
self.owner.connectAttr('position', n, 'input2')
self._Text = bs.newNode(
'text',
owner=self.owner,
attrs={
'text': " K.D:" + str(kd), #prefix text
'inWorld': True,
'shadow': 0.7,
'flatness': 1.0,
'color': prefixColor,
'scale': -0.8,
'hAlign': 'center'
})
n.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 updatePosition(self):
# hmmm this shouldnt be happening..
if not self._textNode.exists():
'Err: chooser text nonexistant..'
import traceback
traceback.print_stack()
return
spacing = 350
offs = spacing*-0.5*len(self.getLobby()._teams) + spacing*self._selectedTeamIndex + 250
if len(self.getLobby()._teams) > 1: offs -= 35
curPosition = self._textNode.position
bsUtils.animateArray(self._textNode,'position',2,{0:self._textNode.position,100:(-100+offs,self._vPos+23)})
bsUtils.animateArray(self.icon,'position',2,{0:self.icon.position,100:(-130+offs,self._vPos+22)})
def waveDelay(self):
bs.playSound(bs.getSound('gong'))
globals = bs.getSharedObject('globals')
tint = globals.tint
bsUtils.animateArray(bs.getSharedObject('globals'),"tint",3,{0:tint,1000:(0.2,0.2,0.2),2500:(1.2,1.2,1.2),4000:(1.3,1.3,1.3),5000:tint})
bs.Powerup(powerupType = random.choice(['health','shield','punch','impactBombs','curse']),position = self.getRandomPosV(),expire = False).autoRetain()
if random.random() > 0.3:
bs.gameTimer(200,bs.Call(bs.Powerup,powerupType = random.choice(['health','shield','punch','impactBombs']),position = self.getRandomPosV(),expire = False))
bs.Powerup(powerupType = random.choice(['health','shield','punch','impactBombs','curse']),position = self.getRandomPosV(),expire = False).autoRetain()
if random.random() > 0.6:
bs.gameTimer(400,bs.Call(bs.Powerup,powerupType = random.choice(['health','shield','punch','impactBombs']),position = self.getRandomPosV(),expire = False))
bs.gameTimer(5000,bs.Call(self.startNextWave,self.num))
def deleteZone(self):
scl = self.zone.size
bsUtils.animateArray(self.zone, 'size', 1, {0: scl, 350: [0]})
def a():
self.zone.delete()
self.zone = None
self.zoneLimit.delete()
self.zoneLimit = None
bs.playSound(bs.getSound('shieldDown'))
bs.gameTimer(1000, self.spawnZone)
bs.gameTimer(350, a)
def _doNight(self):
self._isSleep = False
self.tint = bs.getSharedObject('globals').tint
bsUtils.animateArray(bs.getSharedObject('globals'), "tint", 3, {
0: self.tint,
1000: (0.3, 0.3, 0.6)
})
bs.playSound(bs.getSound('shieldUp'), volume=10, position=(0, 10, 0))
self._repeaterOne = bs.Timer(450,
bs.WeakCall(self._doSleep),
repeat=True) #shutdown our spazs
self._repeaterTwo = bs.Timer(random.randrange(1000, 10000),
bs.WeakCall(
self._doWakeUp)) #wakeup our spazs
def __init__(self,position = (0,2,0),owner = None,kd=0.0,kills=0,prefix = ' ',prefixColor = (1,1,1),prefixAnim = {0:(1,1,1),500:(0.5,0.5,0.5)},prefixAnimate = False,particles = True):
self.position = position
self.owner = owner
def a():
self.emit()
#particles
if kd>1.1:
self.timer = bs.Timer(10,bs.Call(a),repeat = True)
#prefix
m = bs.newNode('math', owner=self.owner, attrs={'input1': (0, 1.8, 0), 'operation': 'add'})
self.owner.connectAttr('position', m, 'input2')
if kd>1.1: #customize here the criteria for being noob or pro like change to kd>0.7 or kd>2.0 or making it more tough
prefix='PRO!'
prefixColor=(0,1,0)
if kd<0.2:
prefix='NOOB!'
prefixColor=(1,0,0)
if kills==0:
prefix='New'
prefixColor=(0,0,1)
# n = bs.newNode('math', owner=self.owner, attrs={'input1': (0, 1, 0), 'operation': 'add'})
# self.owner.connectAttr('position', n, '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.2,
'hAlign':'center'})
m.connectAttr('output', self._Text, 'position')
# n.connectAttr('output', self._kd, '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 __init__(self, position=(0, 1, 0), color=(1, 0, 0), player=None):
bs.Actor.__init__(self)
self.radius = .6
self.position = position
self.player = player
self.color = color
self.erupted = False
self.volcanoMaterial = bs.Material()
self.volcanoMaterial.addActions(
conditions=(('theyHaveMaterial',
bs.getSharedObject('playerMaterial'))),
actions=(("modifyPartCollision", "collide",
True), ("modifyPartCollision", "physical", False),
("message", "theirNode", "atConnect",
bs.DieMessage()), ("call", "atConnect", self.erupt)))
self.node1 = bs.newNode('region',
attrs={
'position':
(self.position[0], self.position[1],
self.position[2]),
'scale':
(self.radius, self.radius, self.radius),
'materials': [self.volcanoMaterial]
})
self.light = bs.newNode('locator',
attrs={
'shape':
'circle',
'position':
(self.position[0], self.position[1] - 2,
self.position[2]),
'color': (1, 0, 0),
'opacity':
0.5,
'drawBeauty':
True,
'additive':
True
})
bsUtils.animateArray(self.node1, "scale", 3, {
0: (0, 0, 0),
500: (self.radius, self.radius, self.radius)
})
bs.gameTimer(10000, self.die)
def __init__(self,position1 = (0,1,0),color = (random.random(),random.random(),random.random()),r = 1.0,activity = None):
bs.Actor.__init__(self)
self.radius = r
if position1 is None:
self.position1 = self.getRandomPosition(activity)
else :
self.position1 = position1
self.position2 = self.getRandomPosition(activity)
self.portal1Material = bs.Material()
self.portal1Material.addActions(conditions=(('theyHaveMaterial', bs.getSharedObject('playerMaterial'))),actions=(("modifyPartCollision","collide",True),
("modifyPartCollision","physical",False),
("call","atConnect", self.Portal1)))
self.portal2Material = bs.Material()
self.portal2Material.addActions(conditions=(('theyHaveMaterial', bs.getSharedObject('playerMaterial'))),actions=(("modifyPartCollision","collide",True),
("modifyPartCollision","physical",False),
("call","atConnect", self.Portal2)))
# uncomment the following lines to teleport objects also
# self.portal1Material.addActions(conditions=(('theyHaveMaterial', bs.getSharedObject('objectMaterial')),'and',('theyDontHaveMaterial', bs.getSharedObject('playerMaterial'))),actions=(("modifyPartCollision","collide",True),
# ("modifyPartCollision","physical",False),
# ("call","atConnect", self.objPortal1)))
# self.portal2Material.addActions(conditions=(('theyHaveMaterial', bs.getSharedObject('objectMaterial')),'and',('theyDontHaveMaterial', bs.getSharedObject('playerMaterial'))),actions=(("modifyPartCollision","collide",True),
# ("modifyPartCollision","physical",False),
# ("call","atConnect", self.objPortal2)))
self.node1 = bs.newNode('region',
attrs={'position':(self.position1[0],self.position1[1],self.position1[2]),
'scale':(self.radius,self.radius,self.radius),
'type':'sphere',
'materials':[self.portal1Material]})
self.visualRadius = bs.newNode('shield',attrs={'position':self.position1,'color':color,'radius':0.1})
bsUtils.animate(self.visualRadius,"radius",{0:0,500:self.radius*2})
bsUtils.animateArray(self.node1,"scale",3,{0:(0,0,0),500:(self.radius,self.radius,self.radius)})
self.node2 = bs.newNode('region',
attrs={'position':(self.position2[0],self.position2[1],self.position2[2]),
'scale':(self.radius,self.radius,self.radius),
'type':'sphere',
'materials':[self.portal2Material]})
self.visualRadius2 = bs.newNode('shield',attrs={'position':self.position2,'color':color,'radius':0.1})
bsUtils.animate(self.visualRadius2,"radius",{0:0,500:self.radius*2})
bsUtils.animateArray(self.node2,"scale",3,{0:(0,0,0),500:(self.radius,self.radius,self.radius)})
def Delay(): # delay for sync coz our spazs are very lazy
bs.playSound(bs.getSound('healthPowerup'),
volume=10,
position=(0, 10, 0))
if self.getMap().getName() == 'Lake Frigid':
self.tint = bs.getSharedObject('globals').tint
bsUtils.animateArray(bs.getSharedObject('globals'), "tint", 3,
{
0: self.tint,
1000: (1, 1, 1)
})
elif self.getMap().getName() == 'Big G':
self.tint = bs.getSharedObject('globals').tint
bsUtils.animateArray(bs.getSharedObject('globals'), "tint", 3,
{
0: self.tint,
1000: (1.1, 1.2, 1.3)
})
self._organizer()
def __init__(self,
owner=None,
prefix='',
prefixColor=(1, 1, 1),
prefixAnim={
0: (0, 0, 0),
10: (1, 1, 1)
},
prefixAnimate=True,
particles=True,
type='spark'):
self.owner = owner
self.particles_type = type
self.prefix_string = prefix
def a():
self.emit()
if self.owner is not None:
if particles: self.timer = bs.Timer(100, bs.Call(a), repeat=True)
m = bs.newNode('math',
owner=self.owner,
attrs={
'input1': (0, 1.55, 0),
'operation': 'add'
})
self.owner.connectAttr('position', m, 'input2')
self.prefix = bs.newNode('text',
owner=self.owner,
attrs={
'text': self.prefix_string,
'inWorld': True,
'shadow': 0.7,
'flatness': 1.0,
'color': prefixColor,
'scale': 0.01,
'hAlign': 'center',
'maxWidth': 100
})
m.connectAttr('output', self.prefix, 'position')
if prefixAnimate:
bsUtils.animateArray(self.prefix, 'color', 3, prefixAnim, True)
def moveZone(self):
if self.zonePos[0] > 0:
x = random.randrange(0, 10)
else:
x = random.randrange(-10, 0)
if self.zonePos[2] > 0:
y = random.randrange(0, 5)
else:
y = random.randrange(-5, 0)
newPos = (x, 0.0, y)
bsUtils.animateArray(self.zone, 'position', 3, {
0: self.zone.position,
8000: newPos
})
bsUtils.animateArray(self.zoneLimit, 'position', 3, {
0: self.zoneLimit.position,
8000: newPos
})
def doEnd(self,outcome):
bs.playMusic(None)
if self._score2 > 500:
outcome = 'defeat'
self._score2 = 0
self.end(results={'outcome':outcome,'score':self._score2,'playerInfo':self.initialPlayerInfo},delay = 3000)
if outcome == 'defeat':
self._bots.finalCelebrate()
self.fadeToRed()
elif outcome == 'victory':
tint = bs.getSharedObject('globals').tint
bsUtils.animateArray(bs.getSharedObject('globals'),"tint",3,{0:tint,1000:(1.4,1.4,1.4)})
self.cameraFlash()
import bsAchievement
bsAchievement._awardLocalAchievement('Boss')
import settings
settings.bolt = True
settings.duck = True
settings.saveSettings()
def __init__(self,timer = 10):
if bs.getActivity() is not None:
try:
def showZoomMessage():
bs.getActivity().showZoomMessage("Server closes!!!")
showZoomMessage()
if timer*1000 > 3000: bs.gameTimer(3000,bs.Call(showZoomMessage))
except Exception: pass
a = bs.newNode('globals')
bsUtils.animateArray(a,'tint',3,{0:bs.getSharedObject('globals').tint,(timer)*1000:(0.0,0.0,0.0)})
def flash():
bsUtils.animateArray(a,'tint',3,{0:bs.getSharedObject('globals').tint,999:(7.0,7.0,7.0)})
bs.gameTimer(1400+timer*1000,bs.Call(flash))
bs.screenMessage("The server will close after "+ str(timer) +" seconds!")
print "The server will close after "+ str(timer) +" seconds!"
def printTimer(time):
bs.screenMessage(str(time))
print time
if time == -1:
bs.quit()
for i in range(timer+2):
bs.gameTimer(((timer+2)-i)*1000,bs.Call(printTimer,i-1))
def spawnZone(self):
self.zonePos = (random.randrange(-10,
10), 0.0, random.randrange(-5, 5))
self.zone = bs.newNode('locator',
attrs={
'shape': 'circle',
'position': self.zonePos,
'color': (1, 1, 0),
'opacity': 0.5,
'drawBeauty': True,
'additive': False
})
self.zoneLimit = bs.newNode('locator',
attrs={
'shape': 'circleOutline',
'position': self.zonePos,
'color': (1, 0.2, 0.2),
'opacity': 0.8,
'drawBeauty': True,
'additive': False
})
bsUtils.animateArray(
self.zone, 'size', 1, {
0: [0],
300: [self.getPlayersCount() * 0.85],
350: [self.getPlayersCount() * 1]
})
bsUtils.animateArray(
self.zoneLimit, 'size', 1, {
0: [0],
300: [self.getPlayersCount() * 1.2],
350: [self.getPlayersCount() * 1.1]
})
bs.playSound(bs.getSound('laserReverse'))
self.startTimer()
self.moveZone()
def doRing(self,type='in'):
p = self.node.position
pos = (p[0],p[1]-0.3,p[2])
c = bs.getConfig()["effectsMod"]["color"]
if type == 'in': do = False
elif type == 'out': do = False
elif type == 'xplode': do = True
elif type == 'show':do = False
else: do = True
m = bs.newNode('math', owner=self.node, attrs={'input1': (0, 0, 0), 'operation': 'add'})
self.node.connectAttr('position', m, 'input2')
ring = bs.newNode('locator',attrs={'shape':'circleOutline','position':pos,
'color':self.node.color if c else (5,5,5),'opacity':1,'drawBeauty':do,'additive':False,'size':[2]})
m.connectAttr('output', ring, 'position')
if type == 'in':
time = 300
bsUtils.animateArray(ring,'size',1,{0:[5],300:[0]})
bs.animate(ring, 'opacity', {0:0, 160:1})
elif type == 'out':
time = 500
bsUtils.animateArray(ring,'size',1,{0:[0],500:[4]})
bs.animate(ring, 'opacity', {0:1, 500:0})
elif type == 'xplode':
time = 700
bsUtils.animateArray(ring,'size',1,{0:[0],700:[100]})
bs.animate(ring, 'opacity', {0:1, 600:0})
elif type == 'show':
time = 2000
bsUtils.animateArray(ring,'size',1,{0:[0],200:[2.2],300:[1.8],1700:[1.8],1800:[2.2],2000:[0]})
#bs.animate(ring, 'opacity', {0:1, 1800:0})
else: time = 200
bs.gameTimer(time,ring.delete)
def __init__(self, vPos, player, lobby):
import bsInternal
self._deekSound = bs.getSound('deek')
self._clickSound = bs.getSound('click01')
self._punchSound = bs.getSound('punch01')
self._swishSound = bs.getSound('punchSwish')
self._errorSound = bs.getSound('error')
self._maskTexture = bs.getTexture('characterIconMask')
self._vPos = vPos
self._lobby = weakref.ref(lobby)
self._player = player
self._inited = False
self._dead = False
# load available profiles either from the local config or from the
# remote device..
self.reloadProfiles()
# note: this is just our local index out of available teams; *not*
# the team ID!
self._selectedTeamIndex = self.getLobby().nextAddTeam
# store a persistent random character index; we'll use this for the
# '_random' profile. Let's use their inputDevice id to seed it.. this
# will give a persistent character for them between games and will
# distribute characters nicely if everyone is random
try:
inputDeviceID = self._player.getInputDevice().getID()
except Exception as e:
print 'ERROR: exc getting inputDeviceID for chooser creation:', e
inputDeviceID = 0
import traceback
traceback.print_stack()
# we want the first device that asks for a chooser to always get
# spaz as a random character..
global gRandomCharIndexOffset
if gRandomCharIndexOffset is None:
# scratch that.. we now kinda accomplish the same thing with
# account profiles so lets just be fully random here..
gRandomCharIndexOffset = random.randrange(1000)
# to calc our random index we pick a random character out of our
# unlocked list and then locate that character's index in the full list
self._randomCharacterIndex = (
(inputDeviceID + gRandomCharIndexOffset) %
len(self.characterNames))
self._randomColor, self._randomHighlight = \
bsUtils.getPlayerProfileColors(None)
global gAccountProfileDeviceID
# attempt to pick an initial profile based on what's been stored
# for this input device
try:
inputDevice = self._player.getInputDevice()
name = inputDevice.getName()
uniqueID = inputDevice.getUniqueIdentifier()
self.profileName = (
bs.getConfig()['Default Player Profiles'][name + ' ' +
uniqueID])
self.profileIndex = self.profileNames.index(self.profileName)
# if this one is __account__ and is local and we havn't marked
# anyone as the account-profile device yet, mark this guy as it.
# (prevents the next joiner from getting the account profile too)
if (self.profileName == '__account__'
and not inputDevice.isRemoteClient()
and gAccountProfileDeviceID is None):
gAccountProfileDeviceID = inputDeviceID
# well hmm that didn't work.. pick __account__, _random, or some
# other random profile..
except Exception:
profileNames = self.profileNames
# we want the first local input-device in the game to latch on to
# the account profile
if (not inputDevice.isRemoteClient()
and not inputDevice.isControllerApp()):
if (gAccountProfileDeviceID is None
and '__account__' in profileNames):
gAccountProfileDeviceID = inputDeviceID
# if this is the designated account-profile-device, try to default
# to the account profile
if (inputDeviceID == gAccountProfileDeviceID
and '__account__' in profileNames):
self.profileIndex = profileNames.index('__account__')
else:
# if this is the controller app, it defaults to using a random
# profile (since we can pull the random name from the app)
if inputDevice.isControllerApp():
self.profileIndex = profileNames.index('_random')
else:
# if its a client connection, for now just force the account
# profile if possible.. (need to provide a way for clients
# to specify/remember their default profile)
if (inputDevice.isRemoteClient()
and '__account__' in profileNames):
self.profileIndex = profileNames.index('__account__')
else:
global gRandProfileIndex
# cycle through our non-random profiles once; after
# that, everyone gets random.
while (gRandProfileIndex < len(profileNames)
and profileNames[gRandProfileIndex]
in ('_random', '__account__', '_edit')):
gRandProfileIndex += 1
if gRandProfileIndex < len(profileNames):
self.profileIndex = gRandProfileIndex
gRandProfileIndex += 1
else:
self.profileIndex = profileNames.index('_random')
self.profileName = profileNames[self.profileIndex]
self.characterIndex = self._randomCharacterIndex
self._color = self._randomColor
self._highlight = self._randomHighlight
self.ready = False
self._textNode = bs.newNode('text',
delegate=self,
attrs={
'position': (-100, self._vPos),
'maxWidth': 160,
'shadow': 0.5,
'vrDepth': -20,
'hAlign': 'left',
'vAlign': 'center',
'vAttach': 'top'
})
bsUtils.animate(self._textNode, 'scale', {0: 0, 100: 1.0})
self.icon = bs.newNode('image',
owner=self._textNode,
attrs={
'position': (-130, self._vPos + 20),
'maskTexture': self._maskTexture,
'vrDepth': -10,
'attach': 'topCenter'
})
bsUtils.animateArray(self.icon, 'scale', 2, {0: (0, 0), 100: (45, 45)})
self._setReady(False)
# set our initial name to '<choosing player>' in case anyone asks..
self._player.setName(bs.Lstr(resource='choosingPlayerText').evaluate(),
real=False)
self.updateFromPlayerProfile()
self.updatePosition()
self._inited = True
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 onTransitionIn(self):
bs.Activity.onTransitionIn(self)
global gDidInitialTransition
random.seed(123)
try:
import install
except ImportError:
pass
else:
# check needed methods
if hasattr(bs, "get_setting") and hasattr(install,
"update_modpack"):
if bs.get_setting("auto-update", False):
install.update_modpack(True)
self._logoNode = None
self._customLogoTexName = None
self._wordActors = []
env = bs.getEnvironment()
vrMode = bs.getEnvironment()['vrMode']
if not bs.getEnvironment().get('toolbarTest', True):
self.myName = bs.NodeActor(
bs.newNode(
'text',
attrs={
'vAttach':
'bottom',
'hAlign':
'center',
'color': (1, 1, 1, 1) if vrMode else (1, 1, 1, 1),
'flatness':
1.0,
'shadow':
1.0 if vrMode else 0.5,
'scale':
(0.65 if (env['interfaceType'] == 'small' or vrMode)
else 0.7), # FIXME need a node attr for this
'position': (0, 25),
'vrDepth':
-10,
'text':
u'\xa9 2019 Eric Froemling'
}))
fullScreen = bsInternal._getSetting("TV Border")
if env['interfaceType'] != 'small' or env['vrMode']:
if fullScreen: position = (0, -10)
else: position = (-425, 10)
else:
if fullScreen: position = (0, -10)
else: position = (-425, 35)
self.moderName = bs.NodeActor(
bs.newNode(
'text',
attrs={
'vAttach':
'bottom',
'hAlign':
'center',
'color': (0.8, 0.8, 0.8, 0.8) if vrMode else
(0.8, 0.8, 0.8, 0.8),
'flatness':
1.0,
'shadow':
1.0 if vrMode else 0.5,
'scale': (0.55 if
(env['interfaceType'] == 'small' or vrMode)
else 0.7), # FIXME need a node attr for this
'position':
position,
'vrDepth':
-10,
'text':
u'\xa9 ModPack is created by Daniil Rakhov'
}))
self._hostIsNavigatingText = bs.NodeActor(
bs.newNode('text',
attrs={
'text':
bs.Lstr(resource='hostIsNavigatingMenusText',
subs=[
('${HOST}',
bsInternal._getAccountDisplayString())
]),
'clientOnly':
True,
'position': (0, -200),
'flatness':
1.0,
'hAlign':
'center'
}))
if not gDidInitialTransition:
if hasattr(self, 'myName'):
bs.animate(self.myName.node, 'opacity', {2300: 0, 3000: 1.0})
if hasattr(self, 'moderName'):
bs.animate(self.moderName.node, 'opacity', {
2300: 0,
3300: 1.0
})
# FIXME - shouldn't be doing things conditionally based on whether
# the host is vr mode or not (clients may not be or vice versa)
# - any differences need to happen at the engine level
# so everyone sees things in their own optimal way
vrMode = env['vrMode']
interfaceType = env['interfaceType']
# in cases where we're doing lots of dev work lets
# always show the build number
forceShowBuildNumber = True
if not bs.getEnvironment().get('toolbarTest', True):
text = "BROODYs WORLD"
try:
from multiversion import get_version
except ImportError:
path = os.path.join(env["userScriptsDirectory"],
"about_modpack.json")
if os.path.exists(path):
try:
data = json.load(open(path))
except Exception:
pass
else:
text += " v." + str(
data.get("version", {
"v": "???"
}).get("v"))
else:
text += " v." + str(get_version())
if env['debugBuild'] or env['testBuild']:
if env['debugBuild']: text += " [debug]"
else: text += " [test]"
if forceShowBuildNumber:
text = "based on " + str(env['version']) + "\n" + text
self.version = bs.NodeActor(
bs.newNode('text',
attrs={
'vAttach':
'bottom',
'hAttach':
'right',
'hAlign':
'right',
'flatness':
1.0,
'vrDepth':
-10,
'shadow':
0.5,
'color': (0.5, 0.6, 0.5, 0.7),
'scale':
0.7 if
(interfaceType == 'small' or vrMode) else 0.85,
'position': (-260, 10) if vrMode else (-10, 30),
'text':
text
}))
if not gDidInitialTransition:
bs.animate(self.version.node, 'opacity', {
0: 0,
3000: 0,
4000: 1.0
})
# throw in beta info..
self.betaInfo = self.betaInfo2 = None
if env['testBuild'] and not env['kioskMode']:
self.betaInfo = bs.NodeActor(
bs.newNode('text',
attrs={
'vAttach':
'center',
'hAlign':
'center',
'color': (1, 1, 1, 1),
'shadow':
0.5,
'flatness':
0.5,
'scale':
1,
'vrDepth':
-60,
'position': (230, 125) if env['kioskMode'] else
(230, 35),
'text':
bs.Lstr(resource="testBuildText")
}))
if not gDidInitialTransition:
bs.animate(self.betaInfo.node, 'opacity', {1300: 0, 1800: 1.0})
model = bs.getModel('thePadLevel')
treesModel = bs.getModel('trees')
bottomModel = bs.getModel('thePadLevelBottom')
borModel = bs.getCollideModel('thePadLevelCollide')
testColorTexture = bs.getTexture('thePadLevelColor')
treesTexture = bs.getTexture('treesColor')
bgTex = bs.getTexture('alwaysLandBGColor')
bgModel = bs.getModel('alwaysLandBG')
vrBottomFillModel = bs.getModel('thePadVRFillBottom')
vrTopFillModel = bs.getModel('thePadVRFillTop')
bsGlobals = bs.getSharedObject('globals')
bsGlobals.cameraMode = 'rotate'
bsGlobals.tint = (1.1, 1.1, 1.0)
self.bottom = bs.NodeActor(
bs.newNode('terrain',
attrs={
'model': bottomModel,
'lighting': False,
'reflection': 'soft',
'reflectionScale': [0.45],
'colorTexture': testColorTexture
}))
self.node = bs.newNode('terrain',
delegate=self,
attrs={
'collideModel':
borModel,
'model':
model,
'colorTexture':
testColorTexture,
'materials':
[bs.getSharedObject('footingMaterial')]
})
self.vrBottomFill = bs.NodeActor(
bs.newNode('terrain',
attrs={
'model': vrBottomFillModel,
'lighting': False,
'vrOnly': True,
'colorTexture': testColorTexture
}))
self.vrTopFill = bs.NodeActor(
bs.newNode('terrain',
attrs={
'model': vrTopFillModel,
'vrOnly': True,
'lighting': False,
'colorTexture': bgTex
}))
self.terrain = bs.NodeActor(
bs.newNode('terrain',
attrs={
'model': model,
'colorTexture': testColorTexture,
'reflection': 'soft',
'reflectionScale': [0.3]
}))
self.trees = bs.NodeActor(
bs.newNode('terrain',
attrs={
'model': treesModel,
'lighting': False,
'reflection': 'char',
'reflectionScale': [0.1],
'colorTexture': treesTexture
}))
self.bg = bs.NodeActor(
bs.newNode('terrain',
attrs={
'model': bgModel,
'color': (0.92, 0.91, 0.9),
'lighting': False,
'background': True,
'colorTexture': bgTex
}))
textOffsetV = 0
self._ts = 0.86
self._language = None
self._updateTimer = bs.Timer(2000,
bs.Call(self._update, False),
repeat=True)
self._update(True)
bs.gameTimer(55000, bs.Call(self.fireworks))
bsUtils.animateArray(bs.getSharedObject("globals"), "tint", 3, {0:(1.1,1.1,1.0), 7500:(1.25, 1.21, 1.075), 30000:(1.25, 1.21, 1.075), \
57500:(1.1, 0.86, 0.74), 67500:(1.1, 0.86, 0.74), \
90000:(0, 0.27, 0.51), 120000:(0, 0.27, 0.51), 142500:(1.3, 1.06, 1.02), \
157500:(1.3, 1.06, 1.02), 180000:(1.3, 1.25, 1.2), 195500:(1.3, 1.25, 1.2), \
220000:(1.1,1.1,1.0)})
bsInternal._addCleanFrameCallback(bs.WeakCall(self._startPreloads))
random.seed()
class News(object):
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 _tryFetchingNews(self):
if bsInternal._getAccountState() == 'SIGNED_IN':
self._fetchNews()
self._fetchTimer = None
def _fetchNews(self):
try:
launchCount = bs.getConfig()['launchCount']
except Exception:
launchCount = None
global gLastNewsFetchTime
gLastNewsFetchTime = time.time()
# UPDATE - we now just pull news from MRVs
news = bsInternal._getAccountMiscReadVal('n', None)
if news is not None:
self._gotNews(news)
def _changePhrase(self):
global gLastNewsFetchTime
if time.time() - gLastNewsFetchTime > 100.0:
self._fetchNews()
self._text = None
else:
if self._text is not None:
if len(self._phrases) == 0:
for p in self._usedPhrases:
self._phrases.insert(0, p)
val = self._phrases.pop()
if val == '__ACH__':
vr = bs.getEnvironment()['vrMode']
bsUtils.Text(
bs.Lstr(resource='nextAchievementsText'),
color=(1,1,1,1) if vr else (0.95,0.9,1,0.4),
hostOnly=True,
maxWidth=200,
position=(-300, -35),
hAlign='right',
transition='fadeIn',
scale=0.9 if vr else 0.7,
flatness=1.0 if vr else 0.6,
shadow=1.0 if vr else 0.5,
hAttach="center",
vAttach="top",
transitionDelay=1000,
transitionOutDelay=self._messageDuration)\
.autoRetain()
import bsAchievement
achs = [
a for a in bsAchievement.gAchievements
if not a.isComplete()
]
if len(achs) > 0:
a = achs.pop(
random.randrange(min(4, len(achs))))
a.createDisplay(-180,
-35,
1000,
outDelay=self._messageDuration,
style='news')
if len(achs) > 0:
a = achs.pop(
random.randrange(min(8, len(achs))))
a.createDisplay(180,
-35,
1250,
outDelay=self._messageDuration,
style='news')
else:
s = self._messageSpacing
keys = {
s: 0,
s + 1000: 1.0,
s + self._messageDuration - 1000: 1.0,
s + self._messageDuration: 0.0
}
bs.animate(self._text.node, "opacity",
dict([[k, v] for k, v in keys.items()]))
self._text.node.text = val
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()
if not env['kioskMode'] and not env.get('toolbarTest', True):
self._news = News(self)
# bring up the last place we were, or start at the main menu otherwise
with bs.Context('UI'):
try:
mainWindow = bsUI.gMainWindow
except Exception:
mainWindow = None
# when coming back from a kiosk-mode game, jump to
# the kiosk start screen.. if bsUtils.gRunningKioskModeGame:
if bs.getEnvironment()['kioskMode']:
bsUI.uiGlobals['mainMenuWindow'] = \
bsUI.KioskWindow().getRootWidget()
# ..or in normal cases go back to the main menu
else:
if mainWindow == 'Gather':
bsUI.uiGlobals['mainMenuWindow'] = \
bsUI.GatherWindow(transition=None).getRootWidget()
elif mainWindow == 'Watch':
bsUI.uiGlobals['mainMenuWindow'] = \
bsUI.WatchWindow(transition=None).getRootWidget()
elif mainWindow == 'Team Game Select':
bsUI.uiGlobals['mainMenuWindow'] = \
bsUI.TeamsWindow(sessionType=bs.TeamsSession,
transition=None).getRootWidget()
elif mainWindow == 'Free-for-All Game Select':
bsUI.uiGlobals['mainMenuWindow'] = \
bsUI.TeamsWindow(sessionType=bs.FreeForAllSession,
transition=None).getRootWidget()
elif mainWindow == 'Coop Select':
bsUI.uiGlobals['mainMenuWindow'] = \
bsUI.CoopWindow(transition=None).getRootWidget()
else: bsUI.uiGlobals['mainMenuWindow'] = \
bsUI.MainMenuWindow(transition=None).getRootWidget()
# attempt to show any pending offers immediately.
# If that doesn't work, try again in a few seconds
# (we may not have heard back from the server)
# ..if that doesn't work they'll just have to wait
# until the next opportunity.
if not bsUI._showOffer():
def tryAgain():
if not bsUI._showOffer():
# try one last time..
bs.realTimer(2000, bsUI._showOffer)
bs.realTimer(2000, tryAgain)
gDidInitialTransition = True
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 __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
name = 'none'
if powerupType == 'tripleBombs':
tex = factory.texBomb
name = "| |Trio| |"
elif powerupType == 'Party':
tex = factory.texParty
name = "| |Party| |"
elif powerupType == 'Troll':
tex = factory.texTroll
name = "| |Troll| |"
elif powerupType == 'Rchar':
tex = factory.texRchar
name = "| |Rchar| |"
elif powerupType == 'Speed':
tex = factory.texSpeed
name = "| |Boots| |"
elif powerupType == 'Inv':
tex = factory.texInv
name = "| |Invisible| |"
elif powerupType == 'punch':
tex = factory.texPunch
name = "| |Gloves| |"
elif powerupType == 'Bunny':
tex = factory.texBunny
name = "| |Bunny| |"
elif powerupType == 'Bot':
tex = factory.texBot
name = "| |Bot 2.0| |"
elif powerupType == 'iceBombs':
tex = factory.texIceBombs
name = "| |Icy| |"
elif powerupType == 'impactBombs':
tex = factory.texImpactBombs
name = "| |Impacta| |"
elif powerupType == 'landMines':
tex = factory.texLandMines
name = "| |LandMines| |"
elif powerupType == 'stickyBombs':
tex = factory.texStickyBombs
name = "| |Sticky| |"
elif powerupType == 'shield':
tex = factory.texShield
name = "| |Shield| |"
elif powerupType == 'health':
tex = factory.texHealth
name = "| |Med Pack| |"
elif powerupType == 'curse':
tex = factory.texCurse
name = "| |Curse| |"
elif powerupType == 'iceMine':
tex = factory.texiceMine
name = "| |Ice Mine| |"
elif powerupType == 'trioBomb':
tex = factory.textrioBomb
name = "| |Trio Bomb| |"
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 = (random.random(), random.random(), random.random())
if settings.nameOnPowerUps:
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})
bsUtils.animateArray(self.nodeText, 'color', 3, prefixAnim, True)
bs.emitBGDynamics(position=self.nodeText.position, velocity=self.node.position, count=10, scale=0.4,
spread=0.01, chunkType='sweat')
if settings.discoLightsOnPowerUps:
self.nodeLight = bs.newNode('light',
attrs={'position': self.node.position,
'color': color,
'radius': 0.05,
'volumeIntensityScale': 0.03})
self.node.connectAttr('position', self.nodeLight, 'position')
bsUtils.animateArray(self.nodeLight, 'color', 3, prefixAnim, True)
if settings.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)
# 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,
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
elif powerupType == 'multiBombs': tex = factory.texMultiBombs
elif powerupType == 'punch': tex = factory.texPunch
elif powerupType == 'speedPunch': tex = factory.texSpeedPunch
elif powerupType == 'fireworkBombs': tex = factory.texFireworkBomb
elif powerupType == 'killLaKillBombs': tex = factory.texKillLaKillBomb
elif powerupType == 'poisonBombs': tex = factory.texPoisonBomb
elif powerupType == 'pandoraBox': tex = factory.texPandoraBox
elif powerupType == 'yellowShield': tex = factory.texYellowShield
elif powerupType == 'jumpingBombs': tex = factory.texJumpingBomb
elif powerupType == 'tpBombs': tex = factory.texTpBombs
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 == 'unbreakable': tex = factory.texUnb
elif powerupType == 'dirtBombs': tex = factory.texDirt
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'))
})
if powerupType == 'pandoraBox':
bsUtils.animateArray(self.node, 'reflectionScale', 3, {
0: (1, 1, 1),
1500: (5, 5, 5),
3000: (-5, -5, -5),
4500: (1, 1, 1)
}, True)
if settings.get("powerup_lighting", True):
self.light = bs.newNode('light',
owner=self.node,
attrs={
'position':
position,
'intensity':
0,
'radius':
0,
'color': (random.random() * 2.45,
random.random() * 2.45,
random.random() * 2.45)
})
self.node.connectAttr('position', self.light, 'position')
bs.animate(self.light, "radius", {
0: 0,
140: 0.04,
200: 0.09,
400: 0.078
})
bs.animate(self.light,
"intensity", {
0: 1.0,
1000: 1.8,
2000: 1.0
},
loop=True)
bsUtils.animateArray(
self.light, "color", 3, {
0: (self.light.color[0], self.light.color[1],
self.light.color[2]),
1000:
(self.light.color[0] - 0.4, self.light.color[1] - 0.4,
self.light.color[2] - 0.4),
1500: (self.light.color[0], self.light.color[1],
self.light.color[2])
}, True)
if settings.get("timer_the_disappearance_of_the_powerup", True):
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 opt(self, nick, msg):
if self.checkDevice(nick):
m = msg.split(' ')[0] # command
a = msg.split(' ')[1:] # arguments
activity = bsInternal._getForegroundHostActivity()
with bs.Context(activity):
if m == '/kick':
if a == []:
bsInternal._chatMessage(
'Using: /kick name or clientID')
else:
if len(a[0]) > 3:
self.kickByNick(a[0])
bsInternal._chatMessage('Player Kicked By Admin')
else:
try:
s = int(a[0])
bsInternal._chatMessage(
'Player Kicked By Admin')
bsInternal._disconnectClient(int(a[0]))
except:
self.kickByNick(a[0])
elif m == '/admin':
clID = int(a[0])
for client in bsInternal._getGameRoster():
if client['clientID'] == clID:
if a[1] == 'add':
newadmin = client['displayString']
updated_admins = gph.adminHashes.append(
newadmin)
elif a[1] == 'remove':
newadmin = client['displayString']
if newadmin in gph.adminHashes:
updated_admins = gph.adminHashes.remove(
newadmin)
with open(bs.getEnvironment()['systemScriptsDirectory'] +
"/getPermissionsHashes.py") as file:
s = [row for row in file]
s[0] = 'vipHashes = []' + '\n'
s[1] = 'adminHashes = ' + updated_admins + '\n'
f = open(
bs.getEnvironment()['systemScriptsDirectory'] +
"/getPermissionsHashes.py", 'w')
for i in s:
f.write(i)
f.close()
elif m == '/ban':
clID = int(a[0])
for client in bsInternal._getGameRoster():
if client['clientID'] == clID:
if a[1] == 'add':
ban = client['displayString']
updated_ban = gph.ban.append(ban)
bs.screenMessage('Banning...')
elif a[1] == 'remove':
ban = client['displayString']
if ban in gph.ban:
updated_ban = gph.ban.remove(ban)
with open(bs.getEnvironment()['systemScriptsDirectory'] +
"/getPermissionsHashes.py") as file:
s = [row for row in file]
s[0] = 'vipHashes = []' + '\n'
s[1] = 'admin = []' + '\n'
s[2] = 'ass = []' + '\n'
s[3] = 'ban = ' + updated_ban + '\n'
f = open(
bs.getEnvironment()['systemScriptsDirectory'] +
"/getPermissionsHashes.py", 'w')
for i in s:
f.write(i)
f.close()
elif m == '/ass':
clID = int(a[0])
for client in bsInternal._getGameRoster():
if client['clientID'] == clID:
if a[1] == 'add':
ass = client['displayString']
updated_ass = gph.ass.append(ass)
elif a[1] == 'remove':
ass = client['displayString']
if ass in gph.ass:
updated_ass = gph.ass.remove(ass)
with open(bs.getEnvironment()['systemScriptsDirectory'] +
"/getPermissionsHashes.py") as file:
s = [row for row in file]
s[0] = 'vipHashes = []' + '\n'
s[1] = 'admin= []' + '\n'
s[2] = 'ass = ' + updated_admins + '\n'
f = open(
bs.getEnvironment()['systemScriptsDirectory'] +
"/getPermissionsHashes.py", 'w')
for i in s:
f.write(i)
f.close()
elif m == '/vip':
clID = int(a[0])
for client in bsInternal._getGameRoster():
if client['clientID'] == clID:
if a[1] == 'add':
vip = client['displayString']
updated_vip = gph.vip.append(vip)
elif a[1] == 'remove':
vip = client['displayString']
if vip in gph.vip:
updated_vip = gph.vip.remove(vip)
with open(bs.getEnvironment()['systemScriptsDirectory'] +
"/getPermissionsHashes.py") as file:
s = [row for row in file]
s[0] = 'vip = ' + updated_admins + '\n'
f = open(
bs.getEnvironment()['systemScriptsDirectory'] +
"/getPermissionsHashes.py", 'w')
for i in s:
f.write(i)
f.close()
elif m == '/list':
bsInternal._chatMessage(
"======== FOR /kick ONLY: ========")
for i in bsInternal._getGameRoster():
try:
bsInternal._chatMessage(
i['players'][0]['nameFull'] + " (/kick " +
str(i['clientID']) + ")")
except:
pass
bsInternal._chatMessage(
"==================================")
bsInternal._chatMessage(
"======= For other commands: =======")
for s in bsInternal._getForegroundHostSession().players:
bsInternal._chatMessage(
s.getName() +
" " + str(bsInternal._getForegroundHostSession(
).players.index(s)))
elif m == '/ooh':
if a is not None and len(a) > 0:
s = int(a[0])
def oohRecurce(c):
bs.playSound(bs.getSound('ooh'), volume=2)
c -= 1
if c > 0:
bs.gameTimer(
int(a[1]) if len(a) > 1
and a[1] is not None else 1000,
bs.Call(oohRecurce, c=c))
oohRecurce(c=s)
else:
bs.playSound(bs.getSound('ooh'), volume=2)
elif m == '/playSound':
if a is not None and len(a) > 1:
s = int(a[1])
def oohRecurce(c):
bs.playSound(bs.getSound(str(a[0])), volume=2)
c -= 1
if c > 0:
bs.gameTimer(
int(a[2]) if len(a) > 2
and a[2] is not None else 1000,
bs.Call(oohRecurce, c=c))
oohRecurce(c=s)
else:
bs.playSound(bs.getSound(str(a[0])), volume=2)
elif m == '/quit':
bsInternal.quit()
elif m == '/nv':
if self.tint is None:
self.tint = bs.getSharedObject('globals').tint
bs.getSharedObject('globals').tint = (
0.5, 0.7,
1) if a == [] or not a[0] == u'off' else self.tint
elif m == '/freeze':
if a == []:
bsInternal._chatMessage(
'Using: /freeze all or number of list')
else:
if a[0] == 'all':
for i in bs.getSession().players:
try:
i.actor.node.handleMessage(
bs.FreezeMessage())
except:
pass
else:
bs.getSession().players[int(
a[0])].actor.node.handleMessage(
bs.FreezeMessage())
elif m == '/thaw':
if a == []:
bsInternal._chatMessage(
'Using: /thaw all or number of list')
else:
if a[0] == 'all':
for i in bs.getSession().players:
try:
i.actor.node.handleMessage(
bs.ThawMessage())
except:
pass
else:
bs.getSession().players[int(
a[0])].actor.node.handleMessage(
bs.ThawMessage())
elif m == '/sleep':
if a == []:
bsInternal._chatMessage('Using: number of list')
else:
if a[0] == 'all':
for i in bs.getSession().players:
try:
i.actor.node.handleMessage(
"knockout", 5000)
except:
pass
else:
bs.getSession().players[int(
a[0])].actor.node.handleMessage(
"knockout", 5000)
elif m == '/kill':
if a == []:
bsInternal._chatMessage(
'Using: /kill all or number of list')
else:
if a[0] == 'all':
for i in bs.getSession().players:
try:
i.actor.node.handleMessage(bs.DieMessage())
except:
pass
else:
bs.getSession().players[int(
a[0])].actor.node.handleMessage(
bs.DieMessage())
elif m == '/curse':
if a == []:
bsInternal._chatMessage(
'Using: /curse all or number of list')
else:
if a[0] == 'all':
for i in bs.getSession().players:
try:
i.actor.curse()
except:
pass
else:
bs.getSession().players[int(a[0])].actor.curse()
elif m == '/box':
if a == []:
bsInternal._chatMessage(
'Using: /box all or number of list')
else:
try:
if a[0] == 'all':
for i in bs.getSession().players:
try:
i.actor.node.torsoModel = bs.getModel(
"tnt")
except:
print 'error'
for i in bs.getSession().players:
try:
i.actor.node.colorMaskTexture = bs.getTexture(
"tnt")
except:
print 'error'
for i in bs.getSession().players:
try:
i.actor.node.colorTexture = bs.getTexture(
"tnt")
except:
print 'error'
for i in bs.getSession().players:
try:
i.actor.node.highlight = (1, 1, 1)
except:
print 'error'
for i in bs.getSession().players:
try:
i.actor.node.color = (1, 1, 1)
except:
print 'error'
for i in bs.getSession().players:
try:
i.actor.node.headModel = None
except:
print 'error'
for i in bs.getSession().players:
try:
i.actor.node.style = "cyborg"
except:
print 'error'
else:
n = int(a[0])
bs.getSession().players[
n].actor.node.torsoModel = bs.getModel(
"tnt")
bs.getSession().players[
n].actor.node.colorMaskTexture = bs.getTexture(
"tnt")
bs.getSession().players[
n].actor.node.colorTexture = bs.getTexture(
"tnt")
bs.getSession(
).players[n].actor.node.highlight = (1, 1, 1)
bs.getSession().players[n].actor.node.color = (
1, 1, 1)
bs.getSession(
).players[n].actor.node.headModel = None
bs.getSession(
).players[n].actor.node.style = "cyborg"
except:
bs.screenMessage('Ошибка!', color=(1, 0, 0))
elif m == '/spaz':
if a == []:
bsInternal._chatMessage(
'Using: /spaz all or number of list')
else:
try:
if a[0] == 'all':
for i in bs.getSession().players:
t = i.actor.node
try:
t.colorTexture = bs.getTexture(a[1] +
"Color")
t.colorMaskTexture = bs.getTexture(
a[1] + "ColorMask")
t.headModel = bs.getModel(a[1] +
"Head")
t.torsoModel = bs.getModel(a[1] +
"Torso")
t.pelvisModel = bs.getModel(a[1] +
"Pelvis")
t.upperArmModel = bs.getModel(
a[1] + "UpperArm")
t.foreArmModel = bs.getModel(a[1] +
"ForeArm")
t.handModel = bs.getModel(a[1] +
"Hand")
t.upperLegModel = bs.getModel(
a[1] + "UpperLeg")
t.lowerLegModel = bs.getModel(
a[1] + "LowerLeg")
t.toesModel = bs.getModel(a[1] +
"Toes")
t.style = a[1]
except:
print 'error'
else:
n = int(a[0])
t = bs.getSession().players[n].actor.node
t.colorTexture = bs.getTexture(a[1] + "Color")
t.colorMaskTexture = bs.getTexture(a[1] +
"ColorMask")
t.headModel = bs.getModel(a[1] + "Head")
t.torsoModel = bs.getModel(a[1] + "Torso")
t.pelvisModel = bs.getModel(a[1] + "Pelvis")
t.upperArmModel = bs.getModel(a[1] +
"UpperArm")
t.foreArmModel = bs.getModel(a[1] + "ForeArm")
t.handModel = bs.getModel(a[1] + "Hand")
t.upperLegModel = bs.getModel(a[1] +
"UpperLeg")
t.lowerLegModel = bs.getModel(a[1] +
"LowerLeg")
t.toesModel = bs.getModel(a[1] + "Toes")
t.style = a[1]
except:
bs.screenMessage('error', color=(1, 0, 0))
elif m == '/inv':
if a == []:
bsInternal._chatMessage(
'Using: /spaz all or number of list')
else:
try:
if a[0] == 'all':
for i in bs.getSession().players:
t = i.actor.node
try:
t.headModel = None
t.torsoModel = None
t.pelvisModel = None
t.upperArmModel = None
t.foreArmModel = None
t.handModel = None
t.upperLegModel = None
t.lowerLegModel = None
t.toesModel = None
t.style = "cyborg"
except:
print 'error'
else:
n = int(a[0])
t = bs.getSession().players[n].actor.node
t.headModel = None
t.torsoModel = None
t.pelvisModel = None
t.upperArmModel = None
t.foreArmModel = None
t.handModel = None
t.upperLegModel = None
t.lowerLegModel = None
t.toesModel = None
t.style = "cyborg"
except:
bs.screenMessage('error', color=(1, 0, 0))
elif m == '/tex':
if a == []:
bsInternal._chatMessage(
'Using: /tex all or number of list')
else:
try:
if a[0] == 'all':
for i in bs.getSession().players:
try:
i.actor.node.colorMaskTexture = bs.getTexture(
"egg1")
except:
print 'error'
for i in bs.getSession().players:
try:
i.actor.node.colorTexture = bs.getTexture(
"egg1")
except:
print 'error'
else:
n = int(a[0])
bs.getSession().players[
n].actor.node.colorMaskTexture = bs.getTexture(
"egg1")
bs.getSession().players[
n].actor.node.colorTexture = bs.getTexture(
"egg1")
except:
bs.screenMessage('Ошибка!', color=(1, 0, 0))
elif m == '/remove':
if a == []:
bsInternal._chatMessage(
'Using: /remove all or number of list')
else:
if a[0] == 'all':
for i in bs.getSession().players:
try:
i.removeFromGame()
except:
pass
else:
bs.getSession().players[int(a[0])].removeFromGame()
elif m == '/end':
try:
bsInternal._getForegroundHostActivity().endGame()
except:
pass
elif m == '/hug':
if a == []:
bsInternal._chatMessage(
'Using: /hug all or number of list')
else:
try:
if a[0] == 'all':
try:
bsInternal._getForegroundHostActivity(
).players[
0].actor.node.holdNode = bsInternal._getForegroundHostActivity(
).players[1].actor.node
except:
pass
try:
bsInternal._getForegroundHostActivity(
).players[
1].actor.node.holdNode = bsInternal._getForegroundHostActivity(
).players[0].actor.node
except:
pass
try:
bsInternal._getForegroundHostActivity(
).players[
3].actor.node.holdNode = bsInternal._getForegroundHostActivity(
).players[2].actor.node
except:
pass
try:
bsInternal._getForegroundHostActivity(
).players[
4].actor.node.holdNode = bsInternal._getForegroundHostActivity(
).players[3].actor.node
except:
pass
try:
bsInternal._getForegroundHostActivity(
).players[
5].actor.node.holdNode = bsInternal._getForegroundHostActivity(
).players[6].actor.node
except:
pass
try:
bsInternal._getForegroundHostActivity(
).players[
6].actor.node.holdNode = bsInternal._getForegroundHostActivity(
).players[7].actor.node
except:
pass
else:
bsInternal._getForegroundHostActivity(
).players[int(
a[0]
)].actor.node.holdNode = bsInternal._getForegroundHostActivity(
).players[int(a[1])].actor.node
except:
bs.screenMessage('Ошибка!', color=(1, 0, 0))
elif m == '/gm':
if a == []:
for i in range(len(activity.players)):
if activity.players[i].getName().encode(
'utf-8').find(
nick.encode('utf-8').replace(
'...', '').replace(':', '')) != -1:
activity.players[
i].actor.node.hockey = activity.players[
i].actor.node.hockey == False
activity.players[
i].actor.node.invincible = activity.players[
i].actor.node.invincible == False
activity.players[
i].actor._punchPowerScale = 5 if activity.players[
i].actor._punchPowerScale == 1.2 else 1.2
else:
activity.players[int(
a[0])].actor.node.hockey = activity.players[int(
a[0])].actor.node.hockey == False
activity.players[int(
a[0])].actor.node.invincible = activity.players[
int(a[0])].actor.node.invincible == False
activity.players[int(
a[0]
)].actor._punchPowerScale = 5 if activity.players[int(
a[0])].actor._punchPowerScale == 1.2 else 1.2
elif m == '/tint':
if a == []:
bsInternal._chatMessage('Using: /tint R G B')
bsInternal._chatMessage('OR')
bsInternal._chatMessage('Using: /tint r bright speed')
else:
if a[0] == 'r':
m = 1.3 if a[1] is None else float(a[1])
s = 1000 if a[2] is None else float(a[2])
bsUtils.animateArray(
bs.getSharedObject('globals'), 'tint', 3, {
0: (1 * m, 0, 0),
s: (0, 1 * m, 0),
s * 2: (0, 0, 1 * m),
s * 3: (1 * m, 0, 0)
}, True)
else:
try:
if a[1] is not None:
bs.getSharedObject('globals').tint = (
float(a[0]), float(a[1]), float(a[2]))
else:
bs.screenMessage('Error!', color=(1, 0, 0))
except:
bs.screenMessage('Error!', color=(1, 0, 0))
elif m == 'pause':
bs.getSharedObject('globals').paused = bs.getSharedObject(
'globals').paused == False
elif m == '/sm':
bs.getSharedObject(
'globals').slowMotion = bs.getSharedObject(
'globals').slowMotion == False
elif m == '/bunny':
if a == []:
bsInternal._chatMessage(
'Using: /bunny count owner(number of list)')
import BuddyBunny
for i in range(int(a[0])):
p = bs.getSession().players[int(a[1])]
if not 'bunnies' in p.gameData:
p.gameData['bunnies'] = BuddyBunny.BunnyBotSet(p)
p.gameData['bunnies'].doBunny()
elif m == '/cameraMode':
try:
if bs.getSharedObject(
'globals').cameraMode == 'follow':
bs.getSharedObject('globals').cameraMode = 'rotate'
else:
bs.getSharedObject('globals').cameraMode = 'follow'
except:
pass
elif m == '/lm':
arr = []
for i in range(100):
try:
arr.append(bsInternal._getChatMessages()[-1 - i])
except:
pass
arr.reverse()
for i in arr:
bsInternal._chatMessage(i)
elif m == '/gp':
if a == []:
bsInternal._chatMessage('Using: /gp number of list')
else:
s = bsInternal._getForegroundHostSession()
for i in s.players[int(
a[0])].getInputDevice()._getPlayerProfiles():
try:
bsInternal._chatMessage(i)
except:
pass
elif m == '/icy':
bsInternal._getForegroundHostActivity().players[int(
a[0]
)].actor.node = bsInternal._getForegroundHostActivity(
).players[int(a[1])].actor.node
elif m == '/fly':
if a == []:
bsInternal._chatMessage(
'Using: /fly all or number of list')
else:
if a[0] == 'all':
for i in bsInternal._getForegroundHostActivity(
).players:
i.actor.node.fly = True
else:
bsInternal._getForegroundHostActivity(
).players[int(
a[0]
)].actor.node.fly = bsInternal._getForegroundHostActivity(
).players[int(a[0])].actor.node.fly == False
elif m == '/floorReflection':
bs.getSharedObject(
'globals').floorReflection = bs.getSharedObject(
'globals').floorReflection == False
elif m == '/ac':
if a == []:
bsInternal._chatMessage('Using: /ac R G B')
bsInternal._chatMessage('OR')
bsInternal._chatMessage('Using: /ac r bright speed')
else:
if a[0] == 'r':
m = 1.3 if a[1] is None else float(a[1])
s = 1000 if a[2] is None else float(a[2])
bsUtils.animateArray(
bs.getSharedObject('globals'), 'ambientColor',
3, {
0: (1 * m, 0, 0),
s: (0, 1 * m, 0),
s * 2: (0, 0, 1 * m),
s * 3: (1 * m, 0, 0)
}, True)
else:
try:
if a[1] is not None:
bs.getSharedObject(
'globals').ambientColor = (float(a[0]),
float(a[1]),
float(a[2]))
else:
bs.screenMessage('Error!', color=(1, 0, 0))
except:
bs.screenMessage('Error!', color=(1, 0, 0))
elif m == '/iceOff':
try:
activity.getMap().node.materials = [
bs.getSharedObject('footingMaterial')
]
activity.getMap().isHockey = False
except:
pass
try:
activity.getMap().floor.materials = [
bs.getSharedObject('footingMaterial')
]
activity.getMap().isHockey = False
except:
pass
for i in activity.players:
i.actor.node.hockey = False
elif m == '/maxPlayers':
if a == []:
bsInternal._chatMessage(
'Using: /maxPlayers count of players')
else:
try:
bsInternal._getForegroundHostSession(
)._maxPlayers = int(a[0])
bsInternal._setPublicPartyMaxSize(int(a[0]))
bsInternal._chatMessage('Players limit set to ' +
str(int(a[0])))
except:
bs.screenMessage('Error!', color=(1, 0, 0))
elif m == '/heal':
if a == []:
bsInternal._chatMessage(
'Using: /heal all or number of list')
else:
try:
bsInternal._getForegroundHostActivity().players[
int(a[0])].actor.node.handleMessage(
bs.PowerupMessage(powerupType='health'))
except:
bs.screenMessage('Error!', color=(1, 0, 0))
elif m == '/reflections':
if a == [] or len(a) < 2:
bsInternal._chatMessage(
'Using: /reflections type(1/0) scale')
rs = [int(a[1])]
type = 'soft' if int(a[0]) == 0 else 'powerup'
try:
bsInternal._getForegroundHostActivity().getMap(
).node.reflection = type
bsInternal._getForegroundHostActivity().getMap(
).node.reflectionScale = rs
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).bg.reflection = type
bsInternal._getForegroundHostActivity().getMap(
).bg.reflectionScale = rs
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).floor.reflection = type
bsInternal._getForegroundHostActivity().getMap(
).floor.reflectionScale = rs
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).center.reflection = type
bsInternal._getForegroundHostActivity().getMap(
).center.reflectionScale = rs
except:
pass
elif m == '/shatter':
if a == []:
bsInternal._chatMessage(
'Using: /shatter all or number of list')
else:
if a[0] == 'all':
for i in bsInternal._getForegroundHostActivity(
).players:
i.actor.node.shattered = int(a[1])
else:
bsInternal._getForegroundHostActivity().players[
int(a[0])].actor.node.shattered = int(a[1])
elif m == '/cm':
if a == []:
time = 8000
else:
time = int(a[0])
op = 0.08
std = bs.getSharedObject('globals').vignetteOuter
bsUtils.animateArray(
bs.getSharedObject('globals'), 'vignetteOuter', 3,
{
0: bs.getSharedObject('globals').vignetteOuter,
17000: (0, 1, 0)
})
try:
bsInternal._getForegroundHostActivity().getMap(
).node.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).bg.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).bg.node.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).node1.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).node2.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).node3.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).steps.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).floor.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).center.opacity = op
except:
pass
def off():
op = 1
try:
bsInternal._getForegroundHostActivity().getMap(
).node.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).bg.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).bg.node.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).node1.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).node2.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).node3.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).steps.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).floor.opacity = op
except:
pass
try:
bsInternal._getForegroundHostActivity().getMap(
).center.opacity = op
except:
pass
bsUtils.animateArray(
bs.getSharedObject('globals'), 'vignetteOuter', 3,
{
0: bs.getSharedObject('globals').vignetteOuter,
100: std
})
bs.gameTimer(time, bs.Call(off))
elif m == 'help':
bsInternal._chatMessage(
bs.Lstr(resource='help1').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help2').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help3').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help4').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help5').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help6').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help7').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help8').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help9').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help10').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help11').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help12').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help13').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help14').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help15').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help16').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help17').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help18').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help19').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help20').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help21').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help22').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help23').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help24').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help25').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help26').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help27').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help28').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help29').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help30').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help31').evaluate())
bsInternal._chatMessage(
bs.Lstr(resource='help32').evaluate())
