def postUpdate(self):
planet = Point3.zero()
normal = Vec3(self.playernp.getX() - planet.getX(), self.playernp.getY() - planet.getY(), self.playernp.getZ() - planet.getZ())
normal.normalize()
fwd = render.getRelativePoint(self.playernp, Vec3(0, 1, 0))
self.playernp.headsUp(fwd, normal)
self.__currentPos = self.playernp.getPos()
#player movement
#space physcis
#speed = self.playernp.node().getLinearVelocity()
#normal physcis
speed = Vec3(0, 0, 0)
omega = 0.0
v = 5.8
if inputState.isSet('forward'): speed.setY(v)
if inputState.isSet('reverse'): speed.setY(-v)
if inputState.isSet('left'): speed.setX(-v)
if inputState.isSet('right'): speed.setX(v)
if inputState.isSet('flyUp'): speed.setZ( 2.0)
if inputState.isSet('flyDown'): speed.setZ( -2.0)
if inputState.isSet('turnLeft'): omega = 40.0
if inputState.isSet('turnRight'): omega = -40.0
self.playernp.setH(self.playernp, omega * globalClock.getDt())
globalVel = self.playernp.getQuat(render).xform(speed) * globalClock.getDt()
normalVel = Vec3(globalVel)
normalVel.normalize()
if globalVel != Vec3():
globalVelDir = Vec3(globalVel)
globalVelDir.normalize()
fn = Vec3(0.0, 0.0, 0.0)
fn.normalize()
velDot = 1.0 - globalVelDir.angleDeg(fn) / 180.0
if velDot < 0.5:
self.__currentPos -= Vec3(fn.x * globalVel.x, fn.y * globalVel.y, globalVel.z * globalVel.y) * velDot
globalVel *= velDot
self.__currentPos += globalVel
self.playernp.setPos(self.__currentPos)
def __init__(self, distributed_object: Character, host: PastryClient):
self.host = proxy(host)
# Save the actual game object to this instance
self.do = distributed_object
self.do.avatar = proxy(self)
print(self.do.destination)
# TODO: Make this the keyframe beginning
initial_position = Point3.zero()
# TODO: Make into a list of keyframes to do waypoints
# TODO: And this kind of info should live on the DO
self.start_kf = Keyframe(initial_position, time=now())
self.end_kf = Keyframe(initial_position, time=now())
# show where the avatar is headed TODO: Use an arrow or something?
self._marker = base.loader.loadModel('models/Sinbad')
self._marker.reparentTo(base.render)
self._marker.setScale(.05, .05, .05)
super().__init__()
def __init__(self, quest, parent = aspect2d, **kw):
self.quest = quest
# Let's begin building the quest poster.
bookModel = loader.loadModel('phase_3.5/models/gui/stickerbook_gui.bam')
questCard = bookModel.find('**/questCard')
optiondefs = (('relief', None, None),
('image', questCard, None),
('image_scale', (0.8, 1.0, 0.58), None),
('state', DGG.NORMAL, None))
self.defineoptions(kw, optiondefs)
DirectFrame.__init__(self, relief = None)
self.initialiseoptions(QuestPoster)
self.questFrame = DirectFrame(parent = self, relief = None)
# Quest title text
self.headline = DirectLabel(parent = self.questFrame, relief = None,
text = self.quest.getName(),
text_font = CIGlobals.getMinnieFont(),
text_fg = QuestGlobals.TEXT_COLOR,
text_scale = 0.05,
text_align = TextNode.ACenter,
text_wordwrap = 25.0, textMayChange = 1,
pos = (0, 0, 0.23))
# Quest information
self.questInfo = DirectLabel(parent = self.questFrame, relief = None,
text = '',
text_font = CIGlobals.getToonFont(),
text_fg = QuestGlobals.TEXT_COLOR,
text_scale = 0.04,
text_align = TextNode.ACenter,
text_wordwrap = TEXT_WORDWRAP,
textMayChange = 1,
pos = (QuestGlobals.DEFAULT_INFO_POS))
self.questInfo.hide()
self.questInfo02 = DirectLabel(parent = self.questFrame, relief = None,
text = '',
text_font = CIGlobals.getToonFont(),
text_fg = QuestGlobals.TEXT_COLOR,
text_scale = 0.04,
text_align = TextNode.ACenter,
text_wordwrap = TEXT_WORDWRAP,
textMayChange = 1,
pos = (QuestGlobals.DEFAULT_INFO2_POS))
self.questInfo02.hide()
self.locationInfo = DirectLabel(parent = self.questFrame, relief = None,
text = 'N/A',
text_font = CIGlobals.getToonFont(),
text_fg = QuestGlobals.TEXT_COLOR,
text_scale = TEXT_SCALE,
text_align = TextNode.ACenter,
text_wordwrap = TEXT_WORDWRAP,
textMayChange = 1,
pos = (0, 0, -0.115))
self.locationInfo.hide()
# C'mon Brian this one is obvious
self.rewardText = DirectLabel(parent = self.questFrame, relief = None,
text = '',
text_fg = QuestGlobals.REWARD_RED,
text_scale = 0.0425,
text_align = TextNode.ALeft,
text_wordwrap = 17.0,
textMayChange = 1,
pos = (-0.36, 0, -0.26))
self.rewardText.hide()
self.lPictureFrame = DirectFrame(parent = self.questFrame, relief = None,
image = bookModel.find('**/questPictureFrame'),
image_scale = QuestGlobals.IMAGE_SCALE_SMALL,
text = '',
text_pos = (0, -0.11),
text_fg = QuestGlobals.TEXT_COLOR,
text_scale = TEXT_SCALE,
text_align = TextNode.ACenter,
text_wordwrap = 11.0,
pos = (QuestGlobals.DEFAULT_LEFT_PICTURE_POS),
textMayChange = 1)
self.lPictureFrame.hide()
self.rPictureFrame = DirectFrame(parent = self.questFrame, relief = None,
image = bookModel.find('**/questPictureFrame'),
image_scale = QuestGlobals.IMAGE_SCALE_SMALL,
text = '', text_pos = (0, -0.11),
text_fg = QuestGlobals.TEXT_COLOR,
text_scale = TEXT_SCALE,
text_align = TextNode.ACenter,
text_wordwrap = 11.0,
textMayChange = 1,
pos = (QuestGlobals.DEFAULT_RIGHT_PICTURE_POS))
self.rPictureFrame['image_color'] = Vec4(*QuestGlobals.GREEN)
self.rPictureFrame.hide()
self.lQuestIcon = DirectFrame(parent = self.lPictureFrame, relief = None,
text = ' ', text_font = CIGlobals.getSuitFont(),
text_pos = (0, -0.03),
text_fg = QuestGlobals.TEXT_COLOR,
text_scale = 0.13,
text_align = TextNode.ACenter,
text_wordwrap = 13.0,
textMayChange = 1)
self.lQuestIcon.setColorOff(-1)
self.rQuestIcon = DirectFrame(parent = self.rPictureFrame, relief = None,
text = ' ',
text_font = CIGlobals.getSuitFont(),
text_pos = (0, -0.03),
text_fg = QuestGlobals.TEXT_COLOR,
text_scale = 0.13,
text_align = TextNode.ACenter,
text_wordwrap = 13.0,
textMayChange = 1)
self.rQuestIcon.setColorOff(-1)
head = SuitBank.PennyPincher.getHead().generate()
head.setDepthTest(True)
head.setDepthWrite(True)
head.setScale(0.25)
for part in head.getChildren():
part.setDepthTest(True)
part.setDepthWrite(True)
self.fitGeometry(head, fFlip = 1)
self.rQuestIcon['geom'] = head
self.rQuestIcon['geom_scale'] = QuestGlobals.IMAGE_SCALE_SMALL
self.rQuestIcon['geom_pos'] = Point3(0, 10, -0.05)
self.rQuestIcon['geom_hpr'] = Point3(180, 0, 0)
self.rQuestIcon.initialiseoptions(DirectFrame)
self.auxText = DirectLabel(parent = self.questFrame, relief = None,
text = 'Recover',
text_font = CIGlobals.getToonFont(),
text_scale = QuestGlobals.QPauxText,
text_fg = QuestGlobals.TEXT_COLOR,
text_align = TextNode.ACenter,
pos = (QuestGlobals.DEFAULT_AUX_POS),
textMayChange=1)
self.auxText.hide()
self.middleText = DirectLabel(parent = self.questFrame, relief = None,
text = 'from:',
text_font = CIGlobals.getToonFont(),
text_scale = QuestGlobals.QPauxText,
text_fg = QuestGlobals.TEXT_COLOR,
text_align = TextNode.ACenter,
pos = (QuestGlobals.DEFAULT_MIDDLE_POS),
textMayChange=1)
self.middleText.hide()
self.questProgress = DirectWaitBar(parent = self.questFrame, relief = DGG.SUNKEN,
frameSize=(-0.95, 0.95, -0.1, 0.12),
borderWidth = (0.025, 0.025),
scale = 0.2,
frameColor = (0.945, 0.875, 0.706, 1.0),
barColor=(0.5, 0.7, 0.5, 1),
text='0/0',
text_font = CIGlobals.getToonFont(),
text_scale = 0.19,
text_fg = (0.05, 0.14, 0.4, 1),
text_align = TextNode.ACenter,
text_pos = (0, -0.05), #-0.02
pos = (0, 0, -0.2425))
self.questProgress.hide()
rewardFrameGeom = loader.loadModel('phase_4/models/gui/gag_shop_purchase_gui.bam')
self.rewardFrame = DirectFrame(parent = self.questFrame, relief = None,
geom = rewardFrameGeom.find('**/Goofys_Sign'),
geom_scale = (0.615, 0, 0.4),
pos = (-0.01, 0, -0.25)
)
jellybeanJar = QuestGlobals.getFilmIcon()
self.lRewardFrame = DirectFrame(parent = self.rewardFrame, relief = None,
geom = jellybeanJar,
geom_scale = QuestGlobals.TP_ACCESS_SCALE,
sortOrder = 1,
pos = (QuestGlobals.LEFT_TP_ACCESS_POS))
self.lRewardFrame.setBin('gui-popup', 30)
self.lRewardAmt = DirectFrame(parent = self.questFrame, relief = None,
geom = rewardFrameGeom.find('**/Char_Pnl'),
geom_scale = (0.15, 0, 0.1275),
text = '#1',
text_font = CIGlobals.getToonFont(),
text_scale = 0.04,
text_fg = (0, 0, 0, 1),
text_align = TextNode.ACenter,
text_pos = (0, -0.01),
sortOrder = 2,
pos = (-0.285, 0, -0.255))
self.lRewardAmt.setBin('gui-popup', 40)
self.rRewardFrame = DirectFrame(parent = self.rewardFrame, relief = None,
geom = QuestGlobals.getJBIcon(),
geom_scale = QuestGlobals.JB_JAR_SCALE,
pos = QuestGlobals.RIGHT_JB_JAR_POS)
self.rRewardAmt = DirectFrame(parent = self.questFrame, relief = None,
geom = rewardFrameGeom.find('**/Char_Pnl'),
geom_scale = (0.15, 0, 0.1275),
text = '25',
text_font = CIGlobals.getToonFont(),
text_scale = 0.04,
text_fg = (0, 0, 0, 1),
text_align = TextNode.ACenter,
text_pos = (0, -0.01),
pos = (0.2725, 0, -0.255))
self.rRewardAmt.setBin('gui-popup', 40)
rewardFrameGeom.removeNode()
# This is the rotated text on the side.
self.sideInfo = DirectLabel(parent = self.questFrame, relief = None,
text = QuestGlobals.JUST_FOR_FUN,
text_fg = (0.0, 0.439, 1.0, 1.0),
text_shadow = (0, 0, 0, 1),
pos = (-0.2825, 0, 0.2),
scale = 0.03)
self.sideInfo.setR(-30)
self.sideInfo.hide()
bookModel.removeNode()
self.laffMeter = None
self.hide()
return
def getRightOpenPoint(type):
return Point3(0, 0, 0)
def __init__(self, mass=1, location = Point3.zero(), velocity=Vec3.zero(), acceleration=Vec3.zero()):
# instance variables
self.mass = mass
self.location = location
self.velocity = velocity
self.acceleration = acceleration
def getRideElevatorInterval(type = ELEVATOR_NORMAL):
ival = Sequence(Wait(0.5), LerpPosInterval(camera, 0.5, Point3(0, 14, 3.8), startPos=Point3(0, 14, 4), blendType='easeOut'),
LerpPosInterval(camera, 0.5, Point3(0, 14, 4), startPos=Point3(0, 14, 3.8)),
Wait(1.0), LerpPosInterval(camera, 0.5, Point3(0, 14, 4.2), startPos=Point3(0, 14, 4), blendType='easeOut'),
LerpPosInterval(camera, 1.0, Point3(0, 14, 4), startPos=Point3(0, 14, 4.2)))
return ival
def getRightClosePoint(type):
width = ElevatorData[type]['width']
return Point3(-width, 0, 0)
def __init__(self):
ShowBase.__init__(self)
props = WindowProperties()
props.setCursorHidden(True)
props.setMouseMode(WindowProperties.MRelative)
self.win.requestProperties(props)
self.disableMouse()
self.environ = self.loader.loadModel('models/environment')
self.environ.reparentTo(self.render)
self.environ.setScale(.25, .25, .25)
self.environ.setPos(-8, 42, 0)
self.taskMgr.add(self.move_camera_task, 'move_camera_task')
self.taskMgr.add(self.move_projectiles_task, 'move_projectiles_task')
self.taskMgr.add(self.print_fps_task, 'print_fps_task')
self.key_map = {
'cam-forward': False,
'cam-backward': False,
'cam-left': False,
'cam-right': False,
}
self.accept('w', self.set_key, ['cam-forward', True])
self.accept('w-up', self.set_key, ['cam-forward', False])
self.accept('s', self.set_key, ['cam-backward', True])
self.accept('s-up', self.set_key, ['cam-backward', False])
self.accept('a', self.set_key, ['cam-left', True])
self.accept('a-up', self.set_key, ['cam-left', False])
self.accept('d', self.set_key, ['cam-right', True])
self.accept('d-up', self.set_key, ['cam-right', False])
self.accept('escape', sys.exit)
self.accept('mouse1', self.set_teapot)
self.panda = Actor('models/panda-model',
{'walk': 'models/panda-walk4'})
self.panda.setScale(.01, .01, .01)
self.panda.reparentTo(self.render)
self.panda.loop('walk')
point_a = Point3(0, -10, 0)
point_b = Point3(0, 10, 0)
point_c = Point3(180, 0, 0)
point_d = Point3(0, 0, 0)
self.panda_pace = Sequence(self.panda.posInterval(3,
point_a,
startPos=point_b),
self.panda.hprInterval(1,
point_c,
startHpr=point_d),
self.panda.posInterval(3,
point_b,
startPos=point_a),
self.panda.hprInterval(1,
point_d,
startHpr=point_c),
name='panda_pace')
self.panda_pace.loop()
self.teapot = self.loader.loadModel('teapot')
self.projectiles = []
self.fps_time = 0
self.fps = OnscreenText(text='0',
style=1,
fg=(1, 1, 1, 1),
pos=(1.75, .95),
align=TextNode.ARight,
scale=.05)
renderStateFactory = builder.setupRenderStateFactory()
# use the factory to produce a renderState from our node
renderState = renderStateFactory.getRenderState(node)
# and finally submit the renderState to get a shader
shader = builder.getShader(renderState)
node.setShader(shader)
## 5 - A Textured Panda, demo of a more compelex shader generator
# this time using the tex.gen script, read the script for info
shaderManager = shadergenerator.manager.getManager(
["shadergenerator/library"], "shadergenerator/graph/tex.gen")
shaderManager.genShaders(getNode(True))
## 6 - A Lit Panda, demo of a more compelex shader generator
# this time using the lit.gen script, read the script for info
shaderManager = shadergenerator.manager.getManager(
["shadergenerator/library"], "shadergenerator/graph/lit.gen")
node = getNode(True)
# this script requires a dlight input, so add one:
from panda3d.core import DirectionalLight, Vec4, Point3, AmbientLight
dlight = DirectionalLight('dlight')
dlight.setColor(Vec4(4.9, 0.9, 0.8, 1))
dlnp = render.attachNewNode(dlight)
node.setShaderInput('dlight', dlnp)
dayCycle = dlnp.hprInterval(10.0, Point3(0, 360, 0))
dayCycle.loop()
node.setShaderInput('fogDensity', .0001)
shaderManager.genShaders(node)
run()
def __init__(self, entity, mesh=None, center=(0, 0, 0)):
super().__init__()
if mesh == None and entity.model:
print('auto gen mesh colider from entity mesh')
mesh = entity.model
self.node_path = entity.attachNewNode(CollisionNode('CollisionNode'))
self.node_path.setP(90)
node = self.node_path.node()
if mesh.triangles:
for tri in mesh.triangles:
if len(tri) == 3:
shape = CollisionPolygon(
Point3(tri[0]) + Point3(center),
Point3(tri[1]) + Point3(center),
Point3(tri[2]) + Point3(center))
node.addSolid(shape)
elif len(tri) == 4:
shape = CollisionPolygon(
Point3(tri[0]) + Point3(center),
Point3(tri[1]) + Point3(center),
Point3(tri[2]) + Point3(center))
node.addSolid(shape)
shape = CollisionPolygon(
Point3(tri[2]) + Point3(center),
Point3(tri[3]) + Point3(center),
Point3(tri[0]) + Point3(center))
node.addSolid(shape)
else:
for i in range(0, len(mesh.vertices) - 3, 3):
node.addSolid(
CollisionPolygon(
Point3(mesh.vertices[i]) + Point3(center),
Point3(mesh.vertices[i + 1]) + Point3(center),
Point3(mesh.vertices[i + 2]) + Point3(center)))
self.visible = False
class DistributedDodgeballGame(DistributedToonFPSGame, TeamMinigame):
notify = directNotify.newCategory('DistributedDodgeballGame')
TreeData = [
[
'prop_snow_tree_small_ur', Point3(23.23, 66.52, 7.46)],
[
'prop_snow_tree_small_ul', Point3(-34.03, 88.02, 24.17)],
[
'prop_snow_tree_small_ur', Point3(-54.8, 0, 4.19)],
[
'prop_snow_tree_small_ul', Point3(54.8, -5, 4.19)],
[
'prop_snow_tree_small_ur', Point3(62.71, 62.66, 16.8)],
[
'prop_snow_tree_small_ul', Point3(-23.23, -66.52, 6)],
[
'prop_snow_tree_small_ur', Point3(34.03, -88.02, 23)],
[
'prop_snow_tree_small_ul', Point3(-62.71, -62.66, 16)]]
SnowballData = [
Point3(30, 0, 0.75),
Point3(22.5, 0, 0.75),
Point3(15, 0, 0.75),
Point3(7.5, 0, 0.75),
Point3(0, 0, 0.75),
Point3(-7.5, 0, 0.75),
Point3(-15, 0, 0.75),
Point3(-22.5, 0, 0.75),
Point3(-30, 0, 0.75)]
GameSong = 'phase_4/audio/bgm/MG_Dodgeball.ogg'
GameDesc = 'Welcome to the north! You have been invited to play dodgeball with the penguins!\n\nHow To Play\nWASD to Move and use the mouse to aim.\nLeft click to Throw!\nThrow a snowball at a teammate to unfreeze them!\n\nObjective\nThe first team to freeze everyone!'
InitCamTrans = [
Point3(25, 45, 19.5317), Vec3(154.001, -15, 0)]
SnowBallDmg = 25
GetSnowBalls = 'Pick up a snowball from the center!'
Team2OtherBarrier = {BLUE: 'red_barrier_coll', RED: 'blue_barrier_coll'}
def __init__(self, cr):
try:
self.DistributedDodgeballGame_initialized
return
except:
self.DistributedDodgeballGame_initialized = 1
DistributedToonFPSGame.__init__(self, cr)
TeamMinigame.__init__(self, 'BlueSnow', ('phase_4/maps/db_blue_neutral.png',
'phase_4/maps/db_blue_hover.png',
'phase_4/maps/db_blue_hover.png'), 'RedIce', ('phase_4/maps/db_red_neutral.png',
'phase_4/maps/db_red_hover.png',
'phase_4/maps/db_red_hover.png'))
self.fsm.addState(State('chooseTeam', self.enterChooseTeam, self.exitChooseTeam, ['waitForOthers']))
self.fsm.addState(State('scrollBy', self.enterScrollBy, self.exitScrollBy, ['countdown']))
self.fsm.addState(State('countdown', self.enterCountdown, self.exitCountdown, ['play']))
self.fsm.addState(State('announceGameOver', self.enterAnnGameOver, self.exitAnnGameOver, ['displayWinners']))
self.fsm.addState(State('displayWinners', self.enterDisplayWinners, self.exitDisplayWinners, ['gameOver']))
self.fsm.getStateNamed('waitForOthers').addTransition('chooseTeam')
self.fsm.getStateNamed('waitForOthers').addTransition('scrollBy')
self.fsm.getStateNamed('play').addTransition('announceGameOver')
self.firstPerson = DodgeballFirstPerson(self)
self.scrollBySeq = None
self.infoText = None
self.redScoreLbl = None
self.blueScoreLbl = None
self.infoText = getAlertText()
self.spawnPointsByTeam = {BLUE: [
[
Point3(5, 15, 0), Vec3(180, 0, 0)],
[
Point3(15, 15, 0), Vec3(180, 0, 0)],
[
Point3(-5, 15, 0), Vec3(180, 0, 0)],
[
Point3(-15, 15, 0), Vec3(180, 0, 0)]],
RED: [
[
Point3(5, -15, 0), Vec3(0, 0, 0)],
[
Point3(15, -15, 0), Vec3(0, 0, 0)],
[
Point3(-5, -15, 0), Vec3(0, 0, 0)],
[
Point3(-15, -15, 0), Vec3(0, 0, 0)]]}
self.winnerMusic = base.loadMusic('phase_9/audio/bgm/encntr_hall_of_fame.mid')
self.loserMusic = base.loadMusic('phase_9/audio/bgm/encntr_sting_announce.mid')
self.danceSound = base.loadSfx('phase_3.5/audio/sfx/ENC_Win.ogg')
self.sky = None
self.arena = None
self.fog = None
self.snow = None
self.snowRender = None
self.trees = []
self.snowballs = []
return
def getTeamDNAColor(self, team):
print 'getTeamDNAColor'
if team == TEAM1:
print 'blue'
return ToonDNA.colorName2DNAcolor['blue']
if team == TEAM2:
print 'bright red'
return ToonDNA.colorName2DNAcolor['bright red']
def enterDisplayWinners(self):
base.localAvatar.stopLookAround()
base.localAvatar.resetHeadHpr()
base.localAvatar.getGeomNode().show()
camera.reparentTo(render)
camera.setPos((-2.5, 12, 3.5))
camera.setHpr((-175.074, -5.47218, 0))
base.transitions.fadeIn()
base.playSfx(self.danceSound, looping=1)
if self.winnerTeam == self.team:
base.playMusic(self.winnerMusic, volume=0.8)
else:
base.playMusic(self.loserMusic, volume=0.8)
winnerPositions = [(-2, 0, 0), (2, 0, 0), (6, 0, 0), (-6, 0, 0)]
loserPositions = [(-3.5, -10, 0), (-1.5, -15, 0), (3.0, -8, 0), (5.5, -12, 0)]
for team in [RED, BLUE]:
for avId in self.playerListByTeam[team]:
av = self.cr.doId2do.get(avId)
if av:
av.stopSmooth()
av.setHpr(0, 0, 0)
if team == self.winnerTeam:
posList = winnerPositions
av.setAnimState('off')
av.stop()
if not self.getRemoteAvatar(avId).isFrozen:
av.loop('win')
else:
posList = loserPositions
av.setAnimState('off')
av.stop()
if not self.getRemoteAvatar(avId).isFrozen:
av.loop('pout')
pos = random.choice(posList)
posList.remove(pos)
av.setPos(pos)
if self.winnerTeam == team:
text = 'YOU WIN!'
else:
text = 'YOU LOSE!'
self.gameOverLbl.setText(text)
self.track = Sequence(Wait(2.0), Func(self.gameOverLbl.setScale, 0.01), Func(self.gameOverLbl.show), getAlertPulse(self.gameOverLbl, 0.27, 0.25))
self.track.start()
def exitDisplayWinners(self):
base.transitions.noTransitions()
self.danceSound.stop()
if hasattr(self, 'track'):
self.track.finish()
self.track = None
self.gameOverLbl.hide()
return
def enterAnnGameOver(self, timeRanOut=0):
self.firstPerson.vModel.hide()
text = 'GAME\nOVER'
if timeRanOut:
text = "TIME's\nUP"
self.gameOverLbl.setText(text)
self.gameOverLbl.show()
base.transitions.fadeScreen()
taskMgr.doMethodLater(3.0, self.__annGameOverTask, self.uniqueName('annGameOverTask'))
def __annGameOverTask(self, task):
self.gameOverLbl.hide()
self.ival = Sequence(base.transitions.getFadeOutIval(), Func(self.fsm.request, 'displayWinners'))
self.ival.start()
return task.done
def exitAnnGameOver(self):
taskMgr.remove(self.uniqueName('annGameOverTask'))
if hasattr(self, 'ival'):
self.ival.finish()
del self.ival
self.gameOverLbl.hide()
def teamWon(self, team):
self.winnerTeam = team
base.localAvatar.disableAvatarControls()
self.firstPerson.end()
self.deleteTimer()
self.fsm.request('announceGameOver')
def incrementTeamScore(self, team):
TeamMinigame.incrementTeamScore(self, team)
if team == BLUE:
self.blueScoreLbl.setText('BLUE: ' + str(self.scoreByTeam[team]))
ToontownIntervals.start(ToontownIntervals.getPulseLargerIval(self.blueScoreLbl, 'blueScorePulse'))
else:
if team == RED:
self.redScoreLbl.setText('RED: ' + str(self.scoreByTeam[team]))
ToontownIntervals.start(ToontownIntervals.getPulseLargerIval(self.redScoreLbl, 'redScorePulse'))
def getWinterDodgeballScoreText(self, color):
text = OnscreenText(fg=color, font=CIGlobals.getMinnieFont(), scale=0.15, shadow=(0,
0,
0,
1))
return text
def snowballHitWall(self, snowballIndex):
snowball = self.snowballs[snowballIndex]
snowball.handleHitWallOrPlayer()
base.playSfx(snowball.impactSound, node=snowball, volume=1.5)
def snowballHitGround(self, snowballIndex):
snowball = self.snowballs[snowballIndex]
snowball.handleHitGround()
base.playSfx(snowball.impactSound, node=snowball, volume=1.5)
def snowballHitPlayer(self, damagedPlayer, throwerTeam, snowballIndex):
av = self.getRemoteAvatar(damagedPlayer)
if av:
if throwerTeam == av.team:
if av.unFreeze():
if damagedPlayer == base.localAvatar.doId:
self.showAlert('A team member has unfroze you!')
self.firstPerson.camFSM.request('unfrozen')
self.sendUpdate('teamMateUnfrozeMe', [self.team])
elif av.freeze():
if damagedPlayer == base.localAvatar.doId:
self.showAlert("You've been frozen by an enemy!")
self.firstPerson.camFSM.request('frozen')
self.sendUpdate('enemyFrozeMe', [self.team, throwerTeam])
snowball = self.snowballs[snowballIndex]
snowball.handleHitWallOrPlayer()
base.playSfx(snowball.impactSound, node=snowball, volume=1.5)
def playerCaughtSnowball(self, snowballIndex, catcherId):
av = self.getRemoteAvatar(catcherId)
if av:
snowball = self.snowballs[snowballIndex]
snowball.pauseThrowIval()
snowball.pickup(av)
def setupRemoteAvatar(self, avId):
av = RemoteDodgeballAvatar(self, self.cr, avId)
if avId == self.cr.localAvId:
self.myRemoteAvatar = av
self.remoteAvatars.append(av)
def __getSnowTree(self, path):
trees = loader.loadModel('phase_8/models/props/snow_trees.bam')
tree = trees.find('**/' + path)
tree.find('**/*shadow*').removeNode()
return tree
def load(self):
self.setMinigameMusic(DistributedDodgeballGame.GameSong)
self.setDescription(DistributedDodgeballGame.GameDesc)
self.setWinnerPrize(200)
self.setLoserPrize(0)
self.createWorld()
self.blueScoreLbl = self.getWinterDodgeballScoreText(VBase4(0, 0, 1, 1))
self.blueScoreLbl.reparentTo(base.a2dTopLeft)
self.blueScoreLbl['align'] = TextNode.ALeft
self.blueScoreLbl.setText('Blue: 0')
self.blueScoreLbl.setZ(-0.17)
self.blueScoreLbl.setX(0.05)
self.blueScoreLbl.hide()
self.redScoreLbl = self.getWinterDodgeballScoreText(VBase4(1, 0, 0, 1))
self.redScoreLbl.reparentTo(base.a2dTopLeft)
self.redScoreLbl['align'] = TextNode.ALeft
self.redScoreLbl.setText('Red: 0')
self.redScoreLbl.setZ(-0.35)
self.redScoreLbl.setX(0.05)
self.redScoreLbl.hide()
trans = DistributedDodgeballGame.InitCamTrans
camera.setPos(trans[0])
camera.setHpr(trans[1])
DistributedToonFPSGame.load(self)
def createWorld(self):
self.deleteWorld()
self.sky = loader.loadModel('phase_3.5/models/props/BR_sky.bam')
self.sky.reparentTo(render)
self.sky.setZ(-40)
self.sky.setFogOff()
self.arena = loader.loadModel('phase_4/models/minigames/dodgeball_arena.egg')
self.arena.reparentTo(render)
self.arena.setScale(0.75)
self.arena.find('**/team_divider').setBin('ground', 18)
self.arena.find('**/floor').setBin('ground', 18)
self.arena.find('**/team_divider_coll').setCollideMask(CIGlobals.FloorBitmask)
for data in DistributedDodgeballGame.TreeData:
code = data[0]
pos = data[1]
tree = self.__getSnowTree(code)
tree.reparentTo(self.arena)
tree.setPos(pos)
self.trees.append(tree)
for i in xrange(len(DistributedDodgeballGame.SnowballData)):
snowdata = DistributedDodgeballGame.SnowballData[i]
snowball = Snowball(self, i)
snowball.load()
snowball.reparentTo(render)
snowball.setPos(snowdata)
self.snowballs.append(snowball)
self.snow = ParticleLoader.loadParticleEffect('phase_8/etc/snowdisk.ptf')
self.snow.setPos(0, 0, 5)
self.snowRender = self.arena.attachNewNode('snowRender')
self.snowRender.setDepthWrite(0)
self.snowRender.setBin('fixed', 1)
self.snow.start(camera, self.snowRender)
self.fog = Fog('snowFog')
self.fog.setColor(0.486, 0.784, 1)
self.fog.setExpDensity(0.003)
render.setFog(self.fog)
def throw(self, snowballIndex, p):
snowball = self.snowballs[snowballIndex]
snowball.throw(p)
def snowballPickup(self, snowballIndex, pickerUpperAvId):
remoteAv = self.getRemoteAvatar(pickerUpperAvId)
if remoteAv:
snowball = self.snowballs[snowballIndex]
snowball.pickup(remoteAv)
def deleteWorld(self):
if self.redScoreLbl:
self.redScoreLbl.destroy()
self.redScoreLbl = None
if self.blueScoreLbl:
self.blueScoreLbl.destroy()
self.blueScoreLbl = None
for snowball in self.snowballs:
snowball.removeNode()
self.snowballs = []
for tree in self.trees:
tree.removeNode()
self.trees = []
if self.snow:
self.snow.cleanup()
self.snow = None
if self.snowRender:
self.snowRender.removeNode()
self.snowRender = None
self.fog = None
if self.sky:
self.sky.removeNode()
self.sky = None
if self.arena:
self.arena.removeNode()
self.arena = None
render.clearFog()
return
def enterPlay(self):
self.createTimer()
self.redScoreLbl.show()
self.blueScoreLbl.show()
self.firstPerson.camFSM.request('unfrozen')
self.arena.find('**/' + self.Team2OtherBarrier[self.team]).stash()
def exitPlay(self):
self.firstPerson.crosshair.destroy()
self.firstPerson.crosshair = None
self.firstPerson.camFSM.request('off')
DistributedToonFPSGame.exitPlay(self)
return
def enterCountdown(self):
self.firstPerson.start()
self.firstPerson.disableMouse()
self.infoText.setText(DistributedDodgeballGame.GetSnowBalls)
self.countdownText = getGameText()
self.countdownIval = Parallel(Sequence(Func(self.countdownText.setText, '5'), getCountdownIval(self.countdownText), Func(self.countdownText.setText, '4'), getCountdownIval(self.countdownText), Func(self.countdownText.setText, '3'), getCountdownIval(self.countdownText), Func(self.countdownText.setText, '2'), getCountdownIval(self.countdownText), Func(self.countdownText.setText, '1'), getCountdownIval(self.countdownText)), getAlertPulse(self.infoText), name='COUNTDOWNIVAL')
self.countdownIval.setDoneEvent(self.countdownIval.getName())
self.acceptOnce(self.countdownIval.getDoneEvent(), self.__handleCountdownDone)
self.countdownIval.start()
def __handleCountdownDone(self):
self.fsm.request('play')
def exitCountdown(self):
if hasattr(self, 'countdownText'):
self.countdownText.destroy()
del self.countdownText
if hasattr(self, 'countdownIval'):
self.ignore(self.countdownIval.getDoneEvent())
self.countdownIval.finish()
del self.countdownIval
def enterScrollBy(self):
BLUE_START_POS = Point3(-20, 0, 4)
BLUE_END_POS = Point3(20, 0, 4)
BLUE_HPR = Vec3(0, 0, 0)
RED_START_POS = Point3(20, 0, 4)
RED_END_POS = Point3(-20, 0, 4)
RED_HPR = Vec3(180, 0, 0)
self.playMinigameMusic()
self.scrollBySeq = Sequence(Func(camera.setHpr, BLUE_HPR), LerpPosInterval(camera, duration=5.0, pos=BLUE_END_POS, startPos=BLUE_START_POS, blendType='easeOut'), Func(base.transitions.fadeOut, 0.4), Wait(0.5), Func(base.transitions.fadeIn, 0.4), Func(camera.setHpr, RED_HPR), LerpPosInterval(camera, duration=5.0, pos=RED_END_POS, startPos=RED_START_POS, blendType='easeOut'), name='SCROLLBYSEQ')
self.scrollBySeq.setDoneEvent(self.scrollBySeq.getName())
self.acceptOnce(self.scrollBySeq.getDoneEvent(), self.__handleScrollByDone)
self.scrollBySeq.start()
def __handleScrollByDone(self):
self.fsm.request('countdown')
def exitScrollBy(self):
if self.scrollBySeq:
self.ignore(self.scrollBySeq.getDoneEvent())
self.scrollBySeq.finish()
self.scrollBySeq = None
return
def allPlayersReady(self):
self.fsm.request('scrollBy')
def chooseUrTeam(self):
self.fsm.request('chooseTeam')
def enterChooseTeam(self):
self.makeSelectionGUI()
def acceptedIntoTeam(self, spawnPoint):
TeamMinigame.acceptedIntoTeam(self)
self.sendUpdate('readyToStart')
self.fsm.request('waitForOthers')
pos, hpr = self.spawnPointsByTeam[self.team][spawnPoint]
base.localAvatar.setPos(pos)
base.localAvatar.setHpr(hpr)
def exitChooseTeam(self):
self.destroySelectionGUI()
def announceGenerate(self):
DistributedToonFPSGame.announceGenerate(self)
base.camLens.setMinFov(CIGlobals.GunGameFOV / (4.0 / 3.0))
self.load()
def disable(self):
base.camLens.setMinFov(CIGlobals.DefaultCameraFov / (4.0 / 3.0))
self.fsm.requestFinalState()
self.deleteWorld()
self.trees = None
self.snowballs = None
self.spawnPointsByTeam = None
if self.firstPerson:
self.firstPerson.reallyEnd()
self.firstPerson.cleanup()
self.firstPerson = None
self.scrollBySeq = None
self.winnerMusic = None
self.loserMusic = None
self.danceSound = None
self.infoText = None
base.localAvatar.setWalkSpeedNormal()
DistributedToonFPSGame.disable(self)
return
def __init__(self):
DirectObject.__init__(self)
self.mouseEnabled = False
self.lastCamRoot2Quat = Quat(Quat.identQuat())
self.punchAngleVel = Vec3(0)
self.punchAngle = Vec3(0)
self.lastFacing = Vec3(0)
self.lastMousePos = Point2(0)
self.currMousePos = Point2(0)
self.bobTime = 0
self.lastBobTime = 0
self.lastVMPos = Point3(0)
self.camRoot = NodePath("camRoot")
self.camRoot2 = self.camRoot.attachNewNode("camRoot2")
self.lastPitch = 0
self.lastEyeHeight = 0.0
# Updates to the transform of camRoot
self.vmRender = NodePath(
BSPRender('vmRender', BSPLoader.getGlobalPtr()))
self.vmRender.setShaderAuto()
self.vmRoot = self.vmRender.attachNewNode('vmRoot')
self.vmRoot2 = self.vmRoot.attachNewNode(ModelRoot('vmRoot2'))
self.viewModel = Actor(
"phase_14/models/char/v_toon_arms.bam",
{
"zero": "phase_14/models/char/v_toon_arms.egg",
# Squirt gun viewmodel animations
"sg_draw": "phase_14/models/char/v_toon_arms-draw.egg",
"sg_idle": "phase_14/models/char/v_toon_arms-idle.egg",
"sg_inspect": "phase_14/models/char/v_toon_arms-inspect.egg",
"sg_shoot_begin":
"phase_14/models/char/v_toon_arms-shoot_begin.egg",
"sg_shoot_loop":
"phase_14/models/char/v_toon_arms-shoot_loop.egg",
"sg_shoot_end":
"phase_14/models/char/v_toon_arms-shoot_end.egg",
"pie_draw": "phase_14/models/char/v_toon_arms-pie_draw.egg",
"pie_idle": "phase_14/models/char/v_toon_arms-pie_idle.egg",
"button_draw":
"phase_14/models/char/v_toon_arms-button_draw.egg",
"button_idle":
"phase_14/models/char/v_toon_arms-button_idle.egg",
"button_press":
"phase_14/models/char/v_toon_arms-button_press.egg",
"gumball_draw":
"phase_14/models/char/v_toon_arms-gumball_draw.egg",
"gumball_idle":
"phase_14/models/char/v_toon_arms-gumball_idle.egg",
"gumball_fire":
"phase_14/models/char/v_toon_arms-gumball_fire.egg",
"hose_draw": "phase_14/models/char/v_toon_arms-hose_draw.egg",
"hose_idle": "phase_14/models/char/v_toon_arms-hose_idle.egg",
"hose_shoot_begin":
"phase_14/models/char/v_toon_arms-hose_shoot_begin.egg",
"hose_shoot_loop":
"phase_14/models/char/v_toon_arms-hose_shoot_loop.egg",
"hose_shoot_end":
"phase_14/models/char/v_toon_arms-hose_shoot_end.egg",
"tnt_draw": "phase_14/models/char/v_toon_arms-tnt_draw.egg",
"tnt_idle": "phase_14/models/char/v_toon_arms-tnt_idle.egg",
"tnt_throw": "phase_14/models/char/v_toon_arms-tnt_throw.egg",
"slap_idle": "phase_14/models/char/v_toon_arms-slap_idle.egg",
"slap_hit": "phase_14/models/char/v_toon_arms-slap_hit.egg",
"sound": "phase_14/models/char/v_toon_arms-sound.egg"
})
self.viewModel.setBlend(
frameBlend=base.config.GetBool("interpolate-frames", False))
self.viewModel.reparentTo(self.vmRoot2)
self.viewModel.find("**/hands").setTwoSided(True)
self.viewModel.hide()
self.defaultViewModel = self.viewModel
self.idealFov = self.ViewModelFOV
precacheActor(self.viewModel)
#self.viewModel.clearMaterial()
#self.viewModel.setMaterial(CIGlobals.getCharacterMaterial(specular = (0, 0, 0, 1)), 1)
self.viewportLens = PerspectiveLens()
self.viewportLens.setMinFov(self.ViewModelFOV / (4. / 3.))
self.viewportLens.setNear(0.3)
# Updates to the transform of base.camera
self.viewportCam = base.makeCamera(base.win,
clearDepth=True,
camName='fpsViewport',
mask=CIGlobals.ViewModelCamMask,
lens=self.viewportLens)
# Pretend to be the main camera so the viewmodel gets ambient probes updated
self.viewportCam.node().setTag("__mainpass__", "1")
self.viewportCam.reparentTo(self.vmRoot)
self.vmGag = None
self.vmAnimTrack = None
self.dmgFade = OnscreenImage(image="phase_14/maps/damage_effect.png",
parent=render2d)
self.dmgFade.setBin('gui-popup', 100)
self.dmgFade.setTransparency(1)
self.dmgFade.setColorScale(1, 1, 1, 0)
self.dmgFadeIval = None
#self.accept('v', self.vmRender.ls)
#base.bspLoader.addDynamicNode(self.vmRoot)
if self.PrintAnimLengths:
print "v_toon_arms animation lengths:"
for anim in self.viewModel.getAnimNames():
print "\t{0}\t:\t{1}".format(anim,
self.viewModel.getDuration(anim))
taskMgr.add(self.__vpDebugTask, "vpdebutask", sort=-100)
def __updateTask(self, task):
# TODO -- This function does a lot of math, I measured it to take .5 ms on my laptop
# That's a lot of time for something miniscule like sway and bob.
dt = globalClock.getDt()
time = globalClock.getFrameTime()
if base.localAvatar.isFirstPerson():
eyePoint = base.localAvatar.getEyePoint()
if base.localAvatar.walkControls.crouching:
eyePoint[2] = eyePoint[2] / 2.0
eyePoint[2] = CIGlobals.lerpWithRatio(eyePoint[2],
self.lastEyeHeight, 0.4)
self.lastEyeHeight = eyePoint[2]
camRootAngles = Vec3(0)
# Mouse look around
mw = base.mouseWatcherNode
if mw.hasMouse():
md = base.win.getPointer(0)
center = Point2(base.win.getXSize() / 2, base.win.getYSize() / 2)
xDist = md.getX() - center.getX()
yDist = md.getY() - center.getY()
sens = self.__getMouseSensitivity()
angular = -(xDist * sens) / dt
base.localAvatar.walkControls.controller.setAngularMovement(
angular)
camRootAngles.setY(self.lastPitch - yDist * sens)
if camRootAngles.getY() > FPSCamera.MaxP:
camRootAngles.setY(FPSCamera.MaxP)
yDist = 0
elif camRootAngles.getY() < FPSCamera.MinP:
yDist = 0
camRootAngles.setY(FPSCamera.MinP)
base.win.movePointer(0, int(center.getX()), int(center.getY()))
if base.localAvatar.isFirstPerson():
# Camera / viewmodel bobbing
vmBob = Point3(0)
vmAngles = Vec3(0)
vmRaise = Point3(0)
camBob = Point3(0)
maxSpeed = base.localAvatar.walkControls.BattleRunSpeed * 16.0
speed = base.localAvatar.walkControls.speeds.length() * 16.0
speed = max(-maxSpeed, min(maxSpeed, speed))
bobOffset = CIGlobals.remapVal(speed, 0, maxSpeed, 0.0, 1.0)
self.bobTime += (time - self.lastBobTime) * bobOffset
self.lastBobTime = time
# Calculate the vertical bob
cycle = self.bobTime - int(
self.bobTime / self.BobCycleMax) * self.BobCycleMax
cycle /= self.BobCycleMax
if cycle < self.BobUp:
cycle = math.pi * cycle / self.BobUp
else:
cycle = math.pi + math.pi * (cycle - self.BobUp) / (1.0 -
self.BobUp)
verticalBob = speed * 0.005
verticalBob = verticalBob * 0.3 + verticalBob * 0.7 * math.sin(
cycle)
verticalBob = max(-7.0, min(4.0, verticalBob))
verticalBob /= 16.0
# Calculate the lateral bob
cycle = self.bobTime - int(
self.bobTime / self.BobCycleMax * 2) * self.BobCycleMax * 2
cycle /= self.BobCycleMax * 2
if cycle < self.BobUp:
cycle = math.pi * cycle / self.BobUp
else:
cycle = math.pi + math.pi * (cycle - self.BobUp) / (1.0 -
self.BobUp)
lateralBob = speed * 0.005
lateralBob = lateralBob * 0.3 + lateralBob * 0.7 * math.sin(cycle)
lateralBob = max(-7.0, min(4.0, lateralBob))
lateralBob /= 16.0
# Apply bob, but scaled down a bit
vmBob.set(lateralBob * 0.8, 0, verticalBob * 0.1)
# Z bob a bit more
vmBob[2] += verticalBob * 0.1
# Bob the angles
vmAngles[2] += verticalBob * 0.5
vmAngles[1] -= verticalBob * 0.4
vmAngles[0] -= lateralBob * 0.3
# ================================================================
# Viewmodel lag/sway
angles = self.camRoot.getHpr(render)
quat = Quat()
quat.setHpr(angles)
invQuat = Quat()
invQuat.invertFrom(quat)
maxVMLag = 1.5
lagforward = quat.getForward()
if dt != 0.0:
lagdifference = lagforward - self.lastFacing
lagspeed = 5.0
lagdiff = lagdifference.length()
if (lagdiff > maxVMLag) and (maxVMLag > 0.0):
lagscale = lagdiff / maxVMLag
lagspeed *= lagscale
self.lastFacing = CIGlobals.extrude(self.lastFacing,
lagspeed * dt,
lagdifference)
self.lastFacing.normalize()
lfLocal = invQuat.xform(lagdifference)
vmBob = CIGlobals.extrude(vmBob, 5.0 / 16.0, lfLocal * -1.0)
pitch = angles[1]
if pitch > 180:
pitch -= 360
elif pitch < -180:
pitch += 360
vmBob = CIGlobals.extrude(vmBob, pitch * (0.035 / 16),
Vec3.forward())
vmBob = CIGlobals.extrude(vmBob, pitch * (0.03 / 16), Vec3.right())
vmBob = CIGlobals.extrude(vmBob, pitch * (0.02 / 16), Vec3.up())
# ================================================================
vmRaise.set(
0, 0, 0
) #(0, abs(camRootAngles.getY()) * -0.002, camRootAngles.getY() * 0.002)
camBob.set(0, 0, 0)
# Apply bob, raise, and sway to the viewmodel.
self.viewModel.setPos(vmBob + vmRaise + self.lastVMPos)
self.vmRoot2.setHpr(vmAngles)
self.camRoot.setPos(eyePoint + camBob)
newPitch = camRootAngles.getY()
if abs(newPitch - self.lastPitch) > self.PitchUpdateEpsilon:
# Broadcast where our head is looking
head = base.localAvatar.getPart("head")
if head and not head.isEmpty():
# Constrain the head pitch a little bit so it doesn't look like their head snapped
headPitch = max(-47, newPitch)
headPitch = min(75, headPitch)
base.localAvatar.b_setLookPitch(headPitch)
self.lastPitch = newPitch
if base.localAvatar.isFirstPerson():
# Apply punch angle
self.decayPunchAngle()
camRootAngles += self.punchAngle
self.camRoot.setHpr(camRootAngles)
return task.cont
def __init__(self):
ShowBase.__init__(self)
# Load the environment model.
self.environ = self.loader.loadModel("models/environment")
# self.environ is now a NodePath, or a handler for the node (the actual model)
# could load the same model several times with different NodePaths
# Reparent the NodePath to render, so the engine knows to show it in the scene.
self.environ.reparentTo(self.render)
# Apply scale and position transforms on the NodePath.
self.environ.setScale(0.25, 0.25, 0.25)
self.environ.setPos(-8, 42, 0)
# disable the mouse so it does not interfere with camera
base.disableMouse()
# set up some keyboard input
self.accept("escape", sys.exit) # Escape quits
self.accept("space", self.toggle_camera_spin) # spacebar
# set up a variable to keep track of camera toggle
self.spin_camera = True
# variable to keep track of total time spinning
self.spin_time = 0
# go ahead and start camera spinning
self.toggle_camera_spin()
# Load and transform the panda actor.
self.panda_actor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.panda_actor.setScale(0.005, 0.005, 0.005)
self.panda_actor.reparentTo(self.render)
# Loop the animation.
self.panda_actor.loop("walk")
# Create the four lerp intervals needed for the panda to
# walk back and forth.
panda_pos_interval1 = self.panda_actor.posInterval(13,
Point3(0, -10, 0),
startPos=Point3(
0, 10, 0))
panda_pos_interval2 = self.panda_actor.posInterval(13,
Point3(0, 10, 0),
startPos=Point3(
0, -10, 0))
panda_hpr_interval1 = self.panda_actor.hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(
0, 0, 0))
panda_hpr_interval2 = self.panda_actor.hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(
180, 0, 0))
# Create and play the sequence that coordinates the intervals.
self.panda_pace = Sequence(panda_pos_interval1,
panda_hpr_interval1,
panda_pos_interval2,
panda_hpr_interval2,
name="pandaPace")
self.panda_pace.loop()
# Add a smiley for fun.
self.smiley = self.loader.loadModel("models/smiley")
self.smiley.setPos(0, 0, 1)
self.smiley.reparentTo(self.render)
# velocity adjustment
self.vel_base = 3
# add task to allow smiley movement
self.taskMgr.add(self.game_loop_task, "GameLoop")
def getSprayStartPos(self):
return Point3(0, 0, 0)
def calcTargetScale():
distance = Vec3(target - origin).length()
yScale = distance / GagGlobals.SPRAY_LEN
targetScale = Point3(yScale * horizScale, yScale,
yScale * vertScale)
return targetScale
def getSprayTrack(self,
origin,
target,
scaleUp,
hold,
scaleDown,
horizScale=1.0,
vertScale=1.0):
if self.sprayJoint.isEmpty():
self.build()
self.origin = self.getSprayStartPos()
base.localAvatar.stop(self.toonAnim)
self.lastFrame = self.avatar.getCurrentFrame(self.toonAnim)
track = Sequence()
sprayProp = loader.loadModel(GagGlobals.SPRAY_MDL)
sprayProp.setTwoSided(1)
sprayScale = hidden.attachNewNode('spray-parent')
sprayRot = hidden.attachNewNode('spray-rotate')
sprayRot.setColor(GagGlobals.WATER_SPRAY_COLOR)
sprayRot.setTransparency(1)
collNode = CollisionNode('Collision')
spraySphere = CollisionSphere(0, 0, 0, 1)
spraySphere.setTangible(0)
collNode.addSolid(spraySphere)
collNode.setCollideMask(CIGlobals.WallBitmask)
sprayNP = sprayRot.attachNewNode(collNode)
sprayNP.setY(1)
self.sprayNP = sprayNP
event = CollisionHandlerEvent()
event.set_in_pattern("%fn-into")
event.set_out_pattern("%fn-out")
base.cTrav.add_collider(sprayNP, event)
self.avatar.acceptOnce(sprayNP.node().getName() + '-into',
self.onCollision)
def showSpray(sprayScale, sprayProp, origin, target):
objects = [sprayRot, sprayScale, sprayProp]
for item in objects:
index = objects.index(item)
if index == 0:
item.reparentTo(self.sprayJoint)
item.setPos(0, 0, 0)
item.setHpr(self.sprayRotation)
item.wrtReparentTo(render)
else:
item.reparentTo(objects[index - 1])
track.append(Func(showSpray, sprayScale, sprayProp, origin, target))
self.spray = sprayRot
def calcTargetScale():
distance = Vec3(target - origin).length()
yScale = distance / GagGlobals.SPRAY_LEN
targetScale = Point3(yScale * horizScale, yScale,
yScale * vertScale)
return targetScale
track.append(
Parallel(
LerpScaleInterval(sprayScale,
scaleUp,
calcTargetScale,
startScale=GagGlobals.PNT3NEAR0),
sprayNP.posInterval(
0.25,
self.spray.getPos(render) + Point3(0, 50, 0),
startPos=self.spray.getPos(render) + Point3(0, 5, 0))))
track.append(Wait(hold))
track.append(Func(self.handleMiss))
track.append(LerpScaleInterval(sprayScale, 0.75, GagGlobals.PNT3NEAR0))
def hideSpray():
lambda prop: prop.removeNode(), [sprayProp, sprayRot, sprayScale]
track.append(Func(hideSpray))
track.append(Func(self.completeSquirt))
return track
def doBillboardEffect(self):
billboardEffect = BillboardEffect.make(Vec3(0, 0, 1), True, False,
self.billboardOffset, base.cam,
Point3(0, 0, 0))
self.contents.setEffect(billboardEffect)
def reposition(self):
if self.contents is None:
return
origin = Point3()
self.contents.setPos(origin)
if self.chatBalloon is not None:
self.chatBalloon.removeNode()
self.chatBalloon = None
self.contents.node().removeAllChildren()
if (self.cell in base.leftCells) or (self.cell in base.rightCells):
text = self.getChatText().replace('\x01WLDisplay\x01',
'').replace('\x02', '')
textWidth = self.chatTextNode.calcWidth(text)
if (textWidth /
self.CHAT_TEXT_WORD_WRAP) > self.CHAT_TEXT_MAX_ROWS:
self.chatTextNode.setWordwrap(
textWidth / (self.CHAT_TEXT_MAX_ROWS - 0.5))
else:
self.chatTextNode.setWordwrap(self.CHAT_TEXT_WORD_WRAP)
model = self.getChatBalloonModel()
modelWidth = self.getChatBalloonWidth()
modelHeight = self.getChatBalloonHeight()
self.drawChatBalloon(model, modelWidth, modelHeight)
nodePath = self.chatBalloon.textNodePath
left, right, bottom, top = self.chatTextNode.getFrameActual()
left -= self.chatBalloon.BALLOON_X_PADDING
right += self.chatBalloon.BALLOON_X_PADDING
bottom -= self.chatBalloon.BALLOON_Z_PADDING
top += self.chatBalloon.BALLOON_Z_PADDING
elif self.panel is not None:
nodePath = self.textNodePath
left, right, bottom, top = self.textNode.getFrameActual()
left -= self.PANEL_X_PADDING
right += self.PANEL_X_PADDING
bottom -= self.PANEL_Z_PADDING
top += self.PANEL_Z_PADDING
# Compensate for the arrow:
bottom -= self.ARROW_SCALE
else:
return
if self.cell in base.bottomCells:
# Move the origin to the bottom center of the node path:
origin = self.contents.getRelativePoint(
nodePath, ((left + right) / 2.0, 0, bottom))
elif self.cell in base.leftCells:
# Move the origin to the left center of the node path:
origin = self.contents.getRelativePoint(nodePath,
(left, 0,
(bottom + top) / 2.0))
elif self.cell in base.rightCells:
# Move the origin to the right center of the node path:
origin = self.contents.getRelativePoint(nodePath,
(right, 0,
(bottom + top) / 2.0))
self.contents.setPos(self.contents, -origin)
class DistributedBattleTrolley(DistributedObject):
notify = directNotify.newCategory('DistributedBattleTrolley')
STAND_POSITIONS = [
Point3(-4.75, -5, 1.4),
Point3(-4.75, -1.6, 1.4),
Point3(-4.75, 1.6, 1.4),
Point3(-4.75, 5, 1.4),
Point3(-4.75, -5, 1.4),
Point3(-4.75, -1.6, 1.4),
Point3(-4.75, 1.6, 1.4),
Point3(-4.75, 5, 1.4)
]
TROLLEY_NEUTRAL_POS = Point3(15, 14, -1)
TROLLEY_GONE_POS = Point3(50, 14.1588, -0.984615)
TROLLEY_ARRIVING_START_POS = Point3(-20, 14.1588, -0.984615)
CAM_POS = Point3(-35, 0, 8)
CAM_HPR = Vec3(-90, 0, 0)
def __init__(self, cr):
DistributedObject.__init__(self, cr)
self.fsm = ClassicFSM.ClassicFSM('DistributedBattleTrolley', [State.State('off', self.enterOff, self.exitOff),
State.State('wait', self.enterWait, self.exitWait),
State.State('waitCountdown', self.enterWaitCountdown, self.exitWaitCountdown),
State.State('leaving', self.enterLeaving, self.exitLeaving),
State.State('arriving', self.enterArriving, self.exitArriving)], 'off', 'off')
self.fsm.enterInitialState()
self.trolleyStation = None
self.trolleyCar = None
self.trolleyKey = None
self.countdownText = None
self.trolleyAwaySfx = base.audio3d.loadSfx('phase_4/audio/sfx/SZ_trolley_away.ogg')
if self.cr.holidayManager.getHoliday() == HolidayType.CHRISTMAS:
self.trolleyAwaySfx = base.audio3d.loadSfx('winter/audio/sfx/SZ_trolley_away.mp3')
self.trolleyBellSfx = base.audio3d.loadSfx('phase_4/audio/sfx/SZ_trolley_bell.ogg')
self.toZone = 0
self.localAvOnTrolley = False
self.trolleyEnterTrack = None
self.trolleyExitTrack = None
self.hoodAbbr = ""
self.index = 0
self.mySlot = -1
def setIndex(self, index):
self.index = index
hood = self.cr.playGame.hood
hoodAbbr = None
if self.index == 0:
hoodAbbr = hood.abbr
elif self.index == 1:
hoodAbbr = 'TT' #ZoneUtil.ZoneId2HoodAbbr[self.toZone]
self.hoodAbbr = hoodAbbr
findStr = '**/prop_trolley_station_' + hoodAbbr + '_DNARoot'
self.trolleyStation = hood.loader.geom.find(findStr)
self.trolleyStation.flattenStrong()
self.trolleyCar = self.trolleyStation.find('**/trolley_car')
self.trolleyKey = self.trolleyStation.find('**/key')
base.audio3d.attachSoundToObject(self.trolleyAwaySfx, self.trolleyCar)
base.audio3d.attachSoundToObject(self.trolleyBellSfx, self.trolleyCar)
exitFog = Fog('TrolleyExitFog')
exitFog.setColor(0.0, 0.0, 0.0)
exitFog.setLinearOnsetPoint(30.0, 14.0, 0.0)
exitFog.setLinearOpaquePoint(37.0, 14.0, 0.0)
exitFog.setLinearFallback(70.0, 999.0, 1000.0)
self.trolleyExitFog = self.trolleyStation.attachNewNode(exitFog)
self.trolleyExitFogNode = exitFog
enterFog = Fog('TrolleyEnterFog')
enterFog.setColor(0.0, 0.0, 0.0)
enterFog.setLinearOnsetPoint(0.0, 14.0, 0.0)
enterFog.setLinearOpaquePoint(-7.0, 14.0, 0.0)
enterFog.setLinearFallback(70.0, 999.0, 1000.0)
self.trolleyEnterFog = self.trolleyStation.attachNewNode(enterFog)
self.trolleyEnterFogNode = enterFog
self.trolleyCar.setFogOff()
tn = TextNode('trolleycountdowntext')
tn.setFont(CIGlobals.getMickeyFont())
tn.setTextColor(1, 0, 0, 1)
tn.setAlign(TextNode.ACenter)
self.keys = self.trolleyCar.findAllMatches('**/key')
self.numKeys = self.keys.getNumPaths()
self.keyInit = []
self.keyRef = []
for i in range(self.numKeys):
key = self.keys[i]
key.setTwoSided(1)
ref = self.trolleyCar.attachNewNode('key' + `i` + 'ref')
ref.setPosHpr(key, 0, 0, 0, 0, 0, 0)
self.keyRef.append(ref)
self.keyInit.append(key.getTransform())
self.frontWheels = self.trolleyCar.findAllMatches('**/front_wheels')
self.numFrontWheels = self.frontWheels.getNumPaths()
self.frontWheelInit = []
self.frontWheelRef = []
for i in range(self.numFrontWheels):
wheel = self.frontWheels[i]
ref = self.trolleyCar.attachNewNode('frontWheel' + `i` + 'ref')
ref.setPosHpr(wheel, 0, 0, 0, 0, 0, 0)
self.frontWheelRef.append(ref)
self.frontWheelInit.append(wheel.getTransform())
self.backWheels = self.trolleyCar.findAllMatches('**/back_wheels')
self.numBackWheels = self.backWheels.getNumPaths()
self.backWheelInit = []
self.backWheelRef = []
for i in range(self.numBackWheels):
wheel = self.backWheels[i]
ref = self.trolleyCar.attachNewNode('backWheel' + `i` + 'ref')
ref.setPosHpr(wheel, 0, 0, 0, 0, 0, 0)
self.backWheelRef.append(ref)
self.backWheelInit.append(wheel.getTransform())
trolleyAnimationReset = Func(self.resetAnimation)
trolleyEnterStartPos = Point3(-20, 14, -1)
trolleyEnterEndPos = Point3(15, 14, -1)
trolleyEnterPos = Sequence(name='TrolleyEnterPos')
trolleyEnterPos.append(Func(self.trolleyCar.setFog, self.trolleyEnterFogNode))
trolleyEnterPos.append(self.trolleyCar.posInterval(TROLLEY_ENTER_TIME, trolleyEnterEndPos, startPos=trolleyEnterStartPos, blendType='easeOut'))
trolleyEnterPos.append(Func(self.trolleyCar.setFogOff))
trolleyEnterTrack = Sequence(trolleyAnimationReset, trolleyEnterPos, name='trolleyEnter')
keyAngle = round(TROLLEY_ENTER_TIME) * 360
dist = Vec3(trolleyEnterEndPos - trolleyEnterStartPos).length()
wheelAngle = dist / (2.0 * math.pi * 0.95) * 360
trolleyEnterAnimateInterval = LerpFunctionInterval(self.animateTrolley, duration=TROLLEY_ENTER_TIME, blendType='easeOut', extraArgs=[keyAngle, wheelAngle], name='TrolleyAnimate')
trolleyEnterSoundTrack = SoundInterval(self.trolleyAwaySfx, node=self.trolleyCar)
self.trolleyEnterTrack = Parallel(trolleyEnterTrack, trolleyEnterAnimateInterval, trolleyEnterSoundTrack)
trolleyExitStartPos = Point3(15, 14, -1)
trolleyExitEndPos = Point3(50, 14, -1)
trolleyExitPos = Sequence(name='TrolleyExitPos')
trolleyExitPos.append(Func(self.trolleyCar.setFog, self.trolleyExitFogNode))
trolleyExitPos.append(self.trolleyCar.posInterval(TROLLEY_EXIT_TIME, trolleyExitEndPos, startPos=trolleyExitStartPos, blendType='easeIn'))
trolleyExitPos.append(Func(self.trolleyCar.setFogOff))
trolleyExitStartPos = Point3(15, 14, -1)
trolleyExitEndPos = Point3(50, 14, -1)
trolleyExitBellInterval = SoundInterval(self.trolleyBellSfx, node=self.trolleyCar)
trolleyExitAwayInterval = SoundInterval(self.trolleyAwaySfx, node=self.trolleyCar)
keyAngle = round(TROLLEY_EXIT_TIME) * 360
dist = Vec3(trolleyExitEndPos - trolleyExitStartPos).length()
wheelAngle = dist / (2.0 * math.pi * 0.95) * 360
trolleyExitAnimateInterval = LerpFunctionInterval(self.animateTrolley, duration=TROLLEY_EXIT_TIME, blendType='easeIn', extraArgs=[keyAngle, wheelAngle], name='TrolleyAnimate')
self.trolleyExitTrack = Parallel(trolleyExitPos, trolleyExitBellInterval, trolleyExitAwayInterval, trolleyExitAnimateInterval, name=self.uniqueName('trolleyExit'))
self.countdownText = self.trolleyStation.attachNewNode(tn)
self.countdownText.setScale(3.0)
self.countdownText.setPos(14.58, 10.77, 11.17)
try:
self.trolleySphere = self.trolleyStation.find('**/trolley_sphere')
self.trolleySphere.setName('trolley{0}_sphere'.format(hoodAbbr))
except:
pass
def getIndex(self):
return self.index
def putAvatarInTrolley(self, avId, slot):
av = self.cr.doId2do.get(avId)
if av:
print "putAvatarInTrolley:", av.node().getName()
av.stopSmooth()
av.wrtReparentTo(self.trolleyCar)
av.setAnimState('off')
slotPos = self.STAND_POSITIONS[slot]
av.setPos(slotPos)
if slot <= 3:
av.loop('sit')
else:
av.loop('neutral')
av.setHpr(90, 0, 0)
def headOff(self):
if self.index == 1:
zoneId = base.localAvatar.getLastHood()
hoodId = ZoneUtil.getHoodId(zoneId)
else:
zoneId = self.toZone
hoodId = ZoneUtil.getHoodId(self.toZone)
requestStatus = {'zoneId': zoneId,
'hoodId': hoodId,
'where': 'playground',
'avId': base.localAvatar.doId,
'loader': 'safeZoneLoader',
'shardId': None,
'wantLaffMeter': 1,
'how': 'teleportIn',
'prevZoneId': base.localAvatar.zoneId,
'slot': self.mySlot}
self.cr.playGame.getPlace().doneStatus = requestStatus
messenger.send(self.cr.playGame.getPlace().doneEvent)
base.localAvatar.reparentTo(render)
base.localAvatar.setPos(0, 0, 0)
base.localAvatar.setHpr(0, 0, 0)
base.localAvatar.walkControls.setCollisionsActive(1)
self.localAvOnTrolley = False
def setToZone(self, zone):
self.toZone = zone
def getToZone(self):
return self.toZone
def enterOff(self, ts = 0):
pass
def exitOff(self):
pass
def __maybeAcceptCollisions(self):
if self.fsm.getCurrentState().getName() in ['wait', 'waitCountdown'] and not self.localAvOnTrolley:
self.acceptOnce('entertrolley{0}_sphere'.format(self.hoodAbbr), self.__handleTrolleyTrigger)
def __ignoreCollisions(self):
self.ignore('entertrolley{0}_sphere'.format(self.hoodAbbr))
def enterWait(self, ts = 0):
self.trolleyCar.setPos(self.TROLLEY_NEUTRAL_POS)
self.__maybeAcceptCollisions()
def exitWait(self):
self.__ignoreCollisions()
def enterWaitCountdown(self, ts = 0):
self.trolleyCar.setPos(self.TROLLEY_NEUTRAL_POS)
self.__maybeAcceptCollisions()
if self.countdownText:
self.countdownTrack = Sequence()
for i in range(10):
self.countdownTrack.append(Func(self.countdownText.node().setText, str(10 - i)))
self.countdownTrack.append(Wait(1.0))
self.countdownTrack.start()
def exitWaitCountdown(self):
self.__ignoreCollisions()
if hasattr(self, 'countdownTrack'):
self.countdownTrack.finish()
del self.countdownTrack
if self.countdownText:
self.countdownText.node().setText('')
self.disableExitButton()
def enterArriving(self, ts = 0):
if self.localAvOnTrolley == True:
CIGlobals.hideWaitForOthers()
camera.wrtReparentTo(self.trolleyCar)
camera.setPos(0, -18.55, 3.75)
camera.setHpr(0, 0, 0)
Sequence(Wait(2.0), camera.posHprInterval(3, self.CAM_POS, self.CAM_HPR, startPos = (0, -18.55, 3.75), startHpr = (0, 0, 0), blendType='easeInOut')).start()
self.trolleyEnterTrack.start(ts)
def exitArriving(self):
if self.trolleyEnterTrack:
self.trolleyEnterTrack.finish()
def enterLeaving(self, ts = 0):
base.playSfx(self.trolleyBellSfx, node = self.trolleyCar)
if self.localAvOnTrolley == True:
camera.posHprInterval(3, (0, 18.55, 3.75), (-180, 0, 0), blendType='easeInOut').start()
self.trolleyExitTrack.append(Sequence(Wait(4.0), Func(base.transitions.fadeOut), Wait(1.0), Func(self.headOff)))
self.trolleyExitTrack.start(ts)
self.__ignoreCollisions()
def exitLeaving(self):
if self.trolleyExitTrack:
self.trolleyExitTrack.finish()
def setState(self, stateName, timestamp):
ts = globalClockDelta.localElapsedTime(timestamp)
self.fsm.request(stateName, [ts])
def __handleTrolleyTrigger(self, collNp):
# workaround for a bug that i don't understand why it happens
if not hasattr(self, 'cr') or not self.cr:
self.cr = base.cr
self.cr.playGame.getPlace().fsm.request('stop')
base.localAvatar.disableGags()
self.notify.info('Waiting for response from server to enter trolley')
self.sendUpdate('requestBoard')
base.localAvatar.walkControls.setCollisionsActive(0)
def rejectBoard(self):
base.localAvatar.walkControls.setCollisionsActive(1)
self.cr.playGame.getPlace().fsm.request('walk')
self.__maybeAcceptCollisions()
def fillSlot(self, index, avId):
if avId == base.localAvatar.doId:
self.localAvOnTrolley = True
base.localAvatar.stopSmartCamera()
base.camera.wrtReparentTo(self.trolleyCar)
camTrack = Sequence(Parallel(
LerpPosInterval(
base.camera,
duration = 1.5,
pos = self.CAM_POS,
startPos = base.camera.getPos(),
blendType = 'easeOut'
),
LerpQuatInterval(
base.camera,
duration = 1.5,
hpr = self.CAM_HPR,
startHpr = base.camera.getHpr(),
blendType = 'easeOut'
)
), Func(self.enableExitButton))
camTrack.start()
self.mySlot = index
toon = self.cr.doId2do.get(avId)
toon.stopSmooth()
if toon:
toon.wrtReparentTo(self.trolleyCar)
slotPos = self.STAND_POSITIONS[index]
toon.headsUp(slotPos)
track = Sequence(
Func(toon.setAnimState, 'run'),
LerpPosInterval(toon, 0.75, slotPos),
LerpHprInterval(toon, 0.25, Point3(90, 0, 0)))
if index <= 3:
sitStartDuration = toon.getDuration('start-sit')
track.append(Parallel(ActorInterval(toon, 'start-sit'),
Sequence(Wait(sitStartDuration * 0.25),
LerpPosInterval(toon, sitStartDuration * 0.25, Point3(-3.9, -4.5 + index * 3, 3.0)))))
track.append(Func(toon.loop, 'sit'))
else:
track.append(Func(toon.loop, 'neutral'))
track.start()
def enableExitButton(self):
if self.fsm.getCurrentState().getName() != 'leaving':
self.exitButton = CIGlobals.getExitButton(cmd = self.__handleExitButton, pos = (0, 0, -0.8))
def __handleExitButton(self):
if self.fsm.getCurrentState().getName() == 'waitCountdown' and self.localAvOnTrolley == True:
self.disableExitButton()
self.sendUpdate('requestHopOff')
def disableExitButton(self):
if hasattr(self, 'exitButton'):
self.exitButton.destroy()
del self.exitButton
def emptySlot(self, index, avId):
toon = self.cr.doId2do.get(avId)
toon.stopSmooth()
currToonPos = toon.getPos(render)
toon.wrtReparentTo(render)
slotPos = self.STAND_POSITIONS[index]
endPos = (-20, slotPos.getY(), 1.4)
toon.setPos(self.trolleyCar, endPos)
endPosWrtRender = toon.getPos(render)
toon.setPos(currToonPos)
toon.headsUp(self.trolleyCar, endPos)
if index <= 3:
track = Sequence(Parallel(
ActorInterval(toon, 'start-sit', startTime=1, endTime=0.0),
Sequence(Wait(0.5),
LerpPosInterval(toon, 0.25,
Point3(-5, -4.5 + index * 3, 1.4), other=self.trolleyCar))),
Func(toon.setAnimState, 'run'),
LerpPosInterval(toon, 1, Point3(21 - index * 3, -5, 0.02), other=self.trolleyStation),
Func(toon.setAnimState, 'neutral'),
Func(toon.startSmooth),
name=toon.uniqueName('emptyTrolley'), autoPause=1)
else:
track = Sequence(
Func(toon.setAnimState, 'run'),
LerpPosInterval(
toon,
duration = 1.0,
pos = endPosWrtRender,
startPos = currToonPos
),
Func(toon.setAnimState, 'neutral'),
Func(toon.startSmooth)
)
if avId == base.localAvatar.doId:
self.localAvOnTrolley = False
track.append(Func(self.__hoppedOffTrolley))
track.start()
def __hoppedOffTrolley(self):
#self.acceptOnce('entertrolley_sphere', self.__handleTrolleyTrigger)
base.localAvatar.walkControls.setCollisionsActive(1)
self.cr.playGame.getPlace().fsm.request('walk')
def resetAnimation(self):
if self.keys:
for i in range(self.numKeys):
self.keys[i].setTransform(self.keyInit[i])
for i in range(self.numFrontWheels):
self.frontWheels[i].setTransform(self.frontWheelInit[i])
for i in range(self.numBackWheels):
self.backWheels[i].setTransform(self.backWheelInit[i])
def animateTrolley(self, t, keyAngle, wheelAngle):
if self.keys:
for i in range(self.numKeys):
key = self.keys[i]
ref = self.keyRef[i]
key.setH(ref, t * keyAngle)
for i in range(self.numFrontWheels):
frontWheel = self.frontWheels[i]
ref = self.frontWheelRef[i]
frontWheel.setH(ref, t * wheelAngle)
for i in range(self.numBackWheels):
backWheel = self.backWheels[i]
ref = self.backWheelRef[i]
backWheel.setH(ref, t * wheelAngle)
def delete(self):
self.__ignoreCollisions()
self.trolleyStation = None
self.trolleyKey = None
self.soundMoving = None
self.soundBell = None
self.troleyCar = None
self.backWheelInit = None
self.backWheelRef = None
self.backWheels = None
self.frontWheelInit = None
self.frontWheelRef = None
self.frontWheels = None
self.keyInit = None
self.keyRef = None
self.keys = None
self.trolleyEnterTrack = None
self.trolleyExitTrack = None
self.trolleyExitFog = None
self.trolleyExitFogNode = None
self.trolleyEnterFogNode = None
self.trolleyEnterFog = None
if self.countdownText:
self.countdownText.removeNode()
self.countdownText = None
DistributedObject.delete(self)
# left paddle
base.ecs_world.create_entity(
panda3d.Model(),
panda3d.Geometry(file='resources/paddle.bam'),
panda3d.Scene(node=base.aspect2d),
panda3d.Position(value=Vec3(-1.1, 0, 0)),
movement.Movement(direction=Vec3(0, 0, 0)),
paddles.Paddle(player=paddles.Players.LEFT),
)
# right paddle
base.ecs_world.create_entity(
panda3d.Model(),
panda3d.Geometry(file='resources/paddle.bam'),
panda3d.Scene(node=base.aspect2d),
panda3d.Position(value=Point3(1.1, 0, 0)),
movement.Movement(direction=Vec3(0, 0, 0)),
paddles.Paddle(player=paddles.Players.RIGHT),
)
# ball
base.ecs_world.create_entity(
panda3d.Position(value=Point3(0, 0, 0)),
panda3d.Model(),
panda3d.Geometry(file='resources/ball.bam'),
panda3d.Scene(node=base.aspect2d),
ball.Ball(),
ball.Resting(),
)
# another ball - uncomment to enjoy the HARD mode
def setIndex(self, index):
self.index = index
hood = self.cr.playGame.hood
hoodAbbr = None
if self.index == 0:
hoodAbbr = hood.abbr
elif self.index == 1:
hoodAbbr = 'TT' #ZoneUtil.ZoneId2HoodAbbr[self.toZone]
self.hoodAbbr = hoodAbbr
findStr = '**/prop_trolley_station_' + hoodAbbr + '_DNARoot'
self.trolleyStation = hood.loader.geom.find(findStr)
self.trolleyStation.flattenStrong()
self.trolleyCar = self.trolleyStation.find('**/trolley_car')
self.trolleyKey = self.trolleyStation.find('**/key')
base.audio3d.attachSoundToObject(self.trolleyAwaySfx, self.trolleyCar)
base.audio3d.attachSoundToObject(self.trolleyBellSfx, self.trolleyCar)
exitFog = Fog('TrolleyExitFog')
exitFog.setColor(0.0, 0.0, 0.0)
exitFog.setLinearOnsetPoint(30.0, 14.0, 0.0)
exitFog.setLinearOpaquePoint(37.0, 14.0, 0.0)
exitFog.setLinearFallback(70.0, 999.0, 1000.0)
self.trolleyExitFog = self.trolleyStation.attachNewNode(exitFog)
self.trolleyExitFogNode = exitFog
enterFog = Fog('TrolleyEnterFog')
enterFog.setColor(0.0, 0.0, 0.0)
enterFog.setLinearOnsetPoint(0.0, 14.0, 0.0)
enterFog.setLinearOpaquePoint(-7.0, 14.0, 0.0)
enterFog.setLinearFallback(70.0, 999.0, 1000.0)
self.trolleyEnterFog = self.trolleyStation.attachNewNode(enterFog)
self.trolleyEnterFogNode = enterFog
self.trolleyCar.setFogOff()
tn = TextNode('trolleycountdowntext')
tn.setFont(CIGlobals.getMickeyFont())
tn.setTextColor(1, 0, 0, 1)
tn.setAlign(TextNode.ACenter)
self.keys = self.trolleyCar.findAllMatches('**/key')
self.numKeys = self.keys.getNumPaths()
self.keyInit = []
self.keyRef = []
for i in range(self.numKeys):
key = self.keys[i]
key.setTwoSided(1)
ref = self.trolleyCar.attachNewNode('key' + `i` + 'ref')
ref.setPosHpr(key, 0, 0, 0, 0, 0, 0)
self.keyRef.append(ref)
self.keyInit.append(key.getTransform())
self.frontWheels = self.trolleyCar.findAllMatches('**/front_wheels')
self.numFrontWheels = self.frontWheels.getNumPaths()
self.frontWheelInit = []
self.frontWheelRef = []
for i in range(self.numFrontWheels):
wheel = self.frontWheels[i]
ref = self.trolleyCar.attachNewNode('frontWheel' + `i` + 'ref')
ref.setPosHpr(wheel, 0, 0, 0, 0, 0, 0)
self.frontWheelRef.append(ref)
self.frontWheelInit.append(wheel.getTransform())
self.backWheels = self.trolleyCar.findAllMatches('**/back_wheels')
self.numBackWheels = self.backWheels.getNumPaths()
self.backWheelInit = []
self.backWheelRef = []
for i in range(self.numBackWheels):
wheel = self.backWheels[i]
ref = self.trolleyCar.attachNewNode('backWheel' + `i` + 'ref')
ref.setPosHpr(wheel, 0, 0, 0, 0, 0, 0)
self.backWheelRef.append(ref)
self.backWheelInit.append(wheel.getTransform())
trolleyAnimationReset = Func(self.resetAnimation)
trolleyEnterStartPos = Point3(-20, 14, -1)
trolleyEnterEndPos = Point3(15, 14, -1)
trolleyEnterPos = Sequence(name='TrolleyEnterPos')
trolleyEnterPos.append(Func(self.trolleyCar.setFog, self.trolleyEnterFogNode))
trolleyEnterPos.append(self.trolleyCar.posInterval(TROLLEY_ENTER_TIME, trolleyEnterEndPos, startPos=trolleyEnterStartPos, blendType='easeOut'))
trolleyEnterPos.append(Func(self.trolleyCar.setFogOff))
trolleyEnterTrack = Sequence(trolleyAnimationReset, trolleyEnterPos, name='trolleyEnter')
keyAngle = round(TROLLEY_ENTER_TIME) * 360
dist = Vec3(trolleyEnterEndPos - trolleyEnterStartPos).length()
wheelAngle = dist / (2.0 * math.pi * 0.95) * 360
trolleyEnterAnimateInterval = LerpFunctionInterval(self.animateTrolley, duration=TROLLEY_ENTER_TIME, blendType='easeOut', extraArgs=[keyAngle, wheelAngle], name='TrolleyAnimate')
trolleyEnterSoundTrack = SoundInterval(self.trolleyAwaySfx, node=self.trolleyCar)
self.trolleyEnterTrack = Parallel(trolleyEnterTrack, trolleyEnterAnimateInterval, trolleyEnterSoundTrack)
trolleyExitStartPos = Point3(15, 14, -1)
trolleyExitEndPos = Point3(50, 14, -1)
trolleyExitPos = Sequence(name='TrolleyExitPos')
trolleyExitPos.append(Func(self.trolleyCar.setFog, self.trolleyExitFogNode))
trolleyExitPos.append(self.trolleyCar.posInterval(TROLLEY_EXIT_TIME, trolleyExitEndPos, startPos=trolleyExitStartPos, blendType='easeIn'))
trolleyExitPos.append(Func(self.trolleyCar.setFogOff))
trolleyExitStartPos = Point3(15, 14, -1)
trolleyExitEndPos = Point3(50, 14, -1)
trolleyExitBellInterval = SoundInterval(self.trolleyBellSfx, node=self.trolleyCar)
trolleyExitAwayInterval = SoundInterval(self.trolleyAwaySfx, node=self.trolleyCar)
keyAngle = round(TROLLEY_EXIT_TIME) * 360
dist = Vec3(trolleyExitEndPos - trolleyExitStartPos).length()
wheelAngle = dist / (2.0 * math.pi * 0.95) * 360
trolleyExitAnimateInterval = LerpFunctionInterval(self.animateTrolley, duration=TROLLEY_EXIT_TIME, blendType='easeIn', extraArgs=[keyAngle, wheelAngle], name='TrolleyAnimate')
self.trolleyExitTrack = Parallel(trolleyExitPos, trolleyExitBellInterval, trolleyExitAwayInterval, trolleyExitAnimateInterval, name=self.uniqueName('trolleyExit'))
self.countdownText = self.trolleyStation.attachNewNode(tn)
self.countdownText.setScale(3.0)
self.countdownText.setPos(14.58, 10.77, 11.17)
try:
self.trolleySphere = self.trolleyStation.find('**/trolley_sphere')
self.trolleySphere.setName('trolley{0}_sphere'.format(hoodAbbr))
except:
pass
def __init__(self, cr, doJellyBeans=True, doTricks=False, texture=None):
DistributedPartyTrampolineActivity.notify.debug('__init__')
DistributedPartyActivity.__init__(
self,
cr,
PartyGlobals.ActivityIds.PartyTrampoline,
PartyGlobals.ActivityTypes.GuestInitiated,
wantLever=False,
wantRewardGui=True)
self.doJellyBeans = doJellyBeans
self.doTricks = doTricks
self.texture = texture
self.toon = None
self.trampHeight = 3.6
self.trampK = 400.0
self.normalTrampB = 2.5
self.leavingTrampB = 8.0
self.trampB = self.normalTrampB
self.g = -32.0
self.jumpBoost = 330.0
self.beginningBoost = 500.0
self.beginningBoostThreshold = self.trampHeight + 1.5
self.earlyJumpThreshold = 75.0
self.boingThreshold = 300.0
self.turnFactor = 120.0
self.stepDT = 0.001
self.targetCameraPos = Point3(0.0, 40.0, 10.0)
self.cameraSpeed = 2.0
self.hopOffPos = Point3(16.0, 0.0, 0.0)
self.indicatorFactor = 0.0095
self.dropShadowCutoff = 15.0
self.minHeightForText = 15.0
self.heightTextOffset = -0.065
self.beanOffset = 0.5
self.guiBeanOffset = -0.02
self.jumpTextShown = False
self.toonJumped = False
self.turnLeft = False
self.turnRight = False
self.leavingTrampoline = False
self.toonVelocity = 0.0
self.topHeight = 0.0
self.lastPeak = 0.0
self.beginRoundInterval = None
self.hopOnAnim = None
self.hopOffAnim = None
self.flashTextInterval = None
self.numJellyBeans = PartyGlobals.TrampolineNumJellyBeans
self.jellyBeanBonus = PartyGlobals.TrampolineJellyBeanBonus
self.jellyBeanStartHeight = 20.0
self.jellyBeanStopHeight = 90.0
self.jellyBeanColors = [
VBase4(1.0, 0.5, 0.5, 1.0),
VBase4(0.5, 1.0, 0.5, 1.0),
VBase4(0.5, 1.0, 1.0, 1.0),
VBase4(1.0, 1.0, 0.4, 1.0),
VBase4(0.4, 0.4, 1.0, 1.0),
VBase4(1.0, 0.5, 1.0, 1.0)
]
delta = (self.jellyBeanStopHeight -
self.jellyBeanStartHeight) / (self.numJellyBeans - 1)
self.jellyBeanPositions = [
self.jellyBeanStartHeight + n * delta
for n in range(self.numJellyBeans)
]
self.doSimulateStep = False
return
def firingWater(self, startX, startY, startZ, endX, endY, endZ):
origin = Point3(startX, startY, startZ)
target = Point3(endX, endY, endZ)
self.fireWater(origin, target)
class FactorySneakPlayer(DirectObject):
notify = directNotify.newCategory("FactorySneakPlayer")
SPAWN_POINT = Point3(21, 14.5, 3.73)
def __init__(self, mg):
DirectObject.__init__(self)
self.actualAvatar = base.localAvatar
self.beansCollected = 0
self.moneyGui = None
self.mg = mg
self.toonFPS = FactorySneakGameToonFPS(mg)
self.guardsPursuing = 0
def guardPursue(self):
self.mg.gameWorld.showAlert("A guard has noticed you!")
self.guardsPursuing += 1
if self.guardsPursuing == 1:
# Play the "guards pursuing" music.
self.mg.gameWorld.playMusic(1)
def guardStopPursue(self):
self.guardsPursuing -= 1
if self.guardsPursuing == 0:
# Play the "sneak around" music.
self.mg.gameWorld.playMusic(0)
self.mg.gameWorld.showAlert("You've evaded the guards!")
def startFPS(self, enableLookAround=True):
self.toonFPS.load()
self.toonFPS.start()
if (enableLookAround == False):
self.disableLookAround()
self.toonFPS.gui.hp_meter.hide()
self.accept("guardPursue", self.guardPursue)
self.accept("guardStopPursue", self.guardStopPursue)
def enableLookAround(self):
self.toonFPS.firstPerson.disableMouse()
def disableLookAround(self):
self.toonFPS.firstPerson.enableMouse()
def enableControls(self):
self.toonFPS.reallyStart()
def disableControls(self):
self.toonFPS.end()
def cleanupFPS(self):
self.ignore("guardPursue")
self.ignore("guardStopPursue")
self.toonFPS.reallyEnd()
self.toonFPS.cleanup()
def spawn(self):
self.actualAvatar.setPos(self.SPAWN_POINT)
def setupInterface(self):
self.moneyGui = MoneyGui()
self.moneyGui.createGui()
self.moneyGui.frame.setPos(self.moneyGui.frame.getPos() +
(-0.25, 0, 0.175))
self.updateBeansCollected()
def cleanup(self):
self.actualAvatar = None
self.beansCollected = None
self.cleanupFPS()
if self.moneyGui:
self.moneyGui.deleteGui()
self.moneyGui = None
self.mg = None
def setBeansCollected(self, amt):
self.beansCollected = amt
self.updateBeansCollected()
def getBeansCollected(self):
return self.beansCollected
def updateBeansCollected(self):
self.moneyGui.update(self.beansCollected)
def getSlideToPos(toon=toon):
return render.getRelativePoint(toon, Point3(0, -10, 0))
def getLeftClosePoint(type):
width = ElevatorData[type]['width']
return Point3(width, 0, 0)
def getSprayTrack(self,
color,
origin,
target,
dScaleUp,
dHold,
dScaleDown,
horizScale=1.0,
vertScale=1.0,
parent=render):
track = Sequence()
SPRAY_LEN = 1.5
sprayProp = MovieUtil.globalPropPool.getProp('spray')
sprayScale = hidden.attachNewNode('spray-parent')
sprayRot = hidden.attachNewNode('spray-rotate')
spray = sprayRot
spray.setColor(color)
if color[3] < 1.0:
spray.setTransparency(1)
def showSpray(sprayScale, sprayRot, sprayProp, origin, target, parent):
if callable(origin):
origin = origin()
if callable(target):
target = target()
sprayRot.reparentTo(parent)
sprayRot.clearMat()
sprayScale.reparentTo(sprayRot)
sprayScale.clearMat()
sprayProp.reparentTo(sprayScale)
sprayProp.clearMat()
sprayRot.setPos(origin)
sprayRot.lookAt(Point3(target))
track.append(
Func(showSpray, sprayScale, sprayRot, sprayProp, origin, target,
parent))
def calcTargetScale(target=target,
origin=origin,
horizScale=horizScale,
vertScale=vertScale):
if callable(target):
target = target()
if callable(origin):
origin = origin()
distance = Vec3(target - origin).length()
yScale = distance / SPRAY_LEN
targetScale = Point3(yScale * horizScale, yScale,
yScale * vertScale)
return targetScale
track.append(
LerpScaleInterval(sprayScale,
dScaleUp,
calcTargetScale,
startScale=Point3(0.01, 0.01, 0.01)))
track.append(Func(self.checkHitObject))
track.append(Wait(dHold))
def prepareToShrinkSpray(spray, sprayProp, origin, target):
if callable(target):
target = target()
if callable(origin):
origin = origin()
sprayProp.setPos(Point3(0.0, -SPRAY_LEN, 0.0))
spray.setPos(target)
track.append(
Func(prepareToShrinkSpray, spray, sprayProp, origin, target))
track.append(
LerpScaleInterval(sprayScale, dScaleDown, Point3(0.01, 0.01,
0.01)))
def hideSpray(spray, sprayScale, sprayRot, sprayProp, propPool):
sprayProp.detachNode()
MovieUtil.removeProp(sprayProp)
sprayRot.removeNode()
sprayScale.removeNode()
track.append(
Func(hideSpray, spray, sprayScale, sprayRot, sprayProp,
MovieUtil.globalPropPool))
return track
def getLeftOpenPoint(type):
return Point3(0, 0, 0)
def getRowPos(self, place):
return Point3(-0.72, -0.01, 0.2 - place * 0.1)
def generateWater(self, style):
print "Generate Water:", self.waterXMin, self.waterXMax, self.waterYMin, self.waterYMax
'''Generates water
style 0: blue card
style 1: reflective card
style 2: reflective card with shaders
'''
self.waterHeight = 22.0
if self.water:
self.water.removeNode()
if style is 0:
cm = CardMaker("water")
#cm.setFrame(-1, 1, -1, 1)
cm.setFrame(self.waterXMin, self.waterXMax, self.waterYMin,
self.waterYMax)
cm.setColor(0, 0, 1, 0.9)
self.water = render.attachNewNode(cm.generate())
if self.waterYMax > self.waterXMax:
size = self.waterYMax
else:
size = self.waterXMax
self.water.lookAt(0, 0, -1)
self.water.setZ(self.waterHeight)
messenger.send('makePickable', [self.water])
elif style is 1:
# From Prosoft's super awesome terrain demo
cm = CardMaker("water")
#cm.setFrame(-1, 1, -1, 1)
cm.setFrame(self.waterXMin, self.waterXMax, self.waterYMin,
self.waterYMax)
self.water = render.attachNewNode(cm.generate())
if self.waterYMax > self.waterXMax:
size = self.waterYMax
else:
size = self.waterXMax
#self.water.setScale(size)
self.water.lookAt(0, 0, -1)
self.water.setZ(self.waterHeight)
self.water.setShaderOff(1)
self.water.setLightOff(1)
self.water.setAlphaScale(0.5)
self.water.setTransparency(TransparencyAttrib.MAlpha)
wbuffer = base.win.makeTextureBuffer("water", 512, 512)
wbuffer.setClearColorActive(True)
wbuffer.setClearColor(base.win.getClearColor())
self.wcamera = base.makeCamera(wbuffer)
self.wcamera.reparentTo(render)
self.wcamera.node().setLens(base.camLens)
self.wcamera.node().setCameraMask(BitMask32.bit(1))
self.water.hide(BitMask32.bit(1))
wtexture = wbuffer.getTexture()
wtexture.setWrapU(Texture.WMClamp)
wtexture.setWrapV(Texture.WMClamp)
wtexture.setMinfilter(Texture.FTLinearMipmapLinear)
self.wplane = Plane(Vec3(0, 0, 1), Point3(0, 0, self.water.getZ()))
wplanenp = render.attachNewNode(PlaneNode("water", self.wplane))
tmpnp = NodePath("StateInitializer")
tmpnp.setClipPlane(wplanenp)
tmpnp.setAttrib(CullFaceAttrib.makeReverse())
self.wcamera.node().setInitialState(tmpnp.getState())
self.water.projectTexture(TextureStage("reflection"), wtexture,
self.wcamera)
messenger.send('makePickable', [self.water])
elif style is 2:
# From Clcheung just as super awesome demomaster
self.water_level = Vec4(0.0, 0.0, self.waterHeight, 1.0)
self.water = water.WaterNode(self.waterXMin, self.waterYMin,
self.waterXMax, self.waterYMax,
self.water_level.getZ())
self.water.setStandardControl()
self.water.changeParams(None)
wl = self.water_level
wl.setZ(wl.getZ() - 0.05)
#root.setShaderInput('waterlevel', self.water_level)
render.setShaderInput('time', 0)
messenger.send('makePickable', [self.water.waterNP])
class CameraShyLevelLoader:
notify = directNotify.newCategory('CameraShyLevelLoader')
levelData = {
'TT_maze': {
'name':
CIGlobals.ToontownCentral,
'models': {
'phase_4/models/minigames/maze_1player.bam': {
'name': 'maze'
},
'phase_4/models/minigames/maze_1player_collisions.egg': {
'name': 'maze_collisions'
},
},
'sky':
'TT',
'spawnPoints':
[[Point3(0, 0, 0), Vec3(0, 0, 0)],
[Point3(-23.89, 18.58, 0.00),
Vec3(90.00, 0.00, 0.00)],
[Point3(-23.89, 6.30, 0.00),
Vec3(0.00, 0.00, 0.00)],
[Point3(23.78, 6.30, 0.00),
Vec3(0.00, 0.00, 0.00)],
[Point3(8.12, -17.79, 0.00),
Vec3(270.00, 0.00, 0.00)]]
},
'DG_playground': {
'name':
CIGlobals.DaisyGardens,
'dna': [
'phase_8/dna/storage_DG.pdna',
'phase_8/dna/storage_DG_sz.pdna',
'phase_8/dna/daisys_garden_sz.pdna'
],
'sky':
'TT',
'spawnPoints':
hoodMgr.dropPoints[CIGlobals.DaisyGardens]
}
}
skyData = {
'TT': {
'model': 'phase_3.5/models/props/TT_sky.bam',
'moving': 1
}
}
def __init__(self):
self.level = None
self.dnaStore = DNAStorage()
self.levelGeom = None
self.skyUtil = None
self.skyModel = None
# To keep track of all the models.
self.models = []
def setLevel(self, level):
self.level = level
def getLevel(self):
return self.level
def load(self):
if not self.level:
self.notify.warning('Attempted to load a null level!')
return
def loadSky(sky):
data = self.skyData[sky]
if data:
model = data['model']
moving = 0
if data.get('moving'):
moving = data['moving']
self.skyModel = loader.loadModel(model)
self.skyModel.reparentTo(camera)
self.skyUtil = SkyUtil()
self.skyUtil.startSky(self.skyModel)
if moving:
compass = CompassEffect.make(
NodePath(), CompassEffect.PRot | CompassEffect.PZ)
self.skyModel.node().setEffect(compass)
self.unload()
data = self.levelData[self.level]
skyType = data['sky']
# Are we loading a DNA level?
if data.get('dna'):
dnaFiles = data['dna']
loadDNAFile(self.dnaStore, 'phase_4/dna/storage.pdna')
for index in range(len(dnaFiles)):
if 'storage' not in dnaFiles[index]:
# It's an environment file, let's load that up and reparent it to render.
node = loader.loadDNAFile(self.dnaStore, dnaFiles[index])
if node.getNumParents() == 1:
self.levelGeom = NodePath(node.getParent(0))
self.levelGeom.reparentTo(hidden)
else:
self.levelGeom = hidden.attachNewNode(node)
self.levelGeom.flattenMedium()
gsg = base.win.getGsg()
if gsg:
self.levelGeom.prepareScene(gsg)
self.levelGeom.reparentTo(render)
else:
# It's just a storage file, let's just load that up.
loadDNAFile(self.dnaStore, dnaFiles[index])
elif data.get('models'):
models = data['models']
for model, modifiers in models.items():
mdl = loader.loadModel(model)
if modifiers.get('name'):
mdl.setName(modifiers['name'])
if modifiers.get('hpr'):
mdl.setHpr(modifiers['hpr'])
if modifiers.get('pos'):
mdl.setPos(modifiers['pos'])
if modifiers.get('scale'):
mdl.setScale(modifiers['scale'])
if modifiers.get('parent'):
mdl.reparentTo(modifiers['parent'])
else:
mdl.reparentTo(render)
self.models.append(mdl)
else:
self.notify.warning(
'Attempted to load a level with no data on how to generate it. Level is empty!'
)
return
loadSky(skyType)
self.levelLoaded()
def unload(self):
if self.models:
if len(self.models) > 0:
for model in self.models:
model.removeNode()
self.models = []
if self.levelGeom:
self.levelGeom.removeNode()
self.levelGeom = None
if self.skyUtil:
self.skyUtil.stopSky()
self.skyUtil = None
if self.skyModel:
self.skyModel.removeNode()
self.skyModel = None
if self.dnaStore:
self.dnaStore.reset_nodes()
self.dnaStore.reset_hood_nodes()
self.dnaStore.reset_place_nodes()
self.dnaStore.reset_hood()
self.dnaStore.reset_fonts()
self.dnaStore.reset_DNA_vis_groups()
self.dnaStore.reset_textures()
self.dnaStore.reset_block_numbers()
self.dnaStore.reset_block_zones()
self.dnaStore.reset_suit_points()
# This is set outside of the class, so no need to check if it exists.
hoodMgr = None
def cleanup(self):
try:
self.CameraShyLevelLoader_deleted
except:
self.CameraShyLevelLoader_deleted = 1
if self.dnaStore:
self.unload()
self.models = None
self.levelGeom = None
self.skyUtil = None
self.skyModel = None
self.dnaStore = None
self.levelData = None
def levelLoaded(self):
if self.level == 'TT_maze':
for model in self.models:
if model.getName() == 'maze':
model.find('**/maze_walls').setSz(1.5)
elif model.getName() == 'maze_collisions':
model.hide()
model.setTransparency(1)
model.setColorScale(1, 1, 1, 0)
for node in model.findAllMatches('**'):
node.setSz(1.5)
def getSpawnPoints(self):
if self.level:
points = self.levelData[self.level].get('spawnPoints')
# Do we need to disect the pos and hpr coordinates?
if points in hoodMgr.dropPoints.values():
twoPointArray = []
for posHpr in points:
twoPointArray.append(
Point3(posHpr[0], posHpr[1], posHpr[2]),
Vec3(posHpr[3], posHpr[4], posHpr[5]))
points = twoPointArray
return points
else:
self.notify.warning(
'Attempted to get spawn points of a null level!')
return None
def __init__(self):
BasePhysicsObjectShared.__init__(self)
self.waterCheckTask = None
self.needsWaterCheck = False
self.__lastPos = Point3(0)
def update(self):
# Apply gravity
gravity = Point3.zero() - self.playernp.getPos()
gravity.normalize()
gravity *= G * M * m / (R ** 2)
self.playernp.node().applyCentralForce(gravity)
