def generateToonMoveTrack(self, toon): node = NodePath("tempNode") displacement = Vec3(toon.getPos(render) - self.getPos(render)) displacement.setZ(0) displacement.normalize() movieDistance = self.movieNode.getDistance(self.rotateNode) displacement *= movieDistance node.reparentTo(render) node.setPos(displacement + self.getPos(render)) node.lookAt(self) heading = PythonUtil.fitDestAngle2Src(toon.getH(render), node.getH(render)) hpr = toon.getHpr(render) hpr.setX(heading) finalX = node.getX(render) finalY = node.getY(render) finalZ = node.getZ(render) node.removeNode() toonTrack = Sequence( Parallel( ActorInterval(toon, "walk", loop=True, duration=1), Parallel( LerpPosInterval(toon, 1.0, Point3(finalX, finalY, toon.getZ(render)), fluid=True, bakeInStart=False) ), LerpHprInterval(toon, 1.0, hpr=hpr), ), Func(toon.loop, "neutral"), ) return toonTrack
def generateToonMoveTrack(self, toon): node = NodePath('tempNode') displacement = Vec3(toon.getPos(render) - self.getPos(render)) displacement.setZ(0) displacement.normalize() movieDistance = self.movieNode.getDistance(self.rotateNode) displacement *= movieDistance node.reparentTo(render) node.setPos(displacement + self.getPos(render)) node.lookAt(self) heading = PythonUtil.fitDestAngle2Src(toon.getH(render), node.getH(render)) hpr = toon.getHpr(render) hpr.setX(heading) finalX = node.getX(render) finalY = node.getY(render) finalZ = node.getZ(render) node.removeNode() toonTrack = Sequence( Parallel( ActorInterval(toon, 'walk', loop=True, duration=1), Parallel( LerpPosInterval(toon, 1.0, Point3(finalX, finalY, toon.getZ(render)), fluid=True, bakeInStart=False)), LerpHprInterval(toon, 1.0, hpr=hpr)), Func(toon.loop, 'neutral')) return toonTrack
class PartyCog(FSM): notify = directNotify.newCategory('PartyCog') HpTextGenerator = TextNode('HpTextGenerator') hpText = None height = 7 def __init__(self, parentNode, id, bounceSpeed=3, bounceHeight=1, rotateSpeed=1, heightShift=1, xMoveSpeed=0, xMoveDistance=0, bounceOffset=0): self.id = id FSM.__init__(self, 'PartyCogFSM-%d' % self.id) self.showFacingStatus = False self.xMoveSpeed = xMoveSpeed self.xMoveDistance = xMoveDistance self.heightShift = heightShift self.bounceSpeed = bounceSpeed self.bounceHeight = bounceHeight self.rotateSpeed = rotateSpeed self.parentNode = parentNode self.bounceOffset = bounceOffset self.hitInterval = None self.kaboomTrack = None self.resetRollIval = None self.netTimeSentToStartByHit = 0 self.load() self.request('Down') return def load(self): self.root = NodePath('PartyCog-%d' % self.id) self.root.reparentTo(self.parentNode) path = 'phase_13/models/parties/cogPinata_' self.actor = Actor( path + 'actor', { 'idle': path + 'idle_anim', 'down': path + 'down_anim', 'up': path + 'up_anim', 'bodyHitBack': path + 'bodyHitBack_anim', 'bodyHitFront': path + 'bodyHitFront_anim', 'headHitBack': path + 'headHitBack_anim', 'headHitFront': path + 'headHitFront_anim' }) self.actor.reparentTo(self.root) self.temp_transform = Mat4() self.head_locator = self.actor.attachNewNode('temphead') self.bodyColl = CollisionTube(0, 0, 1, 0, 0, 5.75, 0.75) self.bodyColl.setTangible(1) self.bodyCollNode = CollisionNode('PartyCog-%d-Body-Collision' % self.id) self.bodyCollNode.setCollideMask(ToontownGlobals.PieBitmask) self.bodyCollNode.addSolid(self.bodyColl) self.bodyCollNodePath = self.root.attachNewNode(self.bodyCollNode) self.headColl = CollisionTube(0, 0, 3, 0, 0, 3.0, 1.5) self.headColl.setTangible(1) self.headCollNode = CollisionNode('PartyCog-%d-Head-Collision' % self.id) self.headCollNode.setCollideMask(ToontownGlobals.PieBitmask) self.headCollNode.addSolid(self.headColl) self.headCollNodePath = self.root.attachNewNode(self.headCollNode) self.arm1Coll = CollisionSphere(1.65, 0, 3.95, 1.0) self.arm1Coll.setTangible(1) self.arm1CollNode = CollisionNode('PartyCog-%d-Arm1-Collision' % self.id) self.arm1CollNode.setCollideMask(ToontownGlobals.PieBitmask) self.arm1CollNode.addSolid(self.arm1Coll) self.arm1CollNodePath = self.root.attachNewNode(self.arm1CollNode) self.arm2Coll = CollisionSphere(-1.65, 0, 3.45, 1.0) self.arm2Coll.setTangible(1) self.arm2CollNode = CollisionNode('PartyCog-%d-Arm2-Collision' % self.id) self.arm2CollNode.setCollideMask(ToontownGlobals.PieBitmask) self.arm2CollNode.addSolid(self.arm2Coll) self.arm2CollNodePath = self.root.attachNewNode(self.arm2CollNode) splatName = 'splat-creampie' self.splat = globalPropPool.getProp(splatName) self.splat.setBillboardPointEye() self.splatType = globalPropPool.getPropType(splatName) self.pieHitSound = globalBattleSoundCache.getSound( 'AA_wholepie_only.ogg') self.upSound = globalBattleSoundCache.getSound('AV_jump_to_side.ogg') self.hole = loader.loadModel('phase_13/models/parties/cogPinataHole') self.hole.setTransparency(True) self.hole.setP(-90.0) self.hole.setScale(3) self.hole.setBin('ground', 3) self.hole.reparentTo(self.parentNode) def unload(self): self.request('Off') self.clearHitInterval() if self.hole is not None: self.hole.removeNode() self.hole = None if self.actor is not None: self.actor.cleanup() self.actor.removeNode() self.actor = None if self.root is not None: self.root.removeNode() self.root = None if self.kaboomTrack is not None and self.kaboomTrack.isPlaying(): self.kaboomTrack.finish() self.kaboomTrack = None if self.resetRollIval is not None and self.resetRollIval.isPlaying(): self.resetRollIval.finish() self.resetRollIval = None if self.hitInterval is not None and self.hitInterval.isPlaying(): self.hitInterval.finish() self.hitInterval = None del self.upSound del self.pieHitSound return def enterStatic(self): pass def exitStatic(self): pass def enterActive(self, startTime): self.root.setR(0.0) updateTask = Task.Task(self.updateTask) updateTask.startTime = startTime taskMgr.add(updateTask, 'PartyCog.update-%d' % self.id) def exitActive(self): taskMgr.remove('PartyCog.update-%d' % self.id) taskMgr.remove('PartyCog.bounceTask-%d' % self.id) self.clearHitInterval() self.resetRollIval = self.root.hprInterval(0.5, Point3( self.root.getH(), 0.0, 0.0), blendType='easeInOut') self.resetRollIval.start() self.actor.stop() def enterDown(self): if self.oldState == 'Off': downAnimControl = self.actor.getAnimControl('down') self.actor.pose('down', downAnimControl.getNumFrames() - 1) return self.clearHitInterval() startScale = self.hole.getScale() endScale = Point3(5, 5, 5) self.hitInterval = Sequence( LerpFunc(self.setAlongSpline, duration=1.0, fromData=self.currentT, toData=0.0), LerpScaleInterval(self.hole, duration=0.175, scale=endScale, startScale=startScale, blendType='easeIn'), Parallel( SoundInterval(self.upSound, volume=0.6, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), ActorInterval(self.actor, 'down', loop=0)), LerpScaleInterval(self.hole, duration=0.175, scale=Point3(3, 3, 3), startScale=endScale, blendType='easeOut')) self.hitInterval.start() def exitDown(self): self.root.setR(0.0) self.root.setH(0.0) self.targetDistance = 0.0 self.targetFacing = 0.0 self.currentT = 0.0 self.setAlongSpline(0.0) self.clearHitInterval() startScale = self.hole.getScale() endScale = Point3(5, 5, 5) self.hitInterval = Sequence( LerpScaleInterval(self.hole, duration=0.175, scale=endScale, startScale=startScale, blendType='easeIn'), Parallel( SoundInterval(self.upSound, volume=0.6, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), ActorInterval(self.actor, 'up', loop=0)), Func(self.actor.loop, 'idle'), LerpScaleInterval(self.hole, duration=0.175, scale=Point3(3, 3, 3), startScale=endScale, blendType='easeOut')) self.hitInterval.start() def filterDown(self, request, args): if request == 'Down': return None else: return self.defaultFilter(request, args) return None def setEndPoints(self, start, end, amplitude=1.7): self.sinAmplitude = amplitude self.sinPeriod = (end.getX() - start.getX()) / 2 self.sinDisplacement = start.getY() self.startPoint = start self.endPoint = end self.currentT = 0.0 self.targetDistance = 0.0 self.currentFacing = 0.0 self.targetFacing = 0.0 self.setAlongSpline(self.currentT) self.hole.setPos(self.root.getPos()) self.hole.setZ(0.02) def rockBackAndForth(self, task): t = task.startTime + task.time angle = math.sin(t) * 20.0 self.root.setR(angle) return task.cont def updateDistance(self, distance): self.targetDistance = clamp(distance, -1.0, 1.0) def updateTask(self, task): self.rockBackAndForth(task) if self.targetDistance > self.currentT: self.currentT += min(0.01, self.targetDistance - self.currentT) self.setAlongSpline(self.currentT) elif self.targetDistance < self.currentT: self.currentT += max(-0.01, self.targetDistance - self.currentT) self.setAlongSpline(self.currentT) if self.currentT < 0.0: self.targetFacing = -90.0 elif self.currentT > 0.0: self.targetFacing = 90.0 else: self.targetFacing = 0.0 if self.targetFacing > self.currentFacing: self.currentFacing += min(10, self.targetFacing - self.currentFacing) elif self.targetFacing < self.currentFacing: self.currentFacing += max(-10, self.targetFacing - self.currentFacing) self.root.setH(self.currentFacing) return task.cont def setAlongSpline(self, t): t = t + 1.0 dist = (self.endPoint.getX() - self.startPoint.getX()) / 2.0 x = self.startPoint.getX() + t * dist y = self.startPoint.getY() - math.sin( t * 2 * math.pi) * self.sinAmplitude self.root.setPos(x, y, 0) def startBounce(self): taskMgr.add(self.bounce, 'PartyCog.bounceTask-%d' % self.id) def bounce(self, task): self.root.setZ( math.sin((self.bounceOffset + task.time) * self.bounceSpeed) * self.bounceHeight + self.heightShift) return task.cont def setPos(self, position): self.root.setPos(position) def respondToPieHit(self, timestamp, position, hot=False, direction=1.0): if self.netTimeSentToStartByHit < timestamp: self.__showSplat(position, direction, hot) if self.netTimeSentToStartByHit < timestamp: self.netTimeSentToStartByHit = timestamp else: self.notify.debug( 'respondToPieHit self.netTimeSentToStartByHit = %s' % self.netTimeSentToStartByHit) def clearHitInterval(self): if self.hitInterval is not None and self.hitInterval.isPlaying(): self.hitInterval.clearToInitial() return def __showSplat(self, position, direction, hot=False): if self.kaboomTrack is not None and self.kaboomTrack.isPlaying(): self.kaboomTrack.finish() self.clearHitInterval() splatName = 'splat-creampie' self.splat = globalPropPool.getProp(splatName) self.splat.setBillboardPointEye() self.splat.reparentTo(render) self.splat.setPos(self.root, position) self.splat.setAlphaScale(1.0) if not direction == 1.0: self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[0]) if self.currentFacing > 0.0: facing = 'HitFront' else: facing = 'HitBack' else: self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[1]) if self.currentFacing > 0.0: facing = 'HitBack' else: facing = 'HitFront' if hot: targetscale = 0.75 part = 'head' else: targetscale = 0.5 part = 'body' def setSplatAlpha(amount): self.splat.setAlphaScale(amount) self.hitInterval = Sequence( ActorInterval(self.actor, part + facing, loop=0), Func(self.actor.loop, 'idle')) self.hitInterval.start() self.kaboomTrack = Parallel( SoundInterval(self.pieHitSound, volume=1.0, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), Sequence( Func(self.splat.showThrough), Parallel( Sequence( LerpScaleInterval(self.splat, duration=0.175, scale=targetscale, startScale=Point3(0.1, 0.1, 0.1), blendType='easeOut'), Wait(0.175)), Sequence( Wait(0.1), LerpFunc(setSplatAlpha, duration=1.0, fromData=1.0, toData=0.0, blendType='easeOut'))), Func(self.splat.cleanup), Func(self.splat.removeNode))) self.kaboomTrack.start() return def showHitScore(self, number, scale=1): if number <= 0: return if self.hpText: self.hideHitScore() self.HpTextGenerator.setFont(ToontownGlobals.getSignFont()) if number < 0: self.HpTextGenerator.setText(str(number)) else: self.HpTextGenerator.setText('+' + str(number)) self.HpTextGenerator.clearShadow() self.HpTextGenerator.setAlign(TextNode.ACenter) r = 1 g = 1 b = 0 a = 1 self.HpTextGenerator.setTextColor(r, g, b, a) self.hpTextNode = self.HpTextGenerator.generate() self.hpText = render.attachNewNode(self.hpTextNode) self.hpText.setScale(scale) self.hpText.setBillboardPointEye() self.hpText.setBin('fixed', 100) self.hpText.setPos(self.root, 0, 0, self.height / 2) seq = Task.sequence( self.hpText.lerpPos(Point3( self.root.getX(render), self.root.getY(render), self.root.getZ(render) + self.height + 1.0), 0.25, blendType='easeOut'), Task.pause(0.25), self.hpText.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0), 0.1), Task.Task(self.__hideHitScoreTask)) taskMgr.add(seq, 'PartyCogHpText' + str(self.id)) def __hideHitScoreTask(self, task): self.hideHitScore() return Task.done def hideHitScore(self): if self.hpText: taskMgr.remove('PartyCogHpText' + str(self.id)) self.hpText.removeNode() self.hpText = None return def getHeadLocation(self): self.actor.getJoints(jointName='head')[0].getNetTransform( self.temp_transform) self.head_locator.setMat(self.temp_transform) return self.head_locator.getZ(self.root)
class PartyCog(FSM): notify = directNotify.newCategory("PartyCog") HpTextGenerator = TextNode("HpTextGenerator") hpText = None height = 7 def __init__(self, parentNode, id, bounceSpeed=3, bounceHeight=1, rotateSpeed=1, heightShift=1, xMoveSpeed=0, xMoveDistance=0, bounceOffset=0): self.id = id FSM.__init__(self, "PartyCogFSM-%d" % self.id) self.showFacingStatus = False self.xMoveSpeed = xMoveSpeed self.xMoveDistance = xMoveDistance self.heightShift = heightShift self.bounceSpeed = bounceSpeed self.bounceHeight = bounceHeight self.rotateSpeed = rotateSpeed self.parentNode = parentNode self.bounceOffset = bounceOffset self.hitInterval = None self.kaboomTrack = None self.resetRollIval = None self.netTimeSentToStartByHit = 0 self.load() self.request("Down") def load(self): self.root = NodePath("PartyCog-%d" % self.id) self.root.reparentTo(self.parentNode) path = "phase_13/models/parties/cogPinata_" self.actor = Actor( path + "actor", { "idle": path + "idle_anim", "down": path + "down_anim", "up": path + "up_anim", "bodyHitBack": path + "bodyHitBack_anim", "bodyHitFront": path + "bodyHitFront_anim", "headHitBack": path + "headHitBack_anim", "headHitFront": path + "headHitFront_anim", }) self.actor.reparentTo(self.root) self.temp_transform = Mat4() self.head_locator = self.actor.attachNewNode("temphead") self.bodyColl = CollisionTube(0, 0, 1, 0, 0, 5.75, 0.75) self.bodyColl.setTangible(1) self.bodyCollNode = CollisionNode("PartyCog-%d-Body-Collision" % self.id) self.bodyCollNode.setCollideMask(ToontownGlobals.PieBitmask) self.bodyCollNode.addSolid(self.bodyColl) self.bodyCollNodePath = self.root.attachNewNode(self.bodyCollNode) self.headColl = CollisionTube(0, 0, 3, 0, 0, 3.0, 1.5) self.headColl.setTangible(1) self.headCollNode = CollisionNode("PartyCog-%d-Head-Collision" % self.id) self.headCollNode.setCollideMask(ToontownGlobals.PieBitmask) self.headCollNode.addSolid(self.headColl) self.headCollNodePath = self.root.attachNewNode(self.headCollNode) # Cog's Left Arm self.arm1Coll = CollisionSphere(1.65, 0, 3.95, 1.0) self.arm1Coll.setTangible(1) self.arm1CollNode = CollisionNode("PartyCog-%d-Arm1-Collision" % self.id) self.arm1CollNode.setCollideMask(ToontownGlobals.PieBitmask) self.arm1CollNode.addSolid(self.arm1Coll) self.arm1CollNodePath = self.root.attachNewNode(self.arm1CollNode) # Cog's Right Arm self.arm2Coll = CollisionSphere(-1.65, 0, 3.45, 1.0) self.arm2Coll.setTangible(1) self.arm2CollNode = CollisionNode("PartyCog-%d-Arm2-Collision" % self.id) self.arm2CollNode.setCollideMask(ToontownGlobals.PieBitmask) self.arm2CollNode.addSolid(self.arm2Coll) self.arm2CollNodePath = self.root.attachNewNode(self.arm2CollNode) splatName = 'splat-creampie' self.splat = globalPropPool.getProp(splatName) self.splat.setBillboardPointEye() self.splatType = globalPropPool.getPropType(splatName) self.pieHitSound = globalBattleSoundCache.getSound( 'AA_wholepie_only.mp3') self.upSound = globalBattleSoundCache.getSound('AV_jump_to_side.mp3') self.hole = loader.loadModel("phase_13/models/parties/cogPinataHole") self.hole.setTransparency(True) self.hole.setP(-90.0) self.hole.setScale(3) self.hole.setBin("ground", 3) self.hole.reparentTo(self.parentNode) def unload(self): self.request("Off") self.clearHitInterval() if self.hole is not None: self.hole.removeNode() self.hole = None if self.actor is not None: self.actor.cleanup() self.actor.removeNode() self.actor = None if self.root is not None: self.root.removeNode() self.root = None if self.kaboomTrack is not None and self.kaboomTrack.isPlaying(): self.kaboomTrack.finish() self.kaboomTrack = None if self.resetRollIval is not None and self.resetRollIval.isPlaying(): self.resetRollIval.finish() self.resetRollIval = None if self.hitInterval is not None and self.hitInterval.isPlaying(): self.hitInterval.finish() self.hitInterval = None del self.upSound del self.pieHitSound #=============================================================================== # FSM States #=============================================================================== def enterStatic(self): pass def exitStatic(self): pass def enterActive(self, startTime): self.root.setR(0.0) updateTask = Task.Task(self.updateTask) updateTask.startTime = startTime taskMgr.add(updateTask, "PartyCog.update-%d" % self.id) def exitActive(self): taskMgr.remove("PartyCog.update-%d" % self.id) taskMgr.remove("PartyCog.bounceTask-%d" % self.id) self.clearHitInterval() self.resetRollIval = self.root.hprInterval(0.5, Point3( self.root.getH(), 0.0, 0.0), blendType="easeInOut") self.resetRollIval.start() self.actor.stop() def enterDown(self): if self.oldState == "Off": downAnimControl = self.actor.getAnimControl("down") self.actor.pose("down", downAnimControl.getNumFrames() - 1) return self.clearHitInterval() startScale = self.hole.getScale() endScale = Point3(5, 5, 5) self.hitInterval = Sequence( LerpFunc(self.setAlongSpline, duration=1.0, fromData=self.currentT, toData=0.0), LerpScaleInterval(self.hole, duration=0.175, scale=endScale, startScale=startScale, blendType="easeIn"), Parallel( SoundInterval(self.upSound, volume=0.6, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), ActorInterval(self.actor, "down", loop=0), ), LerpScaleInterval(self.hole, duration=0.175, scale=Point3(3, 3, 3), startScale=endScale, blendType="easeOut"), ) self.hitInterval.start() def exitDown(self): self.root.setR(0.0) self.root.setH(0.0) self.targetDistance = 0.0 self.targetFacing = 0.0 self.currentT = 0.0 self.setAlongSpline(0.0) self.clearHitInterval() startScale = self.hole.getScale() endScale = Point3(5, 5, 5) self.hitInterval = Sequence( LerpScaleInterval(self.hole, duration=0.175, scale=endScale, startScale=startScale, blendType="easeIn"), Parallel( SoundInterval(self.upSound, volume=0.6, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), ActorInterval(self.actor, "up", loop=0), ), Func(self.actor.loop, "idle"), LerpScaleInterval(self.hole, duration=0.175, scale=Point3(3, 3, 3), startScale=endScale, blendType="easeOut"), ) self.hitInterval.start() def filterDown(self, request, args): if request == "Down": return None else: return self.defaultFilter(request, args) #------------------------------------------------------------------------------ def setEndPoints(self, start, end, amplitude=1.7): self.sinAmplitude = amplitude self.sinPeriod = (end.getX() - start.getX()) / 2 self.sinDisplacement = start.getY() self.startPoint = start self.endPoint = end self.currentT = 0.0 self.targetDistance = 0.0 self.currentFacing = 0.0 self.targetFacing = 0.0 self.setAlongSpline(self.currentT) self.hole.setPos(self.root.getPos()) self.hole.setZ(0.02) def rockBackAndForth(self, task): t = task.startTime + task.time angle = math.sin(t) * 20.0 self.root.setR(angle) # if self.id == 0: # print angle return task.cont def updateDistance(self, distance): self.targetDistance = clamp(distance, -1.0, 1.0) def updateTask(self, task): self.rockBackAndForth(task) if self.targetDistance > self.currentT: self.currentT += min(0.01, self.targetDistance - self.currentT) self.setAlongSpline(self.currentT) elif self.targetDistance < self.currentT: self.currentT += max(-0.01, self.targetDistance - self.currentT) self.setAlongSpline(self.currentT) if self.currentT < 0.0: self.targetFacing = -90.0 elif self.currentT > 0.0: self.targetFacing = 90.0 else: self.targetFacing = 0.0 if self.targetFacing > self.currentFacing: self.currentFacing += min(10, self.targetFacing - self.currentFacing) elif self.targetFacing < self.currentFacing: self.currentFacing += max(-10, self.targetFacing - self.currentFacing) self.root.setH(self.currentFacing) return task.cont def setAlongSpline(self, t): t = t + 1.0 dist = (self.endPoint.getX() - self.startPoint.getX()) / 2.0 x = self.startPoint.getX() + t * dist y = self.startPoint.getY() - math.sin( t * 2 * math.pi) * self.sinAmplitude self.root.setPos(x, y, 0) def startBounce(self): taskMgr.add(self.bounce, "PartyCog.bounceTask-%d" % self.id) def bounce(self, task): #self.root.setH(self.root.getH() - self.rotateSpeed) self.root.setZ((math.sin((self.bounceOffset + task.time) * self.bounceSpeed) * self.bounceHeight) + self.heightShift) return task.cont def setPos(self, position): self.root.setPos(position) def respondToPieHit(self, timestamp, position, hot=False, direction=1.0): """The toon hit us, react appropriately.""" assert (self.notify.debugStateCall(self)) if self.netTimeSentToStartByHit < timestamp: self.__showSplat(position, direction, hot) if self.netTimeSentToStartByHit < timestamp: self.netTimeSentToStartByHit = timestamp else: #self.notify.debug('localStamp = %s, lastLocalTimeStampFromAI=%s, ignoring respondToPieHit' % (localStamp, self.lastLocalTimeStampFromAI)) self.notify.debug( 'respondToPieHit self.netTimeSentToStartByHit = %s' % self.netTimeSentToStartByHit) def clearHitInterval(self): if self.hitInterval is not None and self.hitInterval.isPlaying(): self.hitInterval.clearToInitial() def __showSplat(self, position, direction, hot=False): """Show the splat graphic and sound.""" if self.kaboomTrack is not None and self.kaboomTrack.isPlaying(): self.kaboomTrack.finish() self.clearHitInterval() splatName = 'splat-creampie' self.splat = globalPropPool.getProp(splatName) self.splat.setBillboardPointEye() self.splat.reparentTo(render) self.splat.setPos(self.root, position) self.splat.setAlphaScale(1.0) if not direction == 1.0: #self.splat.setColorScale(Vec4(0.0, 0.0, 50.0, 1.0)) self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[0]) if self.currentFacing > 0.0: facing = "HitFront" else: facing = "HitBack" else: self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[1]) #self.splat.setColorScale(Vec4(1.0, 0.6, 0.08, 1.0)) if self.currentFacing > 0.0: facing = "HitBack" else: facing = "HitFront" if hot: targetscale = 0.75 part = "head" else: targetscale = 0.5 part = "body" def setSplatAlpha(amount): self.splat.setAlphaScale(amount) self.hitInterval = Sequence( ActorInterval(self.actor, part + facing, loop=0), Func(self.actor.loop, "idle"), ) self.hitInterval.start() self.kaboomTrack = Parallel( SoundInterval(self.pieHitSound, volume=1.0, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), Sequence( Func(self.splat.showThrough), Parallel( Sequence( LerpScaleInterval(self.splat, duration=0.175, scale=targetscale, startScale=Point3(0.1, 0.1, 0.1), blendType="easeOut"), Wait(0.175), ), Sequence( Wait(0.1), LerpFunc( setSplatAlpha, duration=1.0, #0.4, fromData=1.0, toData=0.0, blendType="easeOut"))), Func(self.splat.cleanup), Func(self.splat.removeNode), )) self.kaboomTrack.start() def showHitScore(self, number, scale=1): """ Shows the hit score. Borrowed from otp.avatar.DistributedAvatar.showHpText """ if number <= 0: return # Get rid of the number if it is already there. if self.hpText: self.hideHitScore() # Set the font self.HpTextGenerator.setFont(ToontownGlobals.getSignFont()) # Show both negative and positive signs if number < 0: self.HpTextGenerator.setText(str(number)) else: self.HpTextGenerator.setText("+" + str(number)) # No shadow self.HpTextGenerator.clearShadow() # Center the number self.HpTextGenerator.setAlign(TextNode.ACenter) # Red, always #if number < 0: r = 1 #0.9 g = 1 #0 b = 0 a = 1 self.HpTextGenerator.setTextColor(r, g, b, a) self.hpTextNode = self.HpTextGenerator.generate() # Put the hpText over the head of the avatar self.hpText = render.attachNewNode(self.hpTextNode) self.hpText.setScale(scale) # Make sure it is a billboard self.hpText.setBillboardPointEye() # Render it after other things in the scene. self.hpText.setBin('fixed', 100) # Initial position ... Center of the body... the "tan tien" self.hpText.setPos(self.root, 0, 0, self.height / 2) # Black magic from the early days of Panda3D, later replaced by a Sequence seq = Task.sequence( # Fly the number out of the character self.hpText.lerpPos(Point3( self.root.getX(render), self.root.getY(render), self.root.getZ(render) + self.height + 1.0), 0.25, blendType='easeOut'), Task.pause(0.25), # Fade the number self.hpText.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0), 0.1), # Get rid of the number Task.Task(self.__hideHitScoreTask)) taskMgr.add(seq, "PartyCogHpText" + str(self.id)) def __hideHitScoreTask(self, task): self.hideHitScore() return Task.done def hideHitScore(self): if self.hpText: taskMgr.remove("PartyCogHpText" + str(self.id)) self.hpText.removeNode() self.hpText = None def getHeadLocation(self): (self.actor.getJoints(jointName="head")[0]).getNetTransform( self.temp_transform) self.head_locator.setMat(self.temp_transform) #print self.head_locator.getZ() return self.head_locator.getZ(self.root)
class thirdPerson(DirectObject): def __init__(self, parserClass, mainClass, mapLoaderClass, modelLoaderClass): self.switchState = False # self.t = Timer() self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0} self.ralph = Actor( "data/models/units/ralph/ralph", {"run": "data/models/units/ralph/ralph-run", "walk": "data/models/units/ralph/ralph-walk"}, ) self.ralph.reparentTo(render) # self.ralph.setPos(42, 30, 0) self.ralph.setPos(6, 10, 0) self.ralph.setScale(0.1) self.accept("escape", sys.exit) self.accept("arrow_left", self.setKey, ["left", 1]) self.accept("arrow_left-up", self.setKey, ["left", 0]) self.accept("arrow_right", self.setKey, ["right", 1]) self.accept("arrow_right-up", self.setKey, ["right", 0]) self.accept("arrow_up", self.setKey, ["forward", 1]) self.accept("arrow_up-up", self.setKey, ["forward", 0]) self.accept("arrow_down", self.setKey, ["backward", 1]) self.accept("arrow_down-up", self.setKey, ["backward", 0]) self.isMoving = False self.cTrav = CollisionTraverser() self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0, 0, 1000) self.ralphGroundRay.setDirection(0, 0, -1) self.ralphGroundCol = CollisionNode("ralphRay") self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0)) self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) # self.ralphGroundCol.show() base.cam.reparentTo(self.ralph) base.cam.setPos(0, 9, 7) self.floater2 = NodePath(PandaNode("floater2")) self.floater2.reparentTo(self.ralph) self.floater2.setZ(self.floater2.getZ() + 6) base.cam.lookAt(self.floater2) # Uncomment this line to see the collision rays # self.ralphGroundColNp.show() # self.camGroundColNp.show() # Uncomment this line to show a visual representation of the # collisions occuring # self.cTrav.showCollisions(render) self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) taskMgr.add(self.move, "movingTask", extraArgs=[mainClass, parserClass, mapLoaderClass, modelLoaderClass]) # Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value def move(self, mainClass, parserClass, mapLoaderClass, modelLoaderClass): # Get the time elapsed since last frame. We need this # for framerate-independent movement. elapsed = globalClock.getDt() # save ralph's initial position so that we can restore it, # in case he falls off the map or runs into something. startpos = self.ralph.getPos() # If a move-key is pressed, move ralph in the specified direction. if self.keyMap["left"] != 0: self.ralph.setH(self.ralph.getH() + elapsed * 300) if self.keyMap["right"] != 0: self.ralph.setH(self.ralph.getH() - elapsed * 300) if self.keyMap["forward"] != 0: self.ralph.setY(self.ralph, -(elapsed * 50)) # 25)) if self.keyMap["backward"] != 0: self.ralph.setY(self.ralph, +(elapsed * 20)) if (self.keyMap["forward"] != 0) or (self.keyMap["left"] != 0) or (self.keyMap["right"] != 0): if self.isMoving is False: self.ralph.loop("run") self.isMoving = True elif self.keyMap["backward"] != 0: if self.isMoving is False: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False else: if self.isMoving: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False # Now check for collisions. self.cTrav.traverse(render) # Adjust ralph's Z coordinate. If ralph's ray hit terrain, # update his Z. If it hit anything else, or didn't hit anything, put # him back where he was last frame. entries = [] for i in range(self.ralphGroundHandler.getNumEntries()): entry = self.ralphGroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries) > 0) and (entries[0].getIntoNode().getName()[0:4] == "tile"): self.ralph.setZ(entries[0].getSurfacePoint(render).getZ()) elif (len(entries) > 0) and (entries[0].getIntoNode().getName()[0:5] == "solid"): self.ralph.setPos(startpos) x = int( entries[0] .getIntoNode() .getName()[len(entries[0].getIntoNode().getName()) - 6 : len(entries[0].getIntoNode().getName()) - 4] ) y = int(entries[0].getIntoNode().getName()[len(entries[0].getIntoNode().getName()) - 2 :]) if mapLoaderClass.tileArray[y][x].drillTime != None: mainClass.changeTile(mapLoaderClass.tileArray[y][x], 0, parserClass, modelLoaderClass, mapLoaderClass) else: self.ralph.setPos(startpos) self.ralph.setP(0) return Task.cont
class DistributedFort(DistributedBattleAvatar.DistributedBattleAvatar): notify = directNotify.newCategory("DistributedFort") endingR = 60 zeroHpR = 90 HpTextGenerator = TextNode("HpTextGenerator") HpTextEnabled = 1 def __init__(self, cr): DistributedBattleAvatar.DistributedBattleAvatar.__init__(self, cr) self.island = None self.name = PLocalizer.NavyFortName self.level = 1 self.meterHp = self.maxHp self.hpMeter = None self.meterMp = 0 self.maxMojo = 0 self.currentAttack = 0 self.drawbridges = [] self.smoke = None self.islandRequest = None self.islandDependedObjectsSetup = 0 self.hpTextNodes = [] self.hpTextIvals = [] def delete(self): DistributedBattleAvatar.DistributedBattleAvatar.delete(self) if self.smoke: self.smoke.destroy() self.smoke = None if self.hpMeter: self.hpMeter.destroy() self.hpMeter = None if self.islandRequest: self.cr.relatedObjectMgr.abortRequest(self.islandRequest) def setIslandId(self, islandId): self.islandId = islandId def getNameText(self): return "" def setObjKey(self, objKey): self.objKey = objKey def loadModel(self): DistributedBattleAvatar.DistributedBattleAvatar.loadModel(self) def createGameFSM(self): self.gameFSM = BattleAvatarGameFSM.BattleAvatarGameFSM(self) def announceGenerate(self): self.notify.debug("announceGenerate") self.battleTubeRadius = 50.0 self.battleTubeHeight = 100.0 DistributedBattleAvatar.DistributedBattleAvatar.announceGenerate(self) self.cr.relatedObjectMgr.abortRequest(self.islandRequest) self.islandRequest = self.cr.relatedObjectMgr.requestObjects( [self.islandId], eachCallback=self._DistributedFort__gotIsland ) def disable(self): DistributedBattleAvatar.DistributedBattleAvatar.disable(self) self.island = None self.fortNode = None self.islandDependedObjectsSetup = 0 def _DistributedFort__gotIsland(self, island): self.notify.debug("__gotIsland %s" % island) self.islandRequest = None if island.lastZoneLevel == 0: self._DistributedFort__setupIslandDependentObjects() else: self.cr.distributedDistrict.worldCreator.registerPostLoadCall( self._DistributedFort__setupIslandDependentObjects ) def _DistributedFort__setupIslandDependentObjects(self): self.notify.debug("setupIslandDependentObjects") if not self.areDrawbridgesLoaded(): self.cr.distributedDistrict.worldCreator.registerPostLoadCall( self._DistributedFort__setupIslandDependentObjects ) self.notify.debug("no drawbridges yet, registering another post load call") return None self.notify.debug("drawbridges are in render") self.setupCollisions() self.setupDrawbridges() self.islandDependedObjectsSetup = 1 def readyToGo(self): if self.islandDependedObjectsSetup == 1: pass return self.isGenerated() def smoothPosition(self): DistributedReputationAvatar.smoothPosition(self) def setupCollisions(self): self.notify.debug("setupCollisions") self.island = base.cr.doId2do.get(self.islandId) if not self.island: self.notify.warning("Couldn't find island %d" % self.islandId) return None self.fortNode = self.island.find("**/=uid=%s" % self.objKey) if self.fortNode == self.fortNode.notFound(): self.notify.warning("Couldn't find fort uid %s" % self.objKey) return None allColls = self.fortNode.findAllMatches("**/*collision*") if allColls.getNumPaths() == 0: allColls = self.fortNode.findAllMatches("**/*Col_*") oldBitMask = allColls.getCollideMask() newBitMask = oldBitMask | PiratesGlobals.TargetBitmask allColls.setCollideMask(newBitMask) for index in xrange(allColls.getNumPaths()): nodePath = allColls[index] nodePath.setTag("objType", str(PiratesGlobals.COLL_FORT)) nodePath.setTag("fortId", str(self.doId)) def getNameText(self): pass def gotHitByProjectile(self, hitObject, entry, skillId, ammoSkillId): fn = entry.getFromNodePath() fortId = fn.getNetTag("fortId") if fortId: fortId = int(fortId) if fortId == self.doId: return None if fortId and fortId > 0: return None self.sendHitByProjectile(skillId, ammoSkillId) def sendHitByProjectile(self, skillId, ammoSkillId): if self.hp > 0: self.sendUpdate("hitByProjectile", [skillId, ammoSkillId]) def getLevel(self): return self.level def setupHpMeter(self): if self.hpMeter: return None zAdj = 50 self.smokeZAdj = zAdj self.fortPart = self.fortNode.find("**/top_interior_wall_collision") if self.fortPart.isEmpty(): self.fortPart = self.fortNode.find("**/col_TopFloor1") if self.fortPart.isEmpty(): self.fortPart = self.fortNode.find("**/pPlane4") zAdj = 150 self.smokeZAdj = 100 if self.fortPart.isEmpty(): self.fortPart = self.fortNode.find("**/*tower*") if self.fortPart.isEmpty(): self.fortPart = self.fortNode.find("**/*buttress*") if self.fortPart.isEmpty(): self.fortPart = self.fortNode.find("**/*floor*") fortPartBounds = self.fortPart.getBounds() self.hpAnchor = NodePath("hpAnchor") self.hpAnchor.setPos(fortPartBounds.getApproxCenter()) self.hpAnchor.setZ(self.hpAnchor.getZ() + zAdj) self.hpAnchor.reparentTo(self.fortNode) self.hpMeter = HpMeter.HpMeter(fadeOut=0, parent=self.hpAnchor, originAtMidPt=True) self.hpMeter.setScale(200) self.hpMeter.setBin("fixed", 130) self.hpMeter.setDepthWrite(False) myEffect = BillboardEffect.make(Vec3(0, 0, 1), True, False, 150, NodePath(), Point3(0, 0, 0)) self.hpMeter.node().setEffect(myEffect) self.hpMeter.update(self.hp, self.maxHp) self.hideFortHpMeter() def setHp(self, hp, quietly=0): DistributedBattleAvatar.DistributedBattleAvatar.setHp(self, hp, quietly) if self.isGenerated(): if not self.hpMeter: self.setupHpMeter() self.hpMeter.update(self.hp, self.maxHp) if self.drawbridges: self.updateDrawbridges() if self.hp < self.maxHp: self.updateSmoke() if self.hp <= 0: self.hpMeter.hide() def takeDamage(self, hpLost, pos, bonus=0): DistributedBattleAvatar.DistributedBattleAvatar.takeDamage(self, hpLost, pos, bonus) def died(self): if self.cr and self.cr.wantSpecialEffects != 0: shipDebrisEffect = ShipDebris.getEffect() if shipDebrisEffect and not self.hpAnchor.isEmpty(): shipDebrisEffect.reparentTo(self.hpAnchor) shipDebrisEffect.setZ(shipDebrisEffect.getZ() - self.smokeZAdj) shipDebrisEffect.endPlaneZ = 0 shipDebrisEffect.play() def hideFortHpMeter(self): if self.hpMeter: self.hpMeter.hide() def showFortHpMeter(self): if self.hpMeter: self.hpMeter.show() def getInventory(self): pass def setupDrawbridgeCollisions(self, dbName, drawbridge): curNodePath = drawbridge oldBitMask = curNodePath.getCollideMask() newBitMask = oldBitMask | PiratesGlobals.TargetBitmask newBitMask = newBitMask & ~(PiratesGlobals.ShipCollideBitmask) curNodePath.setCollideMask(newBitMask) curNodePath.setTag("objType", str(PiratesGlobals.COLL_FORT)) curNodePath.setTag("fortId", str(self.doId)) shipCollider = drawbridge.find("**/*shipcollide*;+s") if shipCollider.isEmpty(): self.notify.warning("setupDrawbridgeCollisions could not find ship collider for %s" % dbName) tempStr = "drawbridge_pier" lenTemp = len(tempStr) suffix = dbName[lenTemp:] otherParts = ( "crane_island", "crane1_island", "drawbridge_fort", "crane_fort", "crane1_fort", "drawbridge_fort", ) for otherPart in otherParts: nodeName = otherPart + suffix curNodePath = render.find("**/%s" % nodeName) if curNodePath.isEmpty(): self.notify.warning("setupDrawbridgeCollisions() couldn't find nodepath %s" % nodeName) continue oldBitMask = curNodePath.getCollideMask() newBitMask = oldBitMask | PiratesGlobals.TargetBitmask curNodePath.setCollideMask(newBitMask) curNodePath.setTag("objType", str(PiratesGlobals.COLL_FORT)) curNodePath.setTag("fortId", str(self.doId)) def setupDrawbridges(self): if TreasureMapBlackPearlGlobals.DrawbridgeDict.has_key(self.objKey): dbTuple = TreasureMapBlackPearlGlobals.DrawbridgeDict[self.objKey] for dbName in dbTuple: drawbridge = render.find("**/%s" % dbName) if drawbridge.isEmpty(): self.notify.warning("couldn't find drawbridge %s" % dbName) continue self.drawbridges.append(drawbridge) self.setupDrawbridgeCollisions(dbName, drawbridge) def areDrawbridgesLoaded(self): retval = True if TreasureMapBlackPearlGlobals.DrawbridgeDict.has_key(self.objKey): dbTuple = TreasureMapBlackPearlGlobals.DrawbridgeDict[self.objKey] for dbName in dbTuple: drawbridge = render.find("**/%s" % dbName) if drawbridge.isEmpty(): retval = False continue return retval def updateDrawbridges(self): for drawbridge in self.drawbridges: if self.hp <= 0: if base.options.getSpecialEffectsSetting() >= base.options.SpecialEffectsHigh: smokeEffect = SmokeExplosion.getEffect() if smokeEffect: smokeEffect.reparentTo(render) smokeEffect.setPos(drawbridge, 0, 0, 0) smokeEffect.spriteScale = 1.0 smokeEffect.play() posHprIval = LerpPosHprInterval( drawbridge, 1.0, Vec3(drawbridge.getX(), drawbridge.getY(), drawbridge.getZ() - 130.0), Vec3(drawbridge.getH(), drawbridge.getP() - 360.0, drawbridge.getR() + 15), ) posHprIval.start() continue def debugMissing(self): wi = render.find("**/whole_island") allChildren = wi.getChildren() for index in xrange(allChildren.getNumPaths()): np = allChildren.getPath(index) if not np.isHidden(): print np np.hide() break continue def setDrawbridgesR(self, r): for drawbridge in self.drawbridges: drawbridge.setR(r) def setDrawbridgesLerpR(self, r): angle = 0 if r == 1: angle = -70 for drawbridge in self.drawbridges: if drawbridge.getR() == angle: return None ival = LerpHprInterval(drawbridge, 4.0, Vec3(drawbridge.getH(), drawbridge.getP(), angle)) ival.start() def hideDrawbridges(self): for drawbridge in self.drawbridges: drawbridge.hide() def updateSmoke(self): if self.hp < self.maxHp: self.startSmoke() if self.smoke: density = 1 - float(self.hp) / self.maxHp self.smoke.setDensity(density) def startSmoke(self): if not self.smoke: self.smoke = BlackSmoke.getEffect() if self.smoke: self.smoke.reparentTo(self.hpAnchor) self.smoke.setZ(-(self.smokeZAdj)) self.smoke.startLoop() def setupRadarGui(self): self.hpAnchor.setTag("avId", str(self.doId)) self.setTeam(PiratesGlobals.NAVY_TEAM) def initializeBattleCollisions(self): pass def setLevel(self, level): self.level = level def printExpText(self, totalExp, colorSetting, basicPenalty, crewBonus, doubleXPBonus, holidayBonus, potionBonus): taskMgr.doMethodLater( 0.5, self.showHpText, self.taskName("printExp"), [totalExp, 4, 6.0, 1.0, basicPenalty, crewBonus, doubleXPBonus, holidayBonus, potionBonus], ) def showHpText( self, number, bonus=0, duration=2.0, scale=1.0, basicPenalty=0, crewBonus=0, doubleXPBonus=0, holidayBonus=0, potionBonus=0, ): if self.isEmpty(): return None distance = camera.getDistance(self) scale *= max(1.0, distance / 50.0) height = self.hpAnchor.getZ() + 25.0 startPos = Point3(0, 0, height / 4) destPos = Point3(0, 0, height / 2) newEffect = None def cleanup(): if newEffect in self.textEffects: self.textEffects.remove(newEffect) mods = {} if basicPenalty > 0: mods[TextEffect.MOD_BASICPENALTY] = basicPenalty if crewBonus > 0: mods[TextEffect.MOD_CREWBONUS] = crewBonus if doubleXPBonus > 0: mods[TextEffect.MOD_2XPBONUS] = doubleXPBonus if holidayBonus > 0: mods[TextEffect.MOD_HOLIDAYBONUS] = holidayBonus newEffect = TextEffect.genTextEffect( self.hpAnchor, self.HpTextGenerator, number, bonus, self.isNpc, cleanup, startPos, destPos, scale, modifiers=mods, ) if newEffect: self.textEffects.append(newEffect)
class PartyCog(FSM): notify = directNotify.newCategory('PartyCog') HpTextGenerator = TextNode('HpTextGenerator') hpText = None height = 7 def __init__(self, parentNode, id, bounceSpeed = 3, bounceHeight = 1, rotateSpeed = 1, heightShift = 1, xMoveSpeed = 0, xMoveDistance = 0, bounceOffset = 0): self.id = id FSM.__init__(self, 'PartyCogFSM-%d' % self.id) self.showFacingStatus = False self.xMoveSpeed = xMoveSpeed self.xMoveDistance = xMoveDistance self.heightShift = heightShift self.bounceSpeed = bounceSpeed self.bounceHeight = bounceHeight self.rotateSpeed = rotateSpeed self.parentNode = parentNode self.bounceOffset = bounceOffset self.hitInterval = None self.kaboomTrack = None self.resetRollIval = None self.netTimeSentToStartByHit = 0 self.load() self.request('Down') return def load(self): self.root = NodePath('PartyCog-%d' % self.id) self.root.reparentTo(self.parentNode) path = 'phase_13/models/parties/cogPinata_' self.actor = Actor(path + 'actor', {'idle': path + 'idle_anim', 'down': path + 'down_anim', 'up': path + 'up_anim', 'bodyHitBack': path + 'bodyHitBack_anim', 'bodyHitFront': path + 'bodyHitFront_anim', 'headHitBack': path + 'headHitBack_anim', 'headHitFront': path + 'headHitFront_anim'}) self.actor.reparentTo(self.root) self.temp_transform = Mat4() self.head_locator = self.actor.attachNewNode('temphead') self.bodyColl = CollisionTube(0, 0, 1, 0, 0, 5.75, 0.75) self.bodyColl.setTangible(1) self.bodyCollNode = CollisionNode('PartyCog-%d-Body-Collision' % self.id) self.bodyCollNode.setCollideMask(ToontownGlobals.PieBitmask) self.bodyCollNode.addSolid(self.bodyColl) self.bodyCollNodePath = self.root.attachNewNode(self.bodyCollNode) self.headColl = CollisionTube(0, 0, 3, 0, 0, 3.0, 1.5) self.headColl.setTangible(1) self.headCollNode = CollisionNode('PartyCog-%d-Head-Collision' % self.id) self.headCollNode.setCollideMask(ToontownGlobals.PieBitmask) self.headCollNode.addSolid(self.headColl) self.headCollNodePath = self.root.attachNewNode(self.headCollNode) self.arm1Coll = CollisionSphere(1.65, 0, 3.95, 1.0) self.arm1Coll.setTangible(1) self.arm1CollNode = CollisionNode('PartyCog-%d-Arm1-Collision' % self.id) self.arm1CollNode.setCollideMask(ToontownGlobals.PieBitmask) self.arm1CollNode.addSolid(self.arm1Coll) self.arm1CollNodePath = self.root.attachNewNode(self.arm1CollNode) self.arm2Coll = CollisionSphere(-1.65, 0, 3.45, 1.0) self.arm2Coll.setTangible(1) self.arm2CollNode = CollisionNode('PartyCog-%d-Arm2-Collision' % self.id) self.arm2CollNode.setCollideMask(ToontownGlobals.PieBitmask) self.arm2CollNode.addSolid(self.arm2Coll) self.arm2CollNodePath = self.root.attachNewNode(self.arm2CollNode) splatName = 'splat-creampie' self.splat = globalPropPool.getProp(splatName) self.splat.setBillboardPointEye() self.splatType = globalPropPool.getPropType(splatName) self.pieHitSound = globalBattleSoundCache.getSound('AA_wholepie_only.ogg') self.upSound = globalBattleSoundCache.getSound('AV_jump_to_side.ogg') self.hole = loader.loadModel('phase_13/models/parties/cogPinataHole') self.hole.setTransparency(True) self.hole.setP(-90.0) self.hole.setScale(3) self.hole.setBin('ground', 3) self.hole.reparentTo(self.parentNode) def unload(self): self.request('Off') self.clearHitInterval() if self.hole is not None: self.hole.removeNode() self.hole = None if self.actor is not None: self.actor.cleanup() self.actor.removeNode() self.actor = None if self.root is not None: self.root.removeNode() self.root = None if self.kaboomTrack is not None and self.kaboomTrack.isPlaying(): self.kaboomTrack.finish() self.kaboomTrack = None if self.resetRollIval is not None and self.resetRollIval.isPlaying(): self.resetRollIval.finish() self.resetRollIval = None if self.hitInterval is not None and self.hitInterval.isPlaying(): self.hitInterval.finish() self.hitInterval = None del self.upSound del self.pieHitSound return def enterStatic(self): pass def exitStatic(self): pass def enterActive(self, startTime): self.root.setR(0.0) updateTask = Task.Task(self.updateTask) updateTask.startTime = startTime taskMgr.add(updateTask, 'PartyCog.update-%d' % self.id) def exitActive(self): taskMgr.remove('PartyCog.update-%d' % self.id) taskMgr.remove('PartyCog.bounceTask-%d' % self.id) self.clearHitInterval() self.resetRollIval = self.root.hprInterval(0.5, Point3(self.root.getH(), 0.0, 0.0), blendType='easeInOut') self.resetRollIval.start() self.actor.stop() def enterDown(self): if self.oldState == 'Off': downAnimControl = self.actor.getAnimControl('down') self.actor.pose('down', downAnimControl.getNumFrames() - 1) return self.clearHitInterval() startScale = self.hole.getScale() endScale = Point3(5, 5, 5) self.hitInterval = Sequence(LerpFunc(self.setAlongSpline, duration=1.0, fromData=self.currentT, toData=0.0), LerpScaleInterval(self.hole, duration=0.175, scale=endScale, startScale=startScale, blendType='easeIn'), Parallel(SoundInterval(self.upSound, volume=0.6, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), ActorInterval(self.actor, 'down', loop=0)), LerpScaleInterval(self.hole, duration=0.175, scale=Point3(3, 3, 3), startScale=endScale, blendType='easeOut')) self.hitInterval.start() def exitDown(self): self.root.setR(0.0) self.root.setH(0.0) self.targetDistance = 0.0 self.targetFacing = 0.0 self.currentT = 0.0 self.setAlongSpline(0.0) self.clearHitInterval() startScale = self.hole.getScale() endScale = Point3(5, 5, 5) self.hitInterval = Sequence(LerpScaleInterval(self.hole, duration=0.175, scale=endScale, startScale=startScale, blendType='easeIn'), Parallel(SoundInterval(self.upSound, volume=0.6, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), ActorInterval(self.actor, 'up', loop=0)), Func(self.actor.loop, 'idle'), LerpScaleInterval(self.hole, duration=0.175, scale=Point3(3, 3, 3), startScale=endScale, blendType='easeOut')) self.hitInterval.start() def filterDown(self, request, args): if request == 'Down': return None else: return self.defaultFilter(request, args) return None def setEndPoints(self, start, end, amplitude = 1.7): self.sinAmplitude = amplitude self.sinPeriod = (end.getX() - start.getX()) / 2 self.sinDisplacement = start.getY() self.startPoint = start self.endPoint = end self.currentT = 0.0 self.targetDistance = 0.0 self.currentFacing = 0.0 self.targetFacing = 0.0 self.setAlongSpline(self.currentT) self.hole.setPos(self.root.getPos()) self.hole.setZ(0.02) def rockBackAndForth(self, task): t = task.startTime + task.time angle = math.sin(t) * 20.0 self.root.setR(angle) return task.cont def updateDistance(self, distance): self.targetDistance = clamp(distance, -1.0, 1.0) def updateTask(self, task): self.rockBackAndForth(task) if self.targetDistance > self.currentT: self.currentT += min(0.01, self.targetDistance - self.currentT) self.setAlongSpline(self.currentT) elif self.targetDistance < self.currentT: self.currentT += max(-0.01, self.targetDistance - self.currentT) self.setAlongSpline(self.currentT) if self.currentT < 0.0: self.targetFacing = -90.0 elif self.currentT > 0.0: self.targetFacing = 90.0 else: self.targetFacing = 0.0 if self.targetFacing > self.currentFacing: self.currentFacing += min(10, self.targetFacing - self.currentFacing) elif self.targetFacing < self.currentFacing: self.currentFacing += max(-10, self.targetFacing - self.currentFacing) self.root.setH(self.currentFacing) return task.cont def setAlongSpline(self, t): t = t + 1.0 dist = (self.endPoint.getX() - self.startPoint.getX()) / 2.0 x = self.startPoint.getX() + t * dist y = self.startPoint.getY() - math.sin(t * 2 * math.pi) * self.sinAmplitude self.root.setPos(x, y, 0) def startBounce(self): taskMgr.add(self.bounce, 'PartyCog.bounceTask-%d' % self.id) def bounce(self, task): self.root.setZ(math.sin((self.bounceOffset + task.time) * self.bounceSpeed) * self.bounceHeight + self.heightShift) return task.cont def setPos(self, position): self.root.setPos(position) def respondToPieHit(self, timestamp, position, hot = False, direction = 1.0): if self.netTimeSentToStartByHit < timestamp: self.__showSplat(position, direction, hot) if self.netTimeSentToStartByHit < timestamp: self.netTimeSentToStartByHit = timestamp else: self.notify.debug('respondToPieHit self.netTimeSentToStartByHit = %s' % self.netTimeSentToStartByHit) def clearHitInterval(self): if self.hitInterval is not None and self.hitInterval.isPlaying(): self.hitInterval.clearToInitial() return def __showSplat(self, position, direction, hot = False): if self.kaboomTrack is not None and self.kaboomTrack.isPlaying(): self.kaboomTrack.finish() self.clearHitInterval() splatName = 'splat-creampie' self.splat = globalPropPool.getProp(splatName) self.splat.setBillboardPointEye() self.splat.reparentTo(render) self.splat.setPos(self.root, position) self.splat.setAlphaScale(1.0) if not direction == 1.0: self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[0]) if self.currentFacing > 0.0: facing = 'HitFront' else: facing = 'HitBack' else: self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[1]) if self.currentFacing > 0.0: facing = 'HitBack' else: facing = 'HitFront' if hot: targetscale = 0.75 part = 'head' else: targetscale = 0.5 part = 'body' def setSplatAlpha(amount): self.splat.setAlphaScale(amount) self.hitInterval = Sequence(ActorInterval(self.actor, part + facing, loop=0), Func(self.actor.loop, 'idle')) self.hitInterval.start() self.kaboomTrack = Parallel(SoundInterval(self.pieHitSound, volume=1.0, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), Sequence(Func(self.splat.showThrough), Parallel(Sequence(LerpScaleInterval(self.splat, duration=0.175, scale=targetscale, startScale=Point3(0.1, 0.1, 0.1), blendType='easeOut'), Wait(0.175)), Sequence(Wait(0.1), LerpFunc(setSplatAlpha, duration=1.0, fromData=1.0, toData=0.0, blendType='easeOut'))), Func(self.splat.cleanup), Func(self.splat.removeNode))) self.kaboomTrack.start() return def showHitScore(self, number, scale = 1): if number <= 0: return if self.hpText: self.hideHitScore() self.HpTextGenerator.setFont(ToontownGlobals.getSignFont()) if number < 0: self.HpTextGenerator.setText(str(number)) else: self.HpTextGenerator.setText('+' + str(number)) self.HpTextGenerator.clearShadow() self.HpTextGenerator.setAlign(TextNode.ACenter) r = 1 g = 1 b = 0 a = 1 self.HpTextGenerator.setTextColor(r, g, b, a) self.hpTextNode = self.HpTextGenerator.generate() self.hpText = render.attachNewNode(self.hpTextNode) self.hpText.setScale(scale) self.hpText.setBillboardPointEye() self.hpText.setBin('fixed', 100) self.hpText.setPos(self.root, 0, 0, self.height / 2) seq = Sequence(self.hpText.posInterval(0.25, Point3(self.root.getX(render), self.root.getY(render), self.root.getZ(render) + self.height + 1.0), blendType='easeOut'), Wait(0.25), self.hpText.colorInterval(0.1, Vec4(r, g, b, 0)), Func(self.__hideHitScore)) seq.start() def hideHitScore(self): if self.hpText: taskMgr.remove('PartyCogHpText' + str(self.id)) self.hpText.removeNode() self.hpText = None return def getHeadLocation(self): self.actor.getJoints(jointName='head')[0].getNetTransform(self.temp_transform) self.head_locator.setMat(self.temp_transform) return self.head_locator.getZ(self.root)
class World(DirectObject): def __init__(self): self.keyMap = {"left":0, "right":0, "forward":0, "backward":0, "shoot":0} base.win.setClearColor(Vec4(0,0,0,1)) # Post the instructions self.inst6 = addInstructions(0.95, "Mad Max's Revenge!") self.inst1 = addInstructions(0.90, "[ESC]: Quit") self.inst2 = addInstructions(0.85, "[a]: Left Turn") self.inst3 = addInstructions(0.80, "[d]: Right Turn") self.inst4 = addInstructions(0.75, "[w]: Drive Forward") self.inst4 = addInstructions(0.70, "[s]: Reverse") self.inst5 = addInstructions(0.65, "[mouse]: Fire Rocket") # Set up the environment # # This environment model contains collision meshes. If you look # in the egg file, you will see the following: # # <Collide> { Polyset keep descend } # # This tag causes the following mesh to be converted to a collision # mesh -- a mesh which is optimized for collision, not rendering. # It also keeps the original mesh, so there are now two copies --- # one optimized for rendering, one for collisions. self.environ = loader.loadModel("Assets/Models/env") #models/environment self.environ.reparentTo(render) self.environ.setPos(0,0,0) self.sky = loader.loadModel("Assets/Models/sky") #models/environment self.sky.reparentTo(render) self.sky.setPos(0,0,0) # Create the main character, player playerStartPos = Point3(8,14,1) #self.environ.find("**/start_point").getPos() enemyStartPos = Point3(-7,-8,1) #self.environ.find("**/start_point").getPos() #~ print enemyStartPos enemyStartPos.addX(1.0) enemyStartPos.addY(1.0) #~ print enemyStartPos self.player = Actor("Assets/Models/player_model", {"drive":"Assets/Models/player_drive", "fire":"Assets/Models/player_turret", "drivefire":"Assets/Models/player_both"}) self.player.reparentTo(render) self.player.setScale(0.1) self.player.setPos(playerStartPos) #~ self.playerdrive=self.player.actorInterval("drive") #~ self.playerfire=self.player.actoraaaaaaaInterval("fire") #~ self.playerdrivefire=self.player.actorInterval("drivefire") # Create the enemy, Enemy self.enemy = Actor("Assets/Models/enemy_model", {"drive":"Assets/Models/enemy_drive", "fire":"Assets/Models/enemy_turret", "drivefire":"Assets/Models/enemy_both"}) self.enemy.reparentTo(render) self.enemy.setScale(0.1) tex = loader.loadTexture("Assets/Models/cartexture1.png") self.enemy.setTexture(tex, 1) self.enemy.setPos(enemyStartPos) self.enemyrockettiming = globalClock.getFrameTime() #print self.enemy.getCurrentAnim() #print self.enemy.getCurrentAnim() #~ self.enemydrive=self.enemy.actorInterval("drive") #~ self.enemyfire=self.enemy.actorInterval("fire") #~ self.enemydrivefire=self.enemy.actorInterval("drivefire") self.music = loader.loadMusic("Assets/Sound/music.mp3") SoundInterval(self.music).loop() audio3d.attachSoundToObject(EnemyRunning, self.enemy) audio3d.attachSoundToObject(EnemyIdling, self.enemy) backward = self.enemy.getNetTransform().getMat().getRow3(1) backward.setZ(0) backward.normalize() #self.enemy.setPos(self.enemy.getPos() - backward*(50)) #Set up the lighting self.playerleftlight=self.player.attachNewNode(Spotlight("playerheadleft")) self.playerleftlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1)) self.playerleftlight.node().setLens( PerspectiveLens() ) self.playerleftlight.node().getLens().setFov( 50, 50) self.playerleftlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) ) self.playerleftlight.node().setExponent( 60.0 ) self.playerleftlight.setPos(-1, -0.1, 1.5) self.playerleftlight.setHpr(180, -10, 0) render.setLight(self.playerleftlight) self.playerrightlight=self.player.attachNewNode(Spotlight("playerheadright")) self.playerrightlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1)) self.playerrightlight.node().setLens( PerspectiveLens() ) self.playerrightlight.node().getLens().setFov( 50, 50) self.playerrightlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) ) self.playerrightlight.node().setExponent( 60.0 ) self.playerrightlight.setPos(1, -0.1, 1.5) self.playerrightlight.setHpr(180, -10, 0) render.setLight(self.playerrightlight) self.playerlightson=1 self.enemyleftlight=self.enemy.attachNewNode(Spotlight("enemyheadleft")) self.enemyleftlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1)) self.enemyleftlight.node().setLens( PerspectiveLens() ) self.enemyleftlight.node().getLens().setFov( 50, 50) self.enemyleftlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) ) self.enemyleftlight.node().setExponent( 60.0 ) self.enemyleftlight.setPos(-1, -0.1, 1.5) self.enemyleftlight.setHpr(180, -10, 0) render.setLight(self.enemyleftlight) self.enemyrightlight=self.enemy.attachNewNode(Spotlight("enemyheadright")) self.enemyrightlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1)) self.enemyrightlight.node().setLens( PerspectiveLens() ) self.enemyrightlight.node().getLens().setFov( 50, 50) self.enemyrightlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) ) self.enemyrightlight.node().setExponent( 60.0 ) self.enemyrightlight.setPos(1, -0.1, 1.5) self.enemyrightlight.setHpr(180, -10, 0) render.setLight(self.enemyrightlight) self.enemylightson=1 self.spotlight=camera.attachNewNode(PointLight("spotlight")) #self.spotlight.setPos(0, 3, 0.5) #self.spotlight.setHpr(0, 0, 0) self.spotlight.node().setColor(Vec4(1, 1, 1, 1)) #self.spotlight.node().setLens( PerspectiveLens() ) #self.spotlight.node().getLens().setFov( 180, 120) self.spotlight.node().setAttenuation( Vec3( 1, 0, 0.05 )) #self.spotlight.node().setExponent( 60.0 ) render.setLight(self.spotlight) self.playerlight=self.player.attachNewNode(PointLight("spotlight")) self.playerlight.node().setColor(Vec4(1, 1, 1, 1)) #self.spotlight.node().setLens( PerspectiveLens() ) #self.spotlight.node().getLens().setFov( 180, 120) self.playerlight.node().setAttenuation( Vec3( 1, 0, 0.05 )) #self.spotlight.node().setExponent( 60.0 ) render.setLight(self.playerlight) self.ambientlight=self.sky.attachNewNode(AmbientLight("ambientLight")) self.ambientlight.node().setColor(Vec4(1, 1, 1, 1)) self.sky.setLight(self.ambientlight) # Create a floater object. We use the "floater" as a temporary # variable in a variety of calculations. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) # Accept the control keys for movement and rotation self.accept("escape", sys.exit) self.accept("a", self.setKey, ["left",1]) self.accept("d", self.setKey, ["right",1]) self.accept("w", self.setKey, ["forward",1]) self.accept("s", self.setKey, ["backward",1]) self.accept("a-up", self.setKey, ["left",0]) self.accept("d-up", self.setKey, ["right",0]) self.accept("w-up", self.setKey, ["forward",0]) self.accept("s-up", self.setKey, ["backward",0]) self.accept("l", self.playerLights,[]) self.accept("mouse1", self.setKey, ["shoot", 1]) self.accept("mouse1-up", self.setKey, ["shoot", 0]) #self.shootRocketshootRocket taskMgr.add(self.playerMove,"moveTask") taskMgr.add(self.enemyMove,"moveTask") taskMgr.add(self.shoot,"shootTask") taskMgr.add(self.rocketCollision,"rocketCollision") # Game state variables self.prevtime = 0 self.isMoving = False self.prevShotTime = 0 self.prevEnemyMoveTime = 0 # Set up the camera base.disableMouse() base.camera.setPos(self.player.getX(),self.player.getY()+10,2) # We will detect the height of the terrain by creating a collision # ray and casting it downward toward the terrain. One ray will # start above player's head, and the other will start above the camera. # A ray may hit the terrain, or it may hit a rock or a tree. If it # hits the terrain, we can detect the height. If it hits anything # else, we rule that the move is illegal. self.cTrav = CollisionTraverser() self.playerGroundRay = CollisionRay() self.playerGroundRay.setOrigin(0,0,1000) self.playerGroundRay.setDirection(0,0,-1) self.playerGroundCol = CollisionNode('playerRay') self.playerGroundCol.addSolid(self.playerGroundRay) self.playerGroundCol.setFromCollideMask(BitMask32.bit(3)) self.playerGroundCol.setIntoCollideMask(BitMask32.allOff()) self.playerGroundColNp = self.player.attachNewNode(self.playerGroundCol) self.playerGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.playerGroundColNp, self.playerGroundHandler) self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0,0,1000) self.camGroundRay.setDirection(0,0,-1) self.camGroundCol = CollisionNode('camRay') self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(BitMask32.bit(3)) self.camGroundCol.setIntoCollideMask(BitMask32.allOff()) self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # Uncomment this line to see the collision rays #self.playerGroundColNp.show() #self.camGroundColNp.show() #Uncomment this line to show a visual representation of the #collisions occuring #self.cTrav.showCollisions(render) #Code for Enemy player self.enemyGroundRay = CollisionRay() self.enemyGroundRay.setOrigin(0,0,1000) self.enemyGroundRay.setDirection(0,0,-1) self.enemyGroundCol = CollisionNode('enemyRay') self.enemyGroundCol.addSolid(self.enemyGroundRay) self.enemyGroundCol.setFromCollideMask(BitMask32.bit(3)) self.enemyGroundCol.setIntoCollideMask(BitMask32.allOff()) self.enemyGroundColNp = self.enemy.attachNewNode(self.enemyGroundCol) self.enemyGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.enemyGroundColNp, self.enemyGroundHandler) self.cRocketHandler = CollisionHandlerQueue() self.worldEdge = CollisionInvSphere(0, 0, 0, 50) cNode = CollisionNode("worldEdge") cNode.addSolid(self.worldEdge) cNode.setFromCollideMask(BitMask32.allOff()) cNode.setIntoCollideMask(BitMask32.allOn()) self.worldEdgeNp=self.environ.attachNewNode(cNode) #self.cTrav.addCollider(self.worldEdgeNp, self.cRocketHandler) #cNP = render.attachNewNode(cNode) cNode2 = CollisionNode("wall") cNode2.addSolid(CollisionPlane(Plane(Vec3(-1,0,0), Point3(22.5,0,0)))) cNode2.addSolid(CollisionPlane(Plane(Vec3(1,0,0), Point3(-22.5,0,0)))) cNode2.addSolid(CollisionPlane(Plane(Vec3(0,-1,0), Point3(0,22.5,0)))) cNode2.addSolid(CollisionPlane(Plane(Vec3(0,1,0), Point3(0,-22.5,0)))) cNode2.setFromCollideMask(BitMask32.allOff()) cNode2.setIntoCollideMask(BitMask32.allOn()) cNP2=self.environ.attachNewNode(cNode2) self.picker = CollisionTraverser() #Make a traverser self.pq = CollisionHandlerQueue() #Make a handler #Make a collision node for our picker ray self.pickerNode = CollisionNode('mouseRay') #Attach that node to the camera since the ray will need to be positioned #relative to it self.pickerNP = camera.attachNewNode(self.pickerNode) #Everything to be picked will use bit 1. This way if we were doing other #collision we could seperate it self.pickerNode.setFromCollideMask(BitMask32.allOn()) self.pickerRay = CollisionRay() #Make our ray self.pickerNode.addSolid(self.pickerRay) #Add it to the collision node #Register the ray as something that can cause collisions self.picker.addCollider(self.pickerNP, self.pq) self.playerrocket = None self.enemyrocket = None self.enemyTurn = 0 self.enemyDestAng = 180 self.enemyHp = 3 self.playerHp = 3 #Collisions self.setupCollisions() self.playermoving = False #setup hud self.drawHud() def drawHud(self): #Player OnscreenText(text="Player Health", style=1, fg=(1,1,1,1), pos=(0.85, 0.9), align=TextNode.ALeft, scale = .08) self.playerHealthImg = OnscreenImage(image = 'Assets/Images/healthFull.png', pos = (1.05, 0, .84), scale = .12) self.playerHealthImg.setTransparency(TransparencyAttrib.MAlpha) #Enemy OnscreenText(text="Enemy Health", style=1, fg=(1,1,1,1), pos=(0.85, 0.7), align=TextNode.ALeft, scale = .08) self.enemyHealthImg = OnscreenImage(image = 'Assets/Images/healthFull.png', pos = (1.05, 0, .64), scale = .12) self.enemyHealthImg.setTransparency(TransparencyAttrib.MAlpha) def updateGui(self): #player bar if self.playerHp == 2: self.playerHealthImg.setImage('Assets/Images/healthMedium.png') self.playerHealthImg.setTransparency(TransparencyAttrib.MAlpha) elif self.playerHp == 1: self.playerHealthImg.setImage('Assets/Images/healthLow.png') self.playerHealthImg.setTransparency(TransparencyAttrib.MAlpha) #enemy bar if self.enemyHp == 2: self.enemyHealthImg.setImage('Assets/Images/healthMedium.png') self.enemyHealthImg.setTransparency(TransparencyAttrib.MAlpha) elif self.enemyHp == 1: self.enemyHealthImg.setImage('Assets/Images/healthLow.png') self.enemyHealthImg.setTransparency(TransparencyAttrib.MAlpha) def setupCollisions(self): #player sphere cPlayerSphere = CollisionSphere(Point3(0, 0, .5), 10) cPlayerNode = CollisionNode("Player") cPlayerNode.addSolid(cPlayerSphere) cPlayerNode.setFromCollideMask(BitMask32.bit(4)) cPlayerNode.setIntoCollideMask(BitMask32(20)) cPlayerNP = self.player.attachNewNode(cPlayerNode) self.cTrav.addCollider(cPlayerNP, self.playerGroundHandler) #self.cTrav.addCollider(cPlayerNP, self.cRocketHandler) #cPlayerNP.show() #enemy sphere cEnemySphere = CollisionSphere(Point3(0, 0, .5), 10) cEnemyNode = CollisionNode("Enemy") cEnemyNode.addSolid(cEnemySphere) cEnemyNode.setFromCollideMask(BitMask32.bit(4)) cEnemyNode.setIntoCollideMask(BitMask32(18)) cEnemyNP = self.enemy.attachNewNode(cEnemyNode) self.cTrav.addCollider(cEnemyNP, self.enemyGroundHandler) #self.cTrav.addCollider(cEnemyNP, self.cRocketHandler) #cEnemyNP.show() def rocketCollision(self, task): """Check for rocket collisions with players and objects""" toRemove = [] for i in range(self.cRocketHandler.getNumEntries()): entry = self.cRocketHandler.getEntry(i) #~ print entry if entry.getFromNode().getName() == "PlayerRocket" and entry.getIntoNode().getName() == "Enemy": self.enemyHp -= 1 self.updateGui() if self.enemyHp == 0: print "Victory!" OnscreenText(text="Victory!", style=2, fg=(0,1,0,1), pos=(-0.6, 0), align=TextNode.ALeft, scale = .5, shadow=(0,0,0,0)) self.playerHp += 5 #LerpFunc(end_game, fromData = 0, toData = 1, duration = 3.0, #blendType = 'noBlend', extraArgs = [], name = None) taskMgr.remove("moveTask") taskMgr.remove("shootTask") #print "GAME OVER, YOU WIN" #sys.exit(0) elif entry.getFromNode().getName() == "EnemyRocket" and entry.getIntoNode().getName() == "Player": self.playerHp -= 1 self.updateGui() if self.playerHp == 0: #~ print "GAME OVER, YOU LOSE" OnscreenText(text="Failure!", style=2, fg=(1,0,0,1), pos=(-0.6, 0), align=TextNode.ALeft, scale = .5, shadow=(0,0,0,0)) self.enemyHp += 5 taskMgr.remove("moveTask") taskMgr.remove("shootTask") #Add to remove list if entry.getFromNodePath() not in toRemove: toRemove.append(entry.getFromNodePath()) #remove for np in toRemove: if np.getNode(0).getName() == "PlayerRocket": if self.playerrocket: self.playerrocket.kill_light() #~ print "BOOM!, PLAYER ROCKET EXPLODED" BoomSound.play() RocketFire.stop() Explosion.Explosion(self.playerrocket.rocket.getPos(), render) self.playerrocket = None np.getParent().remove() else: if self.enemyrocket: self.enemyrocket.kill_light() #~ print "BOOM!, ENEMY ROCKET EXPLODED" BoomSound.play() RocketFire.stop() Explosion.Explosion(self.enemyrocket.rocket.getPos(), render) self.enemyrocket = None np.getParent().remove() self.cRocketHandler.clearEntries() return Task.cont def shootPlayerRocket(self): """Shoot a player rocket""" #Check to see if we can access the mouse. We need it to do anything else if base.mouseWatcherNode.hasMouse(): #get the mouse position mpos = base.mouseWatcherNode.getMouse() #Set the position of the ray based on the mouse position self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) #Do the actual collision pass pickerpoint=Point3(0,0,0) self.picker.traverse(render) for i in range(self.pq.getNumEntries()): entry = self.pq.getEntry(i) if entry.getFromNode().getName() == "mouseRay" and entry.getIntoNode().getName()=="terrain": pickerpoint=entry.getSurfacePoint(render) direction=pickerpoint-Point3(self.player.getX(), self.player.getY(), self.player.getZ()+0.5) #~ if self.playerrocket is None: #~ angle = math.radians(self.player.getH()) playerpos=self.player.getPos() self.playerrocket = Rocket.Rocket(Point3(playerpos.getX(), playerpos.getY(), playerpos.getZ()+0.5), direction, "PlayerRocket", render) self.playerrocket.setupCollision(self.cTrav, self.cRocketHandler) RocketFire.play() if self.player.getCurrentAnim()=="drive": self.player.play("drivefire") else: self.player.play("fire") def shootEnemyRocket(self): """Shoot a enemy rocket""" if not (self.enemyrocket) and self.enemyrockettiming <= globalClock.getFrameTime() : #~ angle = math.radians(self.enemy.getH()) #~ self.enemyrocket = Rocket.Rocket(self.enemy.getPos(), angle, "EnemyRocket", render) #~ self.enemyrocket.setupCollision(self.cTrav, self.cRocketHandler) direction = self.player.getPos() - self.enemy.getPos() enemyPos = self.enemy.getPos() self.enemyrocket = Rocket.Rocket(enemyPos + Point3(0,0,.5),direction,"EnemyRocket",render) self.enemyrocket.setupCollision(self.cTrav, self.cRocketHandler) RocketFire.play() self.enemy.play("drivefire") self.enemyrockettiming = globalClock.getFrameTime() + 2.0 #Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value def shoot(self, task): elapsed = task.time - self.prevShotTime if(self.keyMap["shoot"]!=0 and elapsed > 1): self.shootPlayerRocket() self.prevShotTime = task.time return Task.cont def playerLights(self): if self.playerlightson: self.playerleftlight.node().setColor(Vec4(0,0,0,1)) self.playerrightlight.node().setColor(Vec4(0,0,0,1)) self.playerlightson=0 else: self.playerleftlight.node().setColor(Vec4(0.75,0.75,0.75,1)) self.playerrightlight.node().setColor(Vec4(0.75,0.75,0.75,1)) self.playerlightson=1 def enemyLights(self): if self.enemylightson: self.enemyleftlight.node().setColor(Vec4(0,0,0,1)) self.enemyrightlight.node().setColor(Vec4(0,0,0,1)) self.enemylightson=0 else: self.enemyleftlight.node().setColor(Vec4(0.75,0.75,0.75,1)) self.enemyrightlight.node().setColor(Vec4(0.75,0.75,0.75,1)) self.enemylightson=1 def enemyMove(self, task): elapsed = task.time - self.prevEnemyMoveTime startpos = self.enemy.getPos() #Calculate distance to the enemy distvec = self.player.getPos() - self.enemy.getPos() distvec.setZ(0) dist = distvec.length() backward = self.enemy.getNetTransform().getMat().getRow3(1) backward.setZ(0) backward.normalize() #Drive! if self.enemy.getCurrentAnim() is None: self.enemy.loop("drive") #Find the vector from the enemy to the player, then find the angle of that vector vec = self.enemy.getPos() - self.player.getPos() angle = math.degrees(math.atan2(vec.getX(), vec.getY())) #Find the angle left to turn according to the enemy's current angle angleToPlayer = (-self.enemy.getH() - angle) % 360 #Fire rocket if within 60 degree arc of player #~ print angleToPlayer if angleToPlayer < 30 or angleToPlayer > 330: self.shootEnemyRocket() #AI control code starts here #enemyTurn is zero for heading straight, -1 to turn full left, +1 to turn full right #Turning rate is currently maxed at 100 degrees per second #drivedir is for forward (1) or backward (-1) #Wall avoidance stuff enemyTurn=0 myh=self.player.getH()%360 print myh if abs(self.enemy.getPos().getX())>19 or abs(self.enemy.getPos().getX())>19: drivedir=-1.0 else: drivedir=1.0 if self.playerrocket: playerpos=self.player.getPos() if playerpos.getX()>12.5 and (myh<90 or myh>270): self.enemyTurn = -(0.5+0.05*(self.enemy.getX()-12.5))*sign(myh-180) print 1 elif playerpos.getX()<12.5 and not (myh<90 or myh>270): self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getX()))*sign(myh-180) print 2 elif playerpos.getY()>12.5 and myh<180: self.enemyTurn = -(0.5+0.05*(self.enemy.getY()-12.5))*sign(myh-90) print 3 elif playerpos.getY()<12.5 and myh>180: self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getY()))*sign(myh-270) print 4 elif self.enemy.getPos().getX()>12.5 and (myh<90 or myh>270): self.enemyTurn = -(0.5+0.05*(self.enemy.getX()-12.5))*sign(myh-180) print 5 elif self.enemy.getPos().getX()<-12.5 and not (myh<90 or myh>270): self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getX()))*sign(myh-180) print 6 elif self.enemy.getPos().getY()>12.5 and myh<180: self.enemyTurn = -(0.5+0.05*(self.enemy.getY()-12.5))*sign(myh-90) print 7 elif self.enemy.getPos().getY()<-12.5 and myh>180: self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getY()))*sign(myh-270) print 8 elif not(math.fabs(self.enemyDestAng - angleToPlayer) > 3 and math.fabs(self.enemyDestAng - angleToPlayer) < 357): print 9 self.enemyTurn = 0 else: print 10 if dist > 5: self.enemyDestAng = 0 if angleToPlayer > 1 and angleToPlayer <= 180: #Turn left self.enemyTurn = -0.5 elif angleToPlayer > 180 and angleToPlayer < 359: #Turn right self.enemyTurn = 0.5 elif dist < 5: self.enemyDestAng = 180 if angleToPlayer >= 0 and angleToPlayer < 179: #Turn left self.enemyTurn = 0.5 elif angleToPlayer > 181 and angleToPlayer < 360: #Turn right self.enemyTurn = -0.5 #Replace later #drivedir=1.0 #End of AI code #Enemy always tries to move forward, regardless of where the player is self.enemy.setPos(self.enemy.getPos() - backward*(drivedir*elapsed*5)) self.enemy.setH(self.enemy.getH() - elapsed *100.0*self.enemyTurn) EnemyRunning.play() self.cTrav.traverse(render) entries = [] terrain = [] for i in range(self.enemyGroundHandler.getNumEntries()): entry = self.enemyGroundHandler.getEntry(i) if entry.getFromNode().getName() == "enemyRay": terrain.append(entry) elif entry.getFromNode().getName() == "Enemy" and entry.getIntoNode().getName() != "terrain": entries.append(entry) terrain.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries)>0): self.enemy.setPos(startpos) if (len(terrain)>0) and (terrain[0].getIntoNode().getName() == "terrain"): self.enemy.setZ(terrain[0].getSurfacePoint(render).getZ()+.5) else: self.enemy.setPos(startpos) # Store the task time and continue. self.prevEnemyMoveTime = task.time return Task.cont # Accepts arrow keys to move either the player or the menu cursor, # Also deals with grid checking and collision detection def playerMove(self, task): elapsed = task.time - self.prevtime base.camera.lookAt(self.player) camright = base.camera.getNetTransform().getMat().getRow3(0) camright.normalize() # save player's initial position so that we can restore it, # in case he falls off the map or runs into something. startpos = self.player.getPos() # If a move-key is pressed, move player in the specified direction. if ((self.keyMap["left"]!=0) & (self.keyMap["forward"]!=0)): self.player.setH(self.player.getH() + elapsed*50) Idling.stop() Running.play() self.playermoving = True elif((self.keyMap["left"]!=0) & (self.keyMap["backward"]!=0)): self.player.setH(self.player.getH() - elapsed*50) Idling.stop() Running.play() self.playermoving = True if ((self.keyMap["right"]!=0) & (self.keyMap["forward"]!=0)): self.player.setH(self.player.getH() - elapsed*50) Idling.stop() Running.play() self.playermoving = True elif ((self.keyMap["right"]!=0) & (self.keyMap["backward"]!=0)): self.player.setH(self.player.getH() + elapsed*50) Idling.stop() Running.play() self.playermoving = True if (self.keyMap["forward"]!=0): backward = self.player.getNetTransform().getMat().getRow3(1) backward.setZ(0) backward.normalize() self.player.setPos(self.player.getPos() - backward*(elapsed*5)) Running.play() Idling.stop() self.playermoving = True if (self.keyMap["backward"]!=0): backward = self.player.getNetTransform().getMat().getRow3(1) backward.setZ(0) backward.normalize() self.player.setPos(self.player.getPos() + backward*(elapsed*5)) Idling.stop() Running.play() self.playermoving = True if (self.keyMap["backward"]==0 and self.keyMap["forward"]==0 and self.keyMap["left"]==0 and self.keyMap["right"]==0): Running.stop() Idling.play() self.playermoving = False if self.player.getCurrentAnim()=="drive": self.player.stop() #print "STOP MOVING" #DRIVE! if self.player.getCurrentAnim() is None and self.playermoving: self.player.loop("drive") #print "DRIVE ON!" dist = 10.0 angle = math.radians(self.player.getH()) + math.pi dx = dist * math.sin(angle) dy = dist * -math.cos(angle) dest = Point3(self.player.getX() + dx, self.player.getY() + dy, self.player.getZ()+1) base.camera.setPos(dest) # If player is moving, loop the run animation. # If he is standing still, stop the animation. if (self.keyMap["forward"]!=0) or (self.keyMap["left"]!=0) or (self.keyMap["right"]!=0): if self.isMoving is False: #self.player.loop("run") self.isMoving = True else: if self.isMoving: #self.player.stop() #self.player.pose("walk",5) self.isMoving = False # If the camera is too far from player, move it closer. # If the camera is too close to player, move it farther. camvec = self.player.getPos() - base.camera.getPos() camvec.setZ(0) camdist = camvec.length() camvec.normalize() if (camdist > 20.0): base.camera.setPos(base.camera.getPos() + camvec*(camdist-20)) camdist = 20.0 if (camdist < 10.0): base.camera.setPos(base.camera.getPos() - camvec*(10-camdist)) camdist = 10.0 # Now check for collisions. self.cTrav.traverse(render) # Adjust player's Z coordinate. If player's ray hit terrain, # update his Z. If it hit anything else, or didn't hit anything, put # him back where he was last frame. terrain = [] entries = [] for i in range(self.playerGroundHandler.getNumEntries()): entry = self.playerGroundHandler.getEntry(i) if entry.getFromNode().getName() == "playerRay": terrain.append(entry) elif entry.getFromNode().getName() == "Player" and entry.getIntoNode().getName() != "terrain": entries.append(entry) terrain.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries)>0): self.player.setPos(startpos) elif (len(terrain)>0) and (terrain[0].getIntoNode().getName() == "terrain"): self.player.setZ(terrain[0].getSurfacePoint(render).getZ()+.5) else: self.player.setPos(startpos) # Keep the camera at one foot above the terrain, # or two feet above player, whichever is greater. entries = [] for i in range(self.camGroundHandler.getNumEntries()): entry = self.camGroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"): base.camera.setZ(entries[0].getSurfacePoint(render).getZ()+ 1.5) if (base.camera.getZ() < self.player.getZ() + 2.5): base.camera.setZ(self.player.getZ() + 2.5) # The camera should look in player's direction, # but it should also try to stay horizontal, so look at # a floater which hovers above player's head. self.floater.setPos(self.player.getPos()) self.floater.setZ(self.floater.getZ()+1) base.camera.lookAt(self.floater) # Store the task time and continue. self.prevtime = task.time return Task.cont
class thirdPerson(DirectObject): def __init__(self, parserClass, mainClass, mapLoaderClass, modelLoaderClass): self.switchState = False #self.t = Timer() self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0} self.ralph = Actor( "data/models/units/ralph/ralph", { "run": "data/models/units/ralph/ralph-run", "walk": "data/models/units/ralph/ralph-walk" }) self.ralph.reparentTo(render) # self.ralph.setPos(42, 30, 0) self.ralph.setPos(6, 10, 0) self.ralph.setScale(0.1) self.accept("escape", sys.exit) self.accept("arrow_left", self.setKey, ["left", 1]) self.accept("arrow_left-up", self.setKey, ["left", 0]) self.accept("arrow_right", self.setKey, ["right", 1]) self.accept("arrow_right-up", self.setKey, ["right", 0]) self.accept("arrow_up", self.setKey, ["forward", 1]) self.accept("arrow_up-up", self.setKey, ["forward", 0]) self.accept("arrow_down", self.setKey, ["backward", 1]) self.accept("arrow_down-up", self.setKey, ["backward", 0]) self.isMoving = False self.cTrav = CollisionTraverser() self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0, 0, 1000) self.ralphGroundRay.setDirection(0, 0, -1) self.ralphGroundCol = CollisionNode('ralphRay') self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0)) self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) #self.ralphGroundCol.show() base.cam.reparentTo(self.ralph) base.cam.setPos(0, 9, 7) self.floater2 = NodePath(PandaNode("floater2")) self.floater2.reparentTo(self.ralph) self.floater2.setZ(self.floater2.getZ() + 6) base.cam.lookAt(self.floater2) # Uncomment this line to see the collision rays # self.ralphGroundColNp.show() # self.camGroundColNp.show() #Uncomment this line to show a visual representation of the #collisions occuring # self.cTrav.showCollisions(render) self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) taskMgr.add(self.move, "movingTask", extraArgs=[ mainClass, parserClass, mapLoaderClass, modelLoaderClass ]) #Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value def move(self, mainClass, parserClass, mapLoaderClass, modelLoaderClass): # Get the time elapsed since last frame. We need this # for framerate-independent movement. elapsed = globalClock.getDt() # save ralph's initial position so that we can restore it, # in case he falls off the map or runs into something. startpos = self.ralph.getPos() # If a move-key is pressed, move ralph in the specified direction. if (self.keyMap["left"] != 0): self.ralph.setH(self.ralph.getH() + elapsed * 300) if (self.keyMap["right"] != 0): self.ralph.setH(self.ralph.getH() - elapsed * 300) if (self.keyMap["forward"] != 0): self.ralph.setY(self.ralph, -(elapsed * 50)) #25)) if (self.keyMap["backward"] != 0): self.ralph.setY(self.ralph, +(elapsed * 20)) if (self.keyMap["forward"] != 0) or (self.keyMap["left"] != 0) or (self.keyMap["right"] != 0): if self.isMoving is False: self.ralph.loop("run") self.isMoving = True elif (self.keyMap["backward"] != 0): if self.isMoving is False: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False else: if self.isMoving: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False # Now check for collisions. self.cTrav.traverse(render) # Adjust ralph's Z coordinate. If ralph's ray hit terrain, # update his Z. If it hit anything else, or didn't hit anything, put # him back where he was last frame. entries = [] for i in range(self.ralphGroundHandler.getNumEntries()): entry = self.ralphGroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x, y: cmp( y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries) > 0) and (entries[0].getIntoNode().getName()[0:4] == "tile"): self.ralph.setZ(entries[0].getSurfacePoint(render).getZ()) elif (len(entries) > 0) and (entries[0].getIntoNode().getName()[0:5] == "solid"): self.ralph.setPos(startpos) x = int(entries[0].getIntoNode().getName() [len(entries[0].getIntoNode().getName()) - 6:len(entries[0].getIntoNode().getName()) - 4]) y = int(entries[0].getIntoNode().getName() [len(entries[0].getIntoNode().getName()) - 2:]) if (mapLoaderClass.tileArray[y][x].drillTime != None): mainClass.changeTile(mapLoaderClass.tileArray[y][x], 0, parserClass, modelLoaderClass, mapLoaderClass) else: self.ralph.setPos(startpos) self.ralph.setP(0) return Task.cont
class DistributedFort(DistributedBattleAvatar.DistributedBattleAvatar): notify = directNotify.newCategory('DistributedFort') endingR = 60 zeroHpR = 90 HpTextGenerator = TextNode('HpTextGenerator') HpTextEnabled = 1 def __init__(self, cr): DistributedBattleAvatar.DistributedBattleAvatar.__init__(self, cr) self.island = None self.name = PLocalizer.NavyFortName self.level = 1 self.meterHp = self.maxHp self.hpMeter = None self.meterMp = 0 self.maxMojo = 0 self.currentAttack = 0 self.drawbridges = [] self.smoke = None self.islandRequest = None self.islandDependedObjectsSetup = 0 self.hpTextNodes = [] self.hpTextIvals = [] def delete(self): DistributedBattleAvatar.DistributedBattleAvatar.delete(self) if self.smoke: self.smoke.destroy() self.smoke = None if self.hpMeter: self.hpMeter.destroy() self.hpMeter = None if self.islandRequest: self.cr.relatedObjectMgr.abortRequest(self.islandRequest) def setIslandId(self, islandId): self.islandId = islandId def getNameText(self): return '' def setObjKey(self, objKey): self.objKey = objKey def loadModel(self): DistributedBattleAvatar.DistributedBattleAvatar.loadModel(self) def createGameFSM(self): self.gameFSM = BattleAvatarGameFSM.BattleAvatarGameFSM(self) def announceGenerate(self): self.notify.debug('announceGenerate') self.battleTubeRadius = 50.0 self.battleTubeHeight = 100.0 DistributedBattleAvatar.DistributedBattleAvatar.announceGenerate(self) self.cr.relatedObjectMgr.abortRequest(self.islandRequest) self.islandRequest = self.cr.relatedObjectMgr.requestObjects( [self.islandId], eachCallback=self._DistributedFort__gotIsland) def disable(self): DistributedBattleAvatar.DistributedBattleAvatar.disable(self) self.island = None self.fortNode = None self.islandDependedObjectsSetup = 0 def _DistributedFort__gotIsland(self, island): self.notify.debug('__gotIsland %s' % island) self.islandRequest = None if island.lastZoneLevel == 0: self._DistributedFort__setupIslandDependentObjects() else: self.cr.distributedDistrict.worldCreator.registerPostLoadCall( self._DistributedFort__setupIslandDependentObjects) def _DistributedFort__setupIslandDependentObjects(self): self.notify.debug('setupIslandDependentObjects') if not self.areDrawbridgesLoaded(): self.cr.distributedDistrict.worldCreator.registerPostLoadCall( self._DistributedFort__setupIslandDependentObjects) self.notify.debug( 'no drawbridges yet, registering another post load call') return None self.notify.debug('drawbridges are in render') self.setupCollisions() self.setupDrawbridges() self.islandDependedObjectsSetup = 1 def readyToGo(self): if self.islandDependedObjectsSetup == 1: pass return self.isGenerated() def smoothPosition(self): DistributedReputationAvatar.smoothPosition(self) def setupCollisions(self): self.notify.debug('setupCollisions') self.island = base.cr.doId2do.get(self.islandId) if not self.island: self.notify.warning("Couldn't find island %d" % self.islandId) return None self.fortNode = self.island.find('**/=uid=%s' % self.objKey) if self.fortNode == self.fortNode.notFound(): self.notify.warning("Couldn't find fort uid %s" % self.objKey) return None allColls = self.fortNode.findAllMatches('**/*collision*') if allColls.getNumPaths() == 0: allColls = self.fortNode.findAllMatches('**/*Col_*') oldBitMask = allColls.getCollideMask() newBitMask = oldBitMask | PiratesGlobals.TargetBitmask allColls.setCollideMask(newBitMask) for index in xrange(allColls.getNumPaths()): nodePath = allColls[index] nodePath.setTag('objType', str(PiratesGlobals.COLL_FORT)) nodePath.setTag('fortId', str(self.doId)) def getNameText(self): pass def gotHitByProjectile(self, hitObject, entry, skillId, ammoSkillId): fn = entry.getFromNodePath() fortId = fn.getNetTag('fortId') if fortId: fortId = int(fortId) if fortId == self.doId: return None if fortId and fortId > 0: return None self.sendHitByProjectile(skillId, ammoSkillId) def sendHitByProjectile(self, skillId, ammoSkillId): if self.hp > 0: self.sendUpdate('hitByProjectile', [skillId, ammoSkillId]) def getLevel(self): return self.level def setupHpMeter(self): if self.hpMeter: return None zAdj = 50 self.smokeZAdj = zAdj self.fortPart = self.fortNode.find('**/top_interior_wall_collision') if self.fortPart.isEmpty(): self.fortPart = self.fortNode.find('**/col_TopFloor1') if self.fortPart.isEmpty(): self.fortPart = self.fortNode.find('**/pPlane4') zAdj = 150 self.smokeZAdj = 100 if self.fortPart.isEmpty(): self.fortPart = self.fortNode.find('**/*tower*') if self.fortPart.isEmpty(): self.fortPart = self.fortNode.find('**/*buttress*') if self.fortPart.isEmpty(): self.fortPart = self.fortNode.find('**/*floor*') fortPartBounds = self.fortPart.getBounds() self.hpAnchor = NodePath('hpAnchor') self.hpAnchor.setPos(fortPartBounds.getApproxCenter()) self.hpAnchor.setZ(self.hpAnchor.getZ() + zAdj) self.hpAnchor.reparentTo(self.fortNode) self.hpMeter = HpMeter.HpMeter(fadeOut=0, parent=self.hpAnchor, originAtMidPt=True) self.hpMeter.setScale(200) self.hpMeter.setBin('fixed', 130) self.hpMeter.setDepthWrite(False) myEffect = BillboardEffect.make(Vec3(0, 0, 1), True, False, 150, NodePath(), Point3(0, 0, 0)) self.hpMeter.node().setEffect(myEffect) self.hpMeter.update(self.hp, self.maxHp) self.hideFortHpMeter() def setHp(self, hp, quietly=0): DistributedBattleAvatar.DistributedBattleAvatar.setHp( self, hp, quietly) if self.isGenerated(): if not self.hpMeter: self.setupHpMeter() self.hpMeter.update(self.hp, self.maxHp) if self.drawbridges: self.updateDrawbridges() if self.hp < self.maxHp: self.updateSmoke() if self.hp <= 0: self.hpMeter.hide() def takeDamage(self, hpLost, pos, bonus=0): DistributedBattleAvatar.DistributedBattleAvatar.takeDamage( self, hpLost, pos, bonus) def died(self): if self.cr and self.cr.wantSpecialEffects != 0: shipDebrisEffect = ShipDebris.getEffect() if shipDebrisEffect and not self.hpAnchor.isEmpty(): shipDebrisEffect.reparentTo(self.hpAnchor) shipDebrisEffect.setZ(shipDebrisEffect.getZ() - self.smokeZAdj) shipDebrisEffect.endPlaneZ = 0 shipDebrisEffect.play() def hideFortHpMeter(self): if self.hpMeter: self.hpMeter.hide() def showFortHpMeter(self): if self.hpMeter: self.hpMeter.show() def getInventory(self): pass def setupDrawbridgeCollisions(self, dbName, drawbridge): curNodePath = drawbridge oldBitMask = curNodePath.getCollideMask() newBitMask = oldBitMask | PiratesGlobals.TargetBitmask newBitMask = newBitMask & ~(PiratesGlobals.ShipCollideBitmask) curNodePath.setCollideMask(newBitMask) curNodePath.setTag('objType', str(PiratesGlobals.COLL_FORT)) curNodePath.setTag('fortId', str(self.doId)) shipCollider = drawbridge.find('**/*shipcollide*;+s') if shipCollider.isEmpty(): self.notify.warning( 'setupDrawbridgeCollisions could not find ship collider for %s' % dbName) tempStr = 'drawbridge_pier' lenTemp = len(tempStr) suffix = dbName[lenTemp:] otherParts = ('crane_island', 'crane1_island', 'drawbridge_fort', 'crane_fort', 'crane1_fort', 'drawbridge_fort') for otherPart in otherParts: nodeName = otherPart + suffix curNodePath = render.find('**/%s' % nodeName) if curNodePath.isEmpty(): self.notify.warning( "setupDrawbridgeCollisions() couldn't find nodepath %s" % nodeName) continue oldBitMask = curNodePath.getCollideMask() newBitMask = oldBitMask | PiratesGlobals.TargetBitmask curNodePath.setCollideMask(newBitMask) curNodePath.setTag('objType', str(PiratesGlobals.COLL_FORT)) curNodePath.setTag('fortId', str(self.doId)) def setupDrawbridges(self): if TreasureMapBlackPearlGlobals.DrawbridgeDict.has_key(self.objKey): dbTuple = TreasureMapBlackPearlGlobals.DrawbridgeDict[self.objKey] for dbName in dbTuple: drawbridge = render.find('**/%s' % dbName) if drawbridge.isEmpty(): self.notify.warning("couldn't find drawbridge %s" % dbName) continue self.drawbridges.append(drawbridge) self.setupDrawbridgeCollisions(dbName, drawbridge) def areDrawbridgesLoaded(self): retval = True if TreasureMapBlackPearlGlobals.DrawbridgeDict.has_key(self.objKey): dbTuple = TreasureMapBlackPearlGlobals.DrawbridgeDict[self.objKey] for dbName in dbTuple: drawbridge = render.find('**/%s' % dbName) if drawbridge.isEmpty(): retval = False continue return retval def updateDrawbridges(self): for drawbridge in self.drawbridges: if self.hp <= 0: if base.options.getSpecialEffectsSetting( ) >= base.options.SpecialEffectsHigh: smokeEffect = SmokeExplosion.getEffect() if smokeEffect: smokeEffect.reparentTo(render) smokeEffect.setPos(drawbridge, 0, 0, 0) smokeEffect.spriteScale = 1.0 smokeEffect.play() posHprIval = LerpPosHprInterval( drawbridge, 1.0, Vec3(drawbridge.getX(), drawbridge.getY(), drawbridge.getZ() - 130.0), Vec3(drawbridge.getH(), drawbridge.getP() - 360.0, drawbridge.getR() + 15)) posHprIval.start() continue def debugMissing(self): wi = render.find('**/whole_island') allChildren = wi.getChildren() for index in xrange(allChildren.getNumPaths()): np = allChildren.getPath(index) if not np.isHidden(): print np np.hide() break continue def setDrawbridgesR(self, r): for drawbridge in self.drawbridges: drawbridge.setR(r) def setDrawbridgesLerpR(self, r): angle = 0 if r == 1: angle = -70 for drawbridge in self.drawbridges: if drawbridge.getR() == angle: return None ival = LerpHprInterval( drawbridge, 4.0, Vec3(drawbridge.getH(), drawbridge.getP(), angle)) ival.start() def hideDrawbridges(self): for drawbridge in self.drawbridges: drawbridge.hide() def updateSmoke(self): if self.hp < self.maxHp: self.startSmoke() if self.smoke: density = 1 - float(self.hp) / self.maxHp self.smoke.setDensity(density) def startSmoke(self): if not self.smoke: self.smoke = BlackSmoke.getEffect() if self.smoke: self.smoke.reparentTo(self.hpAnchor) self.smoke.setZ(-(self.smokeZAdj)) self.smoke.startLoop() def setupRadarGui(self): self.hpAnchor.setTag('avId', str(self.doId)) self.setTeam(PiratesGlobals.NAVY_TEAM) def initializeBattleCollisions(self): pass def setLevel(self, level): self.level = level def printExpText(self, totalExp, colorSetting, basicPenalty, crewBonus, doubleXPBonus, holidayBonus, potionBonus): taskMgr.doMethodLater( 0.5, self.showHpText, self.taskName('printExp'), [ totalExp, 4, 6.0, 1.0, basicPenalty, crewBonus, doubleXPBonus, holidayBonus, potionBonus ]) def showHpText(self, number, bonus=0, duration=2.0, scale=1.0, basicPenalty=0, crewBonus=0, doubleXPBonus=0, holidayBonus=0, potionBonus=0): if self.isEmpty(): return None distance = camera.getDistance(self) scale *= max(1.0, distance / 50.0) height = self.hpAnchor.getZ() + 25.0 startPos = Point3(0, 0, height / 4) destPos = Point3(0, 0, height / 2) newEffect = None def cleanup(): if newEffect in self.textEffects: self.textEffects.remove(newEffect) mods = {} if basicPenalty > 0: mods[TextEffect.MOD_BASICPENALTY] = basicPenalty if crewBonus > 0: mods[TextEffect.MOD_CREWBONUS] = crewBonus if doubleXPBonus > 0: mods[TextEffect.MOD_2XPBONUS] = doubleXPBonus if holidayBonus > 0: mods[TextEffect.MOD_HOLIDAYBONUS] = holidayBonus newEffect = TextEffect.genTextEffect(self.hpAnchor, self.HpTextGenerator, number, bonus, self.isNpc, cleanup, startPos, destPos, scale, modifiers=mods) if newEffect: self.textEffects.append(newEffect)
class World(DirectObject): def __init__(self): base.win.setClearColor(Vec4(0, 0, 0, 1)) # enable physics (and particle) engine self.throwMode = False self.freelook = False self.score = OnscreenText('0', pos=(-1.32, 0.9), fg=(1, 1, 1, 1), bg=(0, 0, 0, 0.5), scale=0.1, align=TextNode.ALeft) # Load the environment in which Eve will walk. Set its parent # to the render variable so that it is a top-lplayerl node. self.env = loader.loadModel('models/world/world.egg.pz') self.env.reparentTo(render) self.env.setPos(0, 0, 0) self.createCollisionHandlers() # Create an Actor instance for Eve. We also specify the animation # models that we want to use as a dictionary, where we can use to # keys to refer to the animations later on. The start point of Eve # is hardcoded in the world model somewhere, so we look that up. self.player = Eve('Eve', self, self.env.find('**/start_point').getPos()) #self.player.nodePath.setZ(self.player.nodePath.getZ() + 10) self.player.nodePath.reparentTo(render) # Create a floater object that always floats 2 units above Eve. # We make sure that it is attached to Eve by reparenting it to # Eve's object instance. self.floater = NodePath(PandaNode('floater')) self.floater.reparentTo(self.player.nodePath) self.floater.setZ(self.floater.getZ() + 2) # load baseball self.baseball = Baseball('baseball', self, self.player.nodePath.getPos()) self.baseball.nodePath.reparentTo(render) self.player.pickUpItem(self.baseball) # Load the panda bear self.panda = Panda('panda', self, self.player.nodePath.getPos()) self.panda.nodePath.reparentTo(render) # Disable controlling the camera using the mouse. Note that this does # not disable the mouse completely, it merely disables the camera # movement by mouse. base.disableMouse() self.hideMouseCursor() # Set the initial position for the camera as X, Y and Z values. base.camera.setPos(self.player.nodePath.getX(), self.player.nodePath.getY() + 10, 2) # Disable modifier button compound events. base.mouseWatcherNode.setModifierButtons(ModifierButtons()) base.buttonThrowers[0].node().setModifierButtons(ModifierButtons()) # Register any control callbacks. self.accept('escape', sys.exit) self.accept('d', self.dropItem) self.accept('f', self.toggleFullscreen) self.accept('space', self.enterThrowMode) self.accept('space-up', self.leaveThrowMode) # Also make sure that we can, at any time, request the state (pressed # or not) for these keys. self.keys = keys.KeyStateManager() self.keys.registerKeys({ 'arrow_left': 'left', 'arrow_right': 'right', 'arrow_up': 'forward', 'arrow_down': 'backward', 'shift': 'shift', 'r': 'reset' }) self.mouse = mouse.MousePointerManager(0) # Schedule the move method to be executed in the game's main loop. taskMgr.add(self.update, 'update') def hideMouseCursor(self): props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) def toggleFullscreen(self): props = WindowProperties() props.setFullscreen(not base.win.getProperties().getFullscreen()) base.win.requestProperties(props) def enableFreelook(self): self.freelook = True # Make sure we reset the MouseMovementManager's last known mouse position, # so we don't get a huge delta on the first attempt. self.mouse.reset() base.camera.setP(0) def disableFreelook(self): self.freelook = False def createCollisionHandlers(self): # Create a new collision traverser instance. We will use this to determine # if any collisions occurred after performing movement. self.cTrav = CollisionTraverser() camGroundRay = CollisionRay() camGroundRay.setOrigin(0, 0, 1000) camGroundRay.setDirection(0, 0, -1) camGroundCol = CollisionNode('camRay') camGroundCol.addSolid(camGroundRay) camGroundCol.setFromCollideMask(BitMask32.bit(0)) camGroundCol.setIntoCollideMask(BitMask32.allOff()) camGroundColNp = base.camera.attachNewNode(camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(camGroundColNp, self.camGroundHandler) # register the collision pusher self.pusher = CollisionHandlerPusher() # register collision event pattern names self.pusher.addInPattern('col-%fn-into') def update(self, task): # get the time passed since the last frame timePassed = globalClock.getDt() # update player self.player.forceMove(timePassed) self.panda.forceMove(timePassed) # Do collision detection. This iterates all the collider nodes self.cTrav.traverse(render) # check if player's move is valid self.player.validateMove() self.panda.validateMove() # Set the initial position for the camera as X, Y and Z values. base.camera.setPos(self.player.nodePath.getPos()) if self.throwMode: # Position the camera a bit above the ground. base.camera.setZ(base.camera, 1.5) if self.freelook: mx, my = self.mouse.getDelta() h = -mx * 0.1 p = -my * 0.1 base.camera.setHpr(base.camera, h, p, 0) self.player.nodePath.setH(self.player.nodePath, h) else: # Set the heading, pitch and roll of the camera. base.camera.setHpr(self.player.nodePath.getHpr()) else: # Set the heading, pitch and roll of the camera. base.camera.setHpr(self.player.nodePath.getHpr()) # Position the camera somewhat behind the player. base.camera.setY(base.camera, 10) # Make sure the camera is above the ground. camGroundEntry = self.getGroundEntry(self.camGroundHandler) if camGroundEntry is not None and camGroundEntry.getIntoNode( ).getName() == 'terrain': base.camera.setZ( camGroundEntry.getSurfacePoint(render).getZ() + 1.5) # Let the camera look at the floater object above Eve. base.camera.lookAt(self.floater) return Task.cont def dropItem(self): self.player.dropItem() def getGroundEntry(self, collisionHandler): # Put all the collision entries into a Python list so we can sort it, # properly. entries = [] for i in range(collisionHandler.getNumEntries()): entries.append(collisionHandler.getEntry(i)) # Sort the list by the collision points' Z values, making sure the # highest value ends up at the front of the list. entries.sort(lambda x, y: cmp( y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if len(entries) > 0: return entries[0] else: return None def enterThrowMode(self): self.throwMode = True self.player.enterStrafeMode() self.enableFreelook() def leaveThrowMode(self): self.throwMode = False self.player.leaveStrafeMode() self.disableFreelook()
class Entity(DirectObject, object): def __init__(self, model = None): self.prime = None if model != None: self.set_model(model) def get_model(self): return self.prime def set_model(self, model): if model != None: if isinstance(model, PandaNode): self.prime = NodePath(model) elif isinstance(model, NodePath): self.prime = model else: if Filename(model).exists(): self.model = Filename(model).getBasenameWoExtension() path = model else: if isinstance(model, Filename): self.model = model.getBasenameWoExtension() path = model.getFullpath() else: path = APP_PATH + model print "path: ", path if Filename(path).exists(): pass elif Filename(path + ".bam").exists(): path += ".bam" elif Filename(path + ".bam.pz").exists(): path += ".bam.pz" elif Filename(path + ".egg").exists(): path += ".egg" elif Filename(path + ".egg.pz").exists(): path += ".egg.pz" elif Filename(path + ".x").exists(): path += ".x" else: print ":object(error): can't find model", model, "!" # Probably shouldn't exit because of this sys.exit(1) self.model = model self.prime = base.loader.loadModel(path) if self.prime == None: print ":object(error): can't load model", model, "!" # Probably shouldn't exit because of this sys.exit(1) def getX(self): return self.prime.getX(base.render) def getY(self): return self.prime.getY(base.render) def getZ(self): return self.prime.getZ(base.render) def getH(self): return self.prime.getH(base.render) def getP(self): return self.prime.getP(base.render) def getR(self): return self.prime.getR(base.render) def getSx(self): return self.prime.getSx(base.render) def getSy(self): return self.prime.getSy(base.render) def getSz(self): return self.prime.getSz(base.render) def getPos(self): return self.prime.getPos(base.render) def getHpr(self): return self.prime.getHpr(base.render) def getScale(self): return self.prime.getScale(base.render) def getCollideMask(self): return self.prime.getCollideMask() def getTransparency(self): return self.prime.getTransparency() def getTwoSided(self): return self.prime.getTwoSided() def getParent(self): return self.prime.getParent() def setX(self, *v): self.prime.setX(*v) def setY(self, *v): self.prime.setY(*v) def setZ(self, *v): self.prime.setZ(*v) def setH(self, *v): self.prime.setH(*v) def setP(self, *v): self.prime.setP(*v) def setR(self, *v): self.prime.setR(*v) def setSx(self, *v): self.prime.setSx(*v) def setSy(self, *v): self.prime.setSy(*v) def setSz(self, *v): self.prime.setSz(*v) def setPos(self, *v): self.prime.setPos(*v) def setHpr(self, *v): self.prime.setHpr(*v) def setScale(self, *v): self.prime.setScale(*v) def setCollideMask(self, *v): self.prime.setCollideMask(*v) def setTransparency(self, *v): self.prime.setTransparency(*v) def setTwoSided(self, *v): self.prime.setTwoSided(*v) def removeNode(self): self.prime.removeNode() def reparentTo(self, parent): if isinstance(parent, Entity): parent = parent.prime if isinstance(parent, str): if parent.startswith("render/"): parent = parent[7:] tv = parent parent = base.render.find(tv) if parent == NodePath(): parent = base.render.find("**/" + tv) if parent != NodePath() and parent != None: self.prime.reparentTo(parent) def wrtReparentTo(self, parent): if isinstance(parent, Entity): parent = parent.prime if isinstance(parent, str): if parent.startswith("render/"): parent = parent[7:] tv = parent parent = base.render.find(tv) if parent == NodePath(): parent = base.render.find("**/" + tv) if parent != NodePath(): self.prime.reparentTo(parent) def attachTo(self, parent): """This attaches the object to another object/nodepath. The caller object stays at the same place, with the same scale and rotation, but they become relative to the other object/nodepath. This is useful with for example a character that steps onto a moving ship or so.""" if isinstance(parent, Entity): parent = parent.prime if isinstance(parent, str): if(parent.startswith("render/")): parent = parent[7:] tv = parent parent = base.render.find(tv) if(parent == NodePath()): parent = base.render.find("**/" + tv) if(parent != NodePath()): self.prime.setPos(self.prime.getPos(parent)) self.prime.setHpr(self.prime.getHpr(parent)) self.prime.setScale(self.prime.getScale(parent)) self.prime.reparentTo(parent) def hide(self): self.prime.hide() def show(self): self.prime.show() def __del__(self): try: if isinstance(self.prime, NodePath): self.prime.removeNode() except AttributeError: pass def __getstate__(self): return [self.model, self.getX(), self.getY(), self.getZ(), self.getH(), self.getP(), self.getR(), self.getSx(), self.getSy(), self.getSz(), self.getCollideMask().getWord(), self.getTransparency(), self.getTwoSided(), str(self.getParent())] def __setstate__(self, p): if len(p) < 14: print ":object(error): This state is not compatible with this version!" sys.exit(1) self.setModel(p[0]) self.setX(p[1]) self.setY(p[2]) self.setZ(p[3]) self.setH(p[4]) self.setP(p[5]) self.setR(p[6]) self.setSx(p[7]) self.setSy(p[8]) self.setSz(p[9]) self.setCollideMask(BitMask32(p[10])) self.setTransparency(p[11]) self.setTwoSided(p[12]) self.reparentTo(p[13])