def initCollisions(self): self.collNodePath.setCollideMask(BitMask32(0)) self.collNodePath.node().setFromCollideMask(CIGlobals.WallBitmask) pusher = CollisionHandlerPusher() pusher.setInPattern('%in') pusher.addCollider(self.collNodePath, self) base.cTrav.addCollider(self.collNodePath, pusher)
def addPlayer(self, name): self.players[name] = PlayerLogic(name) self.players[name].nodePath = self.nodePath.attachNewNode(PandaNode(name)) collisionNodePath = self.players[name].nodePath.attachNewNode(CollisionNode("pusherCollision")) collisionNodePath.node().addSolid(CollisionSphere(0, 0, 0, 1)) pusher = CollisionHandlerPusher() pusher.addCollider(collisionNodePath, self.players[name].nodePath) self.traverser.addCollider(collisionNodePath, pusher)
def setupCollision(self): cs = CollisionSphere(0, 0, 0, 10) cnodePath = self.player.attachNewNode(CollisionNode('cnode')) cnodePath.node().addSolid(cs) cnodePath.show() for o in self.OBS: ct = CollisionBox(0, 1, 1, 0.5) cn = o.attachNewNode(CollisionNode('ocnode')) cn.node().addSolid(ct) cn.show() pusher = CollisionHandlerPusher() pusher.addCollider(cnodePath, self.player) self.cTrav = CollisionTraverser() self.cTrav.addCollider(cnodePath, pusher) self.cTrav.showCollisions(render)
class MyApp(ShowBase): def __init__(self): ShowBase.__init__(self) # Create player node and attach camera and collision node/solid self.Player = render.attachNewNode('Player') self.camera.reparentTo(self.Player) self.PlayerCN = CollisionNode('Player') self.PlayerCNP = self.Player.attachNewNode(self.PlayerCN) self.PlayerCSph = CollisionSphere(0, 0, 0, 1) self.PlayerCN.addSolid(self.PlayerCSph) # Player collision sphere playerCS = CollisionSphere(0, 0, 0, 2) playerCNP = self.Player.attachNewNode(CollisionNode('cnode')) playerCNP.node().addSolid(playerCS) #PlayerCNP.reparentTo(self.camera) playerCNP.show() # This won't show since we are inside # Create generic sphere in the world in front of us to see self.Sphere = self.loader.loadModel("models/misc/sphere") self.Sphere.reparentTo(self.render) self.Sphere.setPos(0, 20, -0.2) # Collision sphere for visible sphere, slightly larger cs = CollisionSphere(0, 0, 0, 1) cnodePath = self.Sphere.attachNewNode(CollisionNode('cSpherenode')) cnodePath.node().addSolid(cs) cnodePath.show() # Create global collision traverser self.cTrav = CollisionTraverser() # Collision handler pusher - visible sphere will push back self.pusher = CollisionHandlerPusher() # Tell player sphere to act as pusher - or world object? self.cTrav.addCollider(cnodePath, self.pusher) self.pusher.addCollider(cnodePath, self.Sphere, base.drive.node()) seq = self.Player.posInterval(5, Point3(0, 40, 0), startPos=Point3(0, 0, 0), fluid=1).loop()
def setupCollision(self): cs = CollisionSphere(0,0,2,1) cnodePath = self.ralph.attachNewNode(CollisionNode('cnode')) cnodePath.node().addSolid(cs) cnodePath.show() #for o in self.OBS: #ct = CollisionTube(0,0,0, 0,0,1, 0.5) #cn = o.attachNewNode(CollisionNode('ocnode')) #cn.node().addSolid(ct) #cn.show() eyecs = CollisionSphere(0,0,4,5) cnodePath = self.gianteye.attachNewNode(CollisionNode('cnode')) cnodePath.node().addSolid(eyecs) cnodePath.show() eyecs = CollisionSphere(0,0,4,2) cnodePath = self.chik.attachNewNode(CollisionNode('cnode')) cnodePath.node().addSolid(eyecs) cnodePath.show() pusher = CollisionHandlerPusher() pusher.addCollider(cnodePath, self.player) self.cTrav = CollisionTraverser() self.cTrav.add_collider(cnodePath,pusher) self.cTrav.showCollisions(render)
class RoamingRalphDemo(ShowBase): def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) self.orbCollisionHandler = CollisionHandlerQueue() self.cTrav = CollisionTraverser() #hbPath = NodePath() utils3.setUpKeys(self) utils3.loadModels(self) utils3.setUpLighting(self) utils3.setUpFloatingSpheres(self) utils3.setUpRalphsShot(self) utils3.setUpCamera(self) self.healthTxt = utils3.addInstructions(.06,"Health: 100") self.orbTxt = utils3.addInstructions(.18,"Orbs: 0") self.vec = LVector3(0,1,0)#vector for pawns shot # Create a frame #frame = DirectFrame(text = "main", scale = 0.001) # Add button #bar = DirectWaitBar(text = "", value = 50, pos = (0,.4,.4)) #bar.reparent(render) # Game state variables self.isMoving = False self.jumping = False self.vz = 0 self.numOrbs = 0 self.healthCount = 100 #self.shotList = [] taskMgr.add(self.move, "moveTask") #taskMgr.add(utils2.moveChris,"moveChrisTask") self.sphere = CollisionSphere(0,0,4,2) self.sphere2 = CollisionSphere(0,0,2,2) self.cnodePath = self.ralph.attachNewNode((CollisionNode('ralphColNode'))) self.cnodePath.node().addSolid(self.sphere) self.cnodePath.node().addSolid(self.sphere2) #self.cnodePath.show() self.pusher = CollisionHandlerPusher() self.pusher.addCollider(self.cnodePath, self.ralph) #self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler) self.cTrav.addCollider(self.cnodePath, self.pusher) ca = CollisionSphere(0,0,0,20) cb = self.chik.attachNewNode(CollisionNode('chikCollisionNode')) cb.node().addSolid(ca) cb.show() cc = CollisionSphere(3,5,12,25) cd = self.gianteye.attachNewNode(CollisionNode('gianteyeCollisionNode')) cd.node().addSolid(cc) cd.show() ci = CollisionSphere(0,0,0,2) coi = self.catidol.attachNewNode(CollisionNode('catidolCollisionNode')) coi.node().addSolid(ci) coi.show() chi = CollisionSphere(-1,3,3,3) chco = self.chris.attachNewNode(CollisionNode('chrisColPath')) chco.node().addSolid(chi) self.cTrav.addCollider(chco, self.orbCollisionHandler) #chco.show() self.chris.setH(90) self.chris.setR(-90) self.chris.setZ(2) #cbox = CollisionBox((-50,30,20),10,85,20) #cboxPath = self.room.attachNewNode(CollisionNode('roomSide1')) #cboxPath.node().addSolid(cbox) #cboxPath.show() #cbox2 = CollisionBox((200,30,20),10,85,20) #cboxPath2 = self.room.attachNewNode(CollisionNode('roomSide1')) #cboxPath2.node().addSolid(cbox2) #cboxPath2.show() #cbox3 = CollisionBox((80,-60,20),120,20,20) #cboxPath3 = self.room.attachNewNode(CollisionNode('roomSide1')) #cboxPath3.node().addSolid(cbox3) #cboxPath3.show() ct = CollisionSphere(0,0,0,1) cn = self.pawn.attachNewNode(CollisionNode('pawnCollisionNode')) cn.node().addSolid(ct) cn.show() cs2 = CollisionSphere(0,0,0,.2) cs2path = self.plnp.attachNewNode((CollisionNode('orbColPath'))) cs2path.node().addSolid(cs2) cs2path.show() self.cTrav.addCollider(cs2path, self.orbCollisionHandler) #cs3 = CollisionSphere(0,0,0,1) cs3path = self.plnp2.attachNewNode((CollisionNode('orbColPath'))) cs3path.node().addSolid(cs2) cs3path.show() chrisShotNp = self.chrisShot.attachNewNode((CollisionNode("enemyOrbColPath"))) chrisShotNp.node().addSolid(cs2) chrisShotNp.show() self.cTrav.addCollider(cs3path, self.orbCollisionHandler) self.cTrav.addCollider(chrisShotNp, self.orbCollisionHandler) # Uncomment this line to show a visual representation of the # collisions occuring self.cTrav.showCollisions(render) self.chrisLastShotTime = globalClock.getFrameTime() self.chrisTimer = globalClock.getDt() # Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value # Accepts arrow keys to move either the player or the menu cursor, # Also deals with grid checking and collision detection def move(self, task): # Get the time that elapsed since last frame. We multiply this with # the desired speed in order to find out with which distance to move # in order to achieve that desired speed. dt = globalClock.getDt() utils3.moveChris(self,dt) # If the camera-left key is pressed, move camera left. # If the camera-right key is pressed, move camera right. if self.keyMap["cam-left"]: self.camera.setZ(self.camera, -20 * dt) if self.keyMap["cam-right"]: self.camera.setZ(self.camera, +20 * dt) # 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"]: self.ralph.setH(self.ralph.getH() + 150 * dt) #self.camera.setX(self.camera, +15.5 * dt) if self.keyMap["right"]: self.ralph.setH(self.ralph.getH() - 150 * dt) #self.camera.setX(self.camera, -15.5 * dt) if self.keyMap["forward"]: self.ralph.setY(self.ralph, -35 * dt) #self.camera.setY(self.camera, -35 * dt) if self.keyMap["back"]: self.ralph.setY(self.ralph, +35 * dt) #self.camera.setY(self.camera, 35 * dt) if self.keyMap["c"]: if self.jumping is False: #self.ralph.setZ(self.ralph.getZ() + 100 * dt) self.jumping = True self.vz = 7 if self.keyMap["space"]: self.keyMap["space"] = False self.shotList[self.shotCount].lpivot.setPos(self.ralph.getPos()) self.shotList[self.shotCount].lpivot.setZ(self.ralph.getZ() + .5) self.shotList[self.shotCount].lpivot.setX(self.ralph.getX() - .25) #self.shotList.append(rShot) #self.lightpivot3.setPos(self.ralph.getPos()) #self.lightpivot3.setZ(self.ralph.getZ() + .5) #self.lightpivot3.setX(self.ralph.getX() - .25) #self.myShot.setHpr(self.ralph.getHpr()) #parent to ralph #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(0,-1,0)) #self.myShotVec = vec node = NodePath("tmp") node.setHpr(self.ralph.getHpr()) vec = render.getRelativeVector(node,(0,-1,0)) self.shotList[self.shotCount].vec = vec self.shotCount = (self.shotCount + 1) % 5 for rs in self.shotList: rs.lpivot.setPos(rs.lpivot.getPos() + rs.vec * dt * 15 ) #if shot is too far stop updating if self.jumping is True: self.vz = self.vz - 16* dt self.ralph.setZ(self.ralph.getZ() + self.vz * dt ) if self.ralph.getZ() < 0: self.ralph.setZ(0) self.jumping = False else: if self.ralph.getZ() < 0: self.ralph.setZ(0) elif self.ralph.getZ() > 0: self.ralph.setZ(self.ralph.getZ() -7 * dt) # If ralph is moving, loop the run animation. # If he is standing still, stop the animation. if self.keyMap["forward"] or self.keyMap["left"] or self.keyMap["right"] or self.keyMap["c"] or self.keyMap["forward"] or self.keyMap["back"]: if self.isMoving is False: self.ralph.loop("run") self.isMoving = True else: if self.isMoving: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False # update pawns shot or set up new shot after it reaches a certain distance node = NodePath("tmp") node.setHpr(self.pawn.getHpr()) vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0)) self.shot.setPos(self.shot.getPos() + self.vec * dt * 10 ) if self.shot.getY() < -15 or self.shot.getY() > 30 or self.shot.getX() < 5 or self.shot.getX() > 15: self.shot.setPos(self.pawn.getPos() + (0,0,0)) self.vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0)) self.vec = render.getRelativeVector(node,(random.random() * random.randrange(-1,2),random.random() + 1,0)) # If the camera is too far from ralph, move it closer. # If the camera is too close to ralph, move it farther. #self.camera.lookAt(self.floater) camvec = self.ralph.getPos() - self.camera.getPos() #camvec = Vec3(0,camvec.getY(),0) camdist = camvec.length() x = self.camera.getZ() camvec.normalize() #if camdist > 6.0: # self.camera.setPos(self.camera.getPos() + camvec * (camdist - 6)) #if camdist < 6.0: # self.camera.setPos(self.camera.getPos() - camvec * (6 - camdist)) # Normally, we would have to call traverse() to check for collisions. # However, the class ShowBase that we inherit from has a task to do # this for us, if we assign a CollisionTraverser to self.cTrav. #self.cTrav.traverse(render) # Adjust camera so it stays at same height if self.camera.getZ() < self.ralph.getZ() + 1 or self.camera.getZ() > self.ralph.getZ() + 1: self.camera.setZ(self.ralph.getZ() + 1) # The camera should look in ralph's direction, # but it should also try to stay horizontal, so look at # a floater which hovers above ralph's head. self.camera.lookAt(self.floater) entries = list(self.orbCollisionHandler.getEntries()) if(len(entries) > 0): #self.lightpivot.reparentTo(NodePath()) for entry in self.orbCollisionHandler.getEntries(): #print(entry) fromColNp = entry.getFromNodePath() toColNp = entry.getIntoNodePath() if fromColNp.getName() == "orbColPath" and toColNp.getName() == "ralphColNode": fromColNp.getParent().reparentTo(NodePath()) self.orbTxt.destroy() self.numOrbs += 1 str1 = "Orbs: " + str(self.numOrbs) self.orbTxt = utils3.addInstructions(.18, str1) elif toColNp.getName() == "orbColPath" and fromColNp.getName() == "ralphColNode": toColNp.getParent().reparentTo(NodePath()) self.orbTxt.destroy() self.numOrbs += 1 str1 = "Orbs: " + str(self.numOrbs) self.orbTxt = utils3.addInstructions(.18, str1) elif toColNp.getName() == "ralphOrbColPath" and fromColNp.getName() == "chrisColPath": toColNp.getParent().setPos(-50,0,2) self.chrisHealth = self.chrisHealth - 1 self.chris.setColor(1,0,0,1) self.chrisHit = True self.chrisRedTime = globalClock.getFrameTime() #print self.chrisRedTime if self.chrisHealth < 0: fromColNp.getParent().removeNode() self.chrisAlive = False elif toColNp.getName() == "chrisColPath" and fromColNp.getName() == "ralphOrbColPath": fromColNp.getParent().setPos(-50,0,2) self.chrisHealth = self.chrisHealth - 1 self.chris.setColor(1,0,0,1) self.chrisHit = True self.chrisRedTime = globalClock.getFrameTime() #print self.chrisRedTime if self.chrisHealth < 0: fromColNp.getParent().removeNode() self.chrisAlive = False self.chrisShot.setZ(26) elif toColNp.getName() == "enemyOrbColPath" and fromColNp.getName() == "ralphColNode": toColNp.getParent().setZ(26) self.healthTxt.destroy() self.healthCount -= 3 str1 = "Health: " + str(self.healthCount) self.healthTxt = utils3.addInstructions(.06, str1) elif toColNp.getName() == "ralphColNode" and fromColNp.getName() == "enemyOrbColPath": fromColNp.getParent().setZ(26) self.healthTxt.destroy() self.healthCount -= 3 str1 = "Health: " + str(self.healthCount) self.healthTxt = utils3.addInstructions(.06, str1) return task.cont
class CogdoFlyingCollisions(GravityWalker): wantFloorSphere = 0 def __init__(self): GravityWalker.__init__(self, gravity=0.0) def initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius = 1.4, floorOffset = 1.0, reach = 1.0): self.cHeadSphereNodePath = None self.cFloorEventSphereNodePath = None self.setupHeadSphere(avatarNodePath) self.setupFloorEventSphere(avatarNodePath, ToontownGlobals.FloorEventBitmask, avatarRadius) GravityWalker.initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius, floorOffset, reach) return def setupWallSphere(self, bitmask, avatarRadius): self.avatarRadius = avatarRadius cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius) cSphereNode = CollisionNode('Flyer.cWallSphereNode') cSphereNode.addSolid(cSphere) cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) if config.GetBool('want-fluid-pusher', 0): self.pusher = CollisionHandlerFluidPusher() else: self.pusher = CollisionHandlerPusher() self.pusher.addCollider(cSphereNodePath, self.avatarNodePath) self.cWallSphereNodePath = cSphereNodePath def setupEventSphere(self, bitmask, avatarRadius): self.avatarRadius = avatarRadius cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius * 1.04) cSphere.setTangible(0) cSphereNode = CollisionNode('Flyer.cEventSphereNode') cSphereNode.addSolid(cSphere) cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) self.event = CollisionHandlerEvent() self.event.addInPattern('enter%in') self.event.addOutPattern('exit%in') self.cEventSphereNodePath = cSphereNodePath def setupRay(self, bitmask, floorOffset, reach): cRay = CollisionRay(0.0, 0.0, 3.0, 0.0, 0.0, -1.0) cRayNode = CollisionNode('Flyer.cRayNode') cRayNode.addSolid(cRay) self.cRayNodePath = self.avatarNodePath.attachNewNode(cRayNode) cRayNode.setFromCollideMask(bitmask) cRayNode.setIntoCollideMask(BitMask32.allOff()) self.lifter = CollisionHandlerGravity() self.lifter.setLegacyMode(self._legacyLifter) self.lifter.setGravity(self.getGravity(0)) self.lifter.addInPattern('%fn-enter-%in') self.lifter.addAgainPattern('%fn-again-%in') self.lifter.addOutPattern('%fn-exit-%in') self.lifter.setOffset(floorOffset) self.lifter.setReach(reach) self.lifter.addCollider(self.cRayNodePath, self.avatarNodePath) def setupHeadSphere(self, avatarNodePath): collSphere = CollisionSphere(0, 0, 0, 1) collSphere.setTangible(1) collNode = CollisionNode('Flyer.cHeadCollSphere') collNode.setFromCollideMask(ToontownGlobals.CeilingBitmask) collNode.setIntoCollideMask(BitMask32.allOff()) collNode.addSolid(collSphere) self.cHeadSphereNodePath = avatarNodePath.attachNewNode(collNode) self.cHeadSphereNodePath.setZ(base.localAvatar.getHeight() + 1.0) self.headCollisionEvent = CollisionHandlerEvent() self.headCollisionEvent.addInPattern('%fn-enter-%in') self.headCollisionEvent.addOutPattern('%fn-exit-%in') base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent) def setupFloorEventSphere(self, avatarNodePath, bitmask, avatarRadius): cSphere = CollisionSphere(0.0, 0.0, 0.0, 0.75) cSphereNode = CollisionNode('Flyer.cFloorEventSphere') cSphereNode.addSolid(cSphere) cSphereNodePath = avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) self.floorCollisionEvent = CollisionHandlerEvent() self.floorCollisionEvent.addInPattern('%fn-enter-%in') self.floorCollisionEvent.addAgainPattern('%fn-again-%in') self.floorCollisionEvent.addOutPattern('%fn-exit-%in') base.cTrav.addCollider(cSphereNodePath, self.floorCollisionEvent) self.cFloorEventSphereNodePath = cSphereNodePath def deleteCollisions(self): GravityWalker.deleteCollisions(self) if self.cHeadSphereNodePath != None: base.cTrav.removeCollider(self.cHeadSphereNodePath) self.cHeadSphereNodePath.detachNode() self.cHeadSphereNodePath = None self.headCollisionsEvent = None if self.cFloorEventSphereNodePath != None: base.cTrav.removeCollider(self.cFloorEventSphereNodePath) self.cFloorEventSphereNodePath.detachNode() self.cFloorEventSphereNodePath = None self.floorCollisionEvent = None self.cRayNodePath.detachNode() del self.cRayNodePath self.cEventSphereNodePath.detachNode() del self.cEventSphereNodePath return def setCollisionsActive(self, active = 1): if self.collisionsActive != active: if self.cHeadSphereNodePath != None: base.cTrav.removeCollider(self.cHeadSphereNodePath) if active: base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent) if self.cFloorEventSphereNodePath != None: base.cTrav.removeCollider(self.cFloorEventSphereNodePath) if active: base.cTrav.addCollider(self.cFloorEventSphereNodePath, self.floorCollisionEvent) GravityWalker.setCollisionsActive(self, active) return def enableAvatarControls(self): pass def disableAvatarControls(self): pass def handleAvatarControls(self, task): pass
class Load(): def __init__(self): # import leap motion self.leap = leapmotion.LeapMotion() # disable mouse control base.disableMouse() render.hide() self.inGame = True # menu music # taken from https://www.youtube.com/watch?v=2iEWbHJDlo4&list=PLzCxunOM5WFIudfMTgJzXkOE-xbVWrpIF&index=7 self.starterMusic = loader.loadMusic( 'musics/starterMenuBackground.ogg') self.starterMusic.setLoop(True) # taken form https://www.youtube.com/watch?v=I0vEzblcnPA&list=PLzCxunOM5WFIudfMTgJzXkOE-xbVWrpIF&index=18 self.endMusic = loader.loadMusic('musics/endMusic.ogg') self.endMusic.setLoop(True) # game music from https://www.youtube.com/watch?v=mNFNOEi9QV4&list=PLzCxunOM5WFK7WGa3wGjlONp_9R66a2zz&index=8 self.gameMusic = loader.loadMusic('musics/gameMusic.ogg') self.gameMusic.setLoop(True) # import flybot, enemy, door, chests, key, and player self.flyBot = FlyBot() self.player = player.Player(self.flyBot) self.enemies = [] self.numbEnemies = 0 keyChest = random.randint(0, 3) # self.key = Key(keyChest) self.door = Door(225, 190, self.flyBot) self.walls = [] self.chests = [] def startGame(self): # Load the map. self.environ = loader.loadModel("models/background_model") # Reparent the model to render. self.environ.reparentTo(render) # Apply scale and position transforms on the model. # image taken from http://motorbikes-passion.info/scary-dark-room.html myTexture = loader.loadTexture("models/backgroundtexture.jpg") self.environ.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldCubeMap) self.environ.setTexture(myTexture) self.environ.setScale(1, 1, 1) self.environ.setPos(0, 0, 0) self.environ.reparentTo(render) # random generate map self.numbWalls = 4 walls = generateRoom([], self.numbWalls) # if random generation fails, input default map if walls == None: walls = [(120, 30, 0), (-100, 80, 90), (-130, -70, 0), (50, -50, 90)] # load wall models in respective location for wall in walls: x, y, angle = wall newWall = Wall(x, y, angle) self.walls.append(newWall) # generate chests in random areas chests = generateChestLocation(walls) for chest in chests: x, y, chestNumb = chest newChest = Chest(self.player, self.flyBot, x, y, chestNumb) self.chests.append(newChest) # display player stats self.display = self.player.displayStats() # run collision settings base.cTrav = CollisionTraverser() # Set up collision for environment self.backgroundCollide = CollisionRay() self.backgroundNode = CollisionNode('backgroundCollider') self.backgroundNode.addSolid(self.backgroundCollide) self.backgroundNode.setFromCollideMask(CollideMask.bit(0)) self.backgroundNode.setIntoCollideMask(CollideMask.allOff()) self.backgroundCollider = self.environ.attachNewNode( self.backgroundNode) # call all functions that deal with collisions taskMgr.add(self.swordHitEnemy, 'killEnemy') self.wallCollisions() taskMgr.add(self.fireballHitPlayer, 'fireballHits') # load sound effects # sound taken from https://bigsoundbank.com/detail-0129-sword.html self.swordCut = loader.loadSfx('musics/0129.ogg') # sound taken from https://bigsoundbank.com/detail-0437-shot-beretta-m12-9-mm.html self.fireballHit = loader.loadSfx('musics/0437.ogg') # run quitGame self.quitGame() # Set up initial camera position base.camera.setPos(0, 0, 0) base.camera.setHpr(0, 0, 0) base.camera.reparentTo(self.flyBot.flyBot) # import player controls from player file self.playerControl = player.KeyboardControl(self.flyBot, self.chests, self.door, self.walls, self.player) # import leap motion control self.leapControl = player.swordControl(self.leap, self.player) taskMgr.add(self.leapControl.swingsword, 'swingsword') # spawn new enemies sec = 5 - self.player.atLevel taskMgr.doMethodLater(sec, self.spawnEnemies, 'createNewEnemy') # test enemy movements taskMgr.add(self.enemyMovements, 'enemyMovements') # Game AI AI = GameAI(self.enemies, self.flyBot) taskMgr.add(AI.makeDecision, 'enemyStateDetermination') # stop all tasks def stopGame(self): taskMgr.remove('checkGameState') taskMgr.remove('enemyStateDetermination') taskMgr.remove('enemyMovements') taskMgr.remove('createNewEnemy') taskMgr.remove('swingsword') taskMgr.remove('fireballHits') taskMgr.remove('killEnemy') taskMgr.remove("playerMove") taskMgr.remove('openChestOrDoor') taskMgr.remove('moveFireball') taskMgr.remove('fireFireballs') # allow keyboard exit def quitGame(self): textObject = OnscreenText(text='ESC to exit game', pos=(-0.25, -0.05), scale=0.05, parent=base.a2dTopRight) # The key esc will exit the game base.accept('escape', sys.exit) # create new enemies def spawnEnemies(self, task): if len(self.enemies) < 20: # default state is stay self.numbEnemies += 1 newEnemy = enemy.Enemy(1, self.numbEnemies, self.player) self.enemies.append(newEnemy) task.delayTime += 1 return task.again # moves the enemies towards the player def enemyMovements(self, task): for enemy in self.enemies: enemy.lookAtPlayer(self.flyBot) if enemy.state == 0: enemy.move(self.flyBot.flyBot) if enemy.state == 2: randomChest = random.randint(0, 3) doorOrChest = random.randint( [self.door.door, self.chests[randomChest].chestModel]) enemy.move(doorOrChest) return task.cont # Collision functions, called in init def wallCollisions(self): # Pusher so that the player cannot move past the walls self.playerPusher = CollisionHandlerPusher() base.cTrav.addCollider(self.flyBot.playerCollider, self.playerPusher) self.playerPusher.addCollider(self.flyBot.playerCollider, self.flyBot.flyBot) self.enemyPusher = CollisionHandlerPusher() for enemy in self.enemies: base.cTrav.addCollider(enemy.collider, self.enemyPusher) self.enemyPusher.addCollider(enemy.collider, enemy.enemyModel) def swordHitEnemy(self, task): # When the sword collides with enemy, enemy dies for enemy in self.enemies: self.playerKill = CollisionHandlerEvent() base.cTrav.addCollider(enemy.collider, self.playerKill) self.playerKill.addInPattern('%fn-into-%in') # perform the task self.kill = DirectObject() self.kill.accept('enemy' + str(enemy.numb) + '-into-swordCollider', enemy.killEnemy) self.swordHit = DirectObject() self.swordHit.accept( 'enemy' + str(enemy.numb) + '-into-swordCollider', self.swordHitSound) if not enemy.isAlive: self.enemies.remove(enemy) return task.cont # play the sound when the sword hits an ememy def swordHitSound(self, *args): if self.player.damage: self.swordCut.play() # create collision system for fireballs based on the location of the player # and the location of a given enemy def fireballHitPlayer(self, task): for enemy in self.enemies: if enemy.fireballFired.isLive: # When fireball collides with player, player health reduces playerX = self.flyBot.flyBot.getX() playerY = self.flyBot.flyBot.getY() margin = 5 enemyH = math.sin(math.radians(enemy.enemyModel.getH())) fireballX = enemy.enemyModel.getX() fireballY = enemy.enemyModel.getY( ) + enemyH * enemy.fireballFired.fireball.getY() enemyY = enemy.enemyModel.getY() playerH = self.flyBot.flyBot.getH() if abs(fireballY) > 230 or abs(fireballX) > 230: enemy.fireballFired.removeFireball(task) if (playerH > -45 and playerH < 45) or (playerH > 135) or (playerH < -135): if playerX - margin <= fireballX and playerX + margin >= fireballX: if (abs(enemy.enemyModel.getH()) <= 45 and fireballY >= playerY) or\ (abs(enemy.enemyModel.getH()) >= 135 and fireballY <= playerY): self.fireballHit.play() self.player.changeStats(-5, 0) enemy.fireballFired.removeFireball(task) else: if playerY - margin <= fireballY and playerY + margin >= fireballY: if (enemy.enemyModel.getH() <= 0 and fireballX >= playerX) or\ (enemy.enemyModel.getH() > 0 and fireballX <= playerX): self.fireballHit.play() self.player.changeStats(-5, 0) enemy.fireballFired.removeFireball(task) return task.cont
class SmartCamera: UPDATE_TASK_NAME = 'update_smartcamera' notify = directNotify.newCategory('SmartCamera') def __init__(self): self.cTrav = CollisionTraverser('cam_traverser') base.pushCTrav(self.cTrav) self.cTrav.setRespectPrevTransform(1) self.default_pos = None self.parent = None self.initialized = False self.started = False self.camFloorRayNode = None self.ccRay2 = None self.ccRay2Node = None self.ccRay2NodePath = None self.ccRay2BitMask = None self.ccRay2MoveNodePath = None self.camFloorCollisionBroadcaster = None self.notify.debug('SmartCamera initialized!') return def lerpCameraFov(self, fov, time): taskMgr.remove('cam-fov-lerp-play') oldFov = base.camLens.getHfov() if abs(fov - oldFov) > 0.1: def setCamFov(fov): base.camLens.setMinFov(fov / (4.0 / 3.0)) self.camLerpInterval = LerpFunctionInterval(setCamFov, fromData=oldFov, toData=fov, duration=time, name='cam-fov-lerp') self.camLerpInterval.start() def setCameraFov(self, fov): self.fov = fov if not (self.isPageDown or self.isPageUp): base.camLens.setMinFov(self.fov / (4.0 / 3.0)) def initCameraPositions(self): camHeight = max(base.localAvatar.getHeight(), 3.0) nrCamHeight = base.localAvatar.getHeight() heightScaleFactor = camHeight * 0.3333333333 defLookAt = Point3(0.0, 1.5, camHeight) self.firstPersonCamPos = Point3(0.0, 0.7, nrCamHeight * 5.0) scXoffset = 3.0 scPosition = (Point3(scXoffset - 1, -10.0, camHeight + 5.0), Point3(scXoffset, 2.0, camHeight)) self.cameraPositions = [ (Point3(0.0, -9.0 * heightScaleFactor, camHeight), defLookAt, Point3(0.0, camHeight, camHeight * 4.0), Point3(0.0, camHeight, camHeight * -1.0), 0), ( Point3(0.0, 0.7, camHeight), defLookAt, Point3(0.0, camHeight, camHeight * 1.33), Point3(0.0, camHeight, camHeight * 0.66), 1), ( Point3(5.7 * heightScaleFactor, 7.65 * heightScaleFactor, camHeight + 2.0), Point3(0.0, 1.0, camHeight), Point3(0.0, 1.0, camHeight * 4.0), Point3(0.0, 1.0, camHeight * -1.0), 0), ( Point3(0.0, 8.65 * heightScaleFactor, camHeight), Point3(0.0, 1.0, camHeight), Point3(0.0, 1.0, camHeight * 4.0), Point3(0.0, 1.0, camHeight * -1.0), 0), ( Point3(0.0, -24.0 * heightScaleFactor, camHeight + 4.0), defLookAt, Point3(0.0, 1.5, camHeight * 4.0), Point3(0.0, 1.5, camHeight * -1.0), 0), ( Point3(0.0, -12.0 * heightScaleFactor, camHeight + 4.0), defLookAt, Point3(0.0, 1.5, camHeight * 4.0), Point3(0.0, 1.5, camHeight * -1.0), 0)] def pageUp(self): if not base.localAvatar.avatarMovementEnabled: return if not self.isPageUp: self.isPageDown = 0 self.isPageUp = 1 self.lerpCameraFov(70, 0.6) self.setCameraPositionByIndex(self.cameraIndex) else: self.clearPageUpDown() def pageDown(self): if not base.localAvatar.avatarMovementEnabled: return if not self.isPageDown: self.isPageUp = 0 self.isPageDown = 1 self.lerpCameraFov(70, 0.6) self.setCameraPositionByIndex(self.cameraIndex) else: self.clearPageUpDown() def clearPageUpDown(self): if self.isPageDown or self.isPageUp: self.lerpCameraFov(self.fov, 0.6) self.isPageDown = 0 self.isPageUp = 0 self.setCameraPositionByIndex(self.cameraIndex) def nextCameraPos(self, forward): if not base.localAvatar.avatarMovementEnabled: return self.__cameraHasBeenMoved = 1 if forward: self.cameraIndex += 1 if self.cameraIndex > len(self.cameraPositions) - 1: self.cameraIndex = 0 else: self.cameraIndex -= 1 if self.cameraIndex < 0: self.cameraIndex = len(self.cameraPositions) - 1 self.setCameraPositionByIndex(self.cameraIndex) def setCameraPositionByIndex(self, index): self.notify.debug('switching to camera position %s' % index) self.setCameraSettings(self.cameraPositions[index]) def setCameraSettings(self, camSettings): self.setIdealCameraPos(camSettings[0]) if self.isPageUp and self.isPageDown or not self.isPageUp and not self.isPageDown: self.__cameraHasBeenMoved = 1 self.setLookAtPoint(camSettings[1]) else: if self.isPageUp: self.__cameraHasBeenMoved = 1 self.setLookAtPoint(camSettings[2]) else: if self.isPageDown: self.__cameraHasBeenMoved = 1 self.setLookAtPoint(camSettings[3]) else: self.notify.error('This case should be impossible.') self.__disableSmartCam = camSettings[4] if self.__disableSmartCam: self.putCameraFloorRayOnAvatar() self.cameraZOffset = 0.0 def set_default_pos(self, pos): self.default_pos = pos def get_default_pos(self): return self.default_pos def set_parent(self, parent): self.parent = parent def get_parent(self): return self.parent def getVisibilityPoint(self): return Point3(0.0, 0.0, base.localAvatar.getHeight()) def setLookAtPoint(self, la): self.__curLookAt = Point3(la) def getLookAtPoint(self): return Point3(self.__curLookAt) def setIdealCameraPos(self, pos): self.__idealCameraPos = Point3(pos) self.updateSmartCameraCollisionLineSegment() def getIdealCameraPos(self): return Point3(self.__idealCameraPos) def getCompromiseCameraPos(self): if self.__idealCameraObstructed == 0: compromisePos = self.getIdealCameraPos() else: visPnt = self.getVisibilityPoint() idealPos = self.getIdealCameraPos() distance = Vec3(idealPos - visPnt).length() ratio = self.closestObstructionDistance / distance compromisePos = idealPos * ratio + visPnt * (1 - ratio) liftMult = 1.0 - ratio * ratio compromisePos = Point3(compromisePos[0], compromisePos[1], compromisePos[2] + base.localAvatar.getHeight() * 0.4 * liftMult) compromisePos.setZ(compromisePos[2] + self.cameraZOffset) return compromisePos def updateSmartCameraCollisionLineSegment(self): pointB = self.getIdealCameraPos() pointA = self.getVisibilityPoint() vectorAB = Vec3(pointB - pointA) lengthAB = vectorAB.length() if lengthAB > 0.001: self.ccLine.setPointA(pointA) self.ccLine.setPointB(pointB) def initializeSmartCamera(self): self.__idealCameraObstructed = 0 self.closestObstructionDistance = 0.0 self.cameraIndex = 0 self.cameraPositions = [] self.auxCameraPositions = [] self.cameraZOffset = 0.0 self.setGeom(render) self.__onLevelGround = 0 self.__camCollCanMove = 0 self.__disableSmartCam = 0 self.initializeSmartCameraCollisions() self._smartCamEnabled = False self.isPageUp = 0 self.isPageDown = 0 self.fov = CIGlobals.DefaultCameraFov def enterFirstPerson(self): self.stop_smartcamera() if hasattr(self.get_parent(), 'toon_head'): head = self.get_parent().toon_head camera.reparentTo(head) camera.setPos(0, -0.35, 0) camera.setHpr(0, 0, 0) def exitFirstPerson(self): self.initialize_smartcamera() self.initialize_smartcamera_collisions() self.start_smartcamera() def putCameraFloorRayOnAvatar(self): self.camFloorRayNode.setPos(base.localAvatar, 0, 0, 5) def putCameraFloorRayOnCamera(self): self.camFloorRayNode.setPos(self.ccSphereNodePath, 0, 0, 0) def recalcCameraSphere(self): nearPlaneDist = base.camLens.getNear() hFov = base.camLens.getHfov() vFov = base.camLens.getVfov() hOff = nearPlaneDist * math.tan(deg2Rad(hFov / 2.0)) vOff = nearPlaneDist * math.tan(deg2Rad(vFov / 2.0)) camPnts = [Point3(hOff, nearPlaneDist, vOff), Point3(-hOff, nearPlaneDist, vOff), Point3(hOff, nearPlaneDist, -vOff), Point3(-hOff, nearPlaneDist, -vOff), Point3(0.0, 0.0, 0.0)] avgPnt = Point3(0.0, 0.0, 0.0) for camPnt in camPnts: avgPnt = avgPnt + camPnt avgPnt = avgPnt / len(camPnts) sphereRadius = 0.0 for camPnt in camPnts: dist = Vec3(camPnt - avgPnt).length() if dist > sphereRadius: sphereRadius = dist avgPnt = Point3(avgPnt) self.ccSphereNodePath.setPos(avgPnt) self.ccSphereNodePath2.setPos(avgPnt) self.ccSphere.setRadius(sphereRadius) def setGeom(self, geom): self.__geom = geom def initializeSmartCameraCollisions(self): if self.initialized: return self.ccTrav = CollisionTraverser('LocalAvatar.ccTrav') self.ccLine = CollisionSegment(0.0, 0.0, 0.0, 1.0, 0.0, 0.0) self.ccLineNode = CollisionNode('ccLineNode') self.ccLineNode.addSolid(self.ccLine) self.ccLineNodePath = base.localAvatar.attachNewNode(self.ccLineNode) self.ccLineBitMask = CIGlobals.CameraBitmask self.ccLineNode.setFromCollideMask(self.ccLineBitMask) self.ccLineNode.setIntoCollideMask(BitMask32.allOff()) self.camCollisionQueue = CollisionHandlerQueue() self.ccTrav.addCollider(self.ccLineNodePath, self.camCollisionQueue) self.ccSphere = CollisionSphere(0, 0, 0, 1) self.ccSphereNode = CollisionNode('ccSphereNode') self.ccSphereNode.addSolid(self.ccSphere) self.ccSphereNodePath = base.camera.attachNewNode(self.ccSphereNode) self.ccSphereNode.setFromCollideMask(CIGlobals.CameraBitmask) self.ccSphereNode.setIntoCollideMask(BitMask32.allOff()) self.camPusher = CollisionHandlerPusher() self.camPusher.addCollider(self.ccSphereNodePath, base.camera) self.camPusher.setCenter(base.localAvatar) self.ccPusherTrav = CollisionTraverser('LocalAvatar.ccPusherTrav') self.ccSphere2 = self.ccSphere self.ccSphereNode2 = CollisionNode('ccSphereNode2') self.ccSphereNode2.addSolid(self.ccSphere2) self.ccSphereNodePath2 = base.camera.attachNewNode(self.ccSphereNode2) self.ccSphereNode2.setFromCollideMask(CIGlobals.CameraBitmask) self.ccSphereNode2.setIntoCollideMask(BitMask32.allOff()) self.camPusher2 = CollisionHandlerPusher() self.ccPusherTrav.addCollider(self.ccSphereNodePath2, self.camPusher2) self.camPusher2.addCollider(self.ccSphereNodePath2, base.camera) self.camPusher2.setCenter(base.localAvatar) self.camFloorRayNode = base.localAvatar.attachNewNode('camFloorRayNode') self.ccRay = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0) self.ccRayNode = CollisionNode('ccRayNode') self.ccRayNode.addSolid(self.ccRay) self.ccRayNodePath = self.camFloorRayNode.attachNewNode(self.ccRayNode) self.ccRayBitMask = CIGlobals.FloorBitmask self.ccRayNode.setFromCollideMask(self.ccRayBitMask) self.ccRayNode.setIntoCollideMask(BitMask32.allOff()) self.ccTravFloor = CollisionTraverser('LocalAvatar.ccTravFloor') self.camFloorCollisionQueue = CollisionHandlerQueue() self.ccTravFloor.addCollider(self.ccRayNodePath, self.camFloorCollisionQueue) self.ccTravOnFloor = CollisionTraverser('LocalAvatar.ccTravOnFloor') self.ccRay2 = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0) self.ccRay2Node = CollisionNode('ccRay2Node') self.ccRay2Node.addSolid(self.ccRay2) self.ccRay2NodePath = self.camFloorRayNode.attachNewNode(self.ccRay2Node) self.ccRay2BitMask = CIGlobals.FloorBitmask self.ccRay2Node.setFromCollideMask(self.ccRay2BitMask) self.ccRay2Node.setIntoCollideMask(BitMask32.allOff()) self.ccRay2MoveNodePath = hidden.attachNewNode('ccRay2MoveNode') self.camFloorCollisionBroadcaster = CollisionHandlerFloor() self.camFloorCollisionBroadcaster.setInPattern('on-floor') self.camFloorCollisionBroadcaster.setOutPattern('off-floor') self.camFloorCollisionBroadcaster.addCollider(self.ccRay2NodePath, self.ccRay2MoveNodePath) self.cTrav.addCollider(self.ccRay2NodePath, self.camFloorCollisionBroadcaster) self.initialized = True def deleteSmartCameraCollisions(self): del self.ccTrav del self.ccLine del self.ccLineNode self.ccLineNodePath.removeNode() del self.ccLineNodePath del self.camCollisionQueue del self.ccRay del self.ccRayNode self.ccRayNodePath.removeNode() del self.ccRayNodePath del self.ccRay2 del self.ccRay2Node self.ccRay2NodePath.removeNode() del self.ccRay2NodePath self.ccRay2MoveNodePath.removeNode() del self.ccRay2MoveNodePath del self.ccTravOnFloor del self.ccTravFloor del self.camFloorCollisionQueue del self.camFloorCollisionBroadcaster del self.ccSphere del self.ccSphereNode self.ccSphereNodePath.removeNode() del self.ccSphereNodePath del self.camPusher del self.ccPusherTrav del self.ccSphere2 del self.ccSphereNode2 self.ccSphereNodePath2.removeNode() del self.ccSphereNodePath2 del self.camPusher2 self.initialized = False def startUpdateSmartCamera(self): if self.started: return self.__floorDetected = 0 self.__cameraHasBeenMoved = 1 self.recalcCameraSphere() self.__instantaneousCamPos = camera.getPos() self.cTrav.addCollider(self.ccSphereNodePath, self.camPusher) self.ccTravOnFloor.addCollider(self.ccRay2NodePath, self.camFloorCollisionBroadcaster) self.__disableSmartCam = 0 self.__lastPosWrtRender = camera.getPos(render) + 1 self.__lastHprWrtRender = camera.getHpr(render) + 1 taskName = base.localAvatar.taskName('updateSmartCamera') taskMgr.remove(taskName) taskMgr.add(self.updateSmartCamera, taskName, priority=47) self.started = True def stopUpdateSmartCamera(self): self.cTrav.removeCollider(self.ccSphereNodePath) self.ccTravOnFloor.removeCollider(self.ccRay2NodePath) taskName = base.localAvatar.taskName('updateSmartCamera') taskMgr.remove(taskName) camera.setPos(self.getIdealCameraPos()) self.started = False def updateSmartCamera(self, task): if not self.__camCollCanMove and not self.__cameraHasBeenMoved: if self.__lastPosWrtRender == camera.getPos(render): if self.__lastHprWrtRender == camera.getHpr(render): return Task.cont self.__cameraHasBeenMoved = 0 self.__lastPosWrtRender = camera.getPos(render) self.__lastHprWrtRender = camera.getHpr(render) self.__idealCameraObstructed = 0 if not self.__disableSmartCam: self.ccTrav.traverse(self.__geom) if self.camCollisionQueue.getNumEntries() > 0: try: self.camCollisionQueue.sortEntries() self.handleCameraObstruction(self.camCollisionQueue.getEntry(0)) except AssertionError: pass if not self.__onLevelGround: self.handleCameraFloorInteraction() if not self.__idealCameraObstructed: self.nudgeCamera() if not self.__disableSmartCam: self.ccPusherTrav.traverse(self.__geom) self.putCameraFloorRayOnCamera() self.ccTravOnFloor.traverse(self.__geom) return Task.cont def positionCameraWithPusher(self, pos, lookAt): camera.setPos(pos) self.ccPusherTrav.traverse(self.__geom) camera.lookAt(lookAt) def nudgeCamera(self): CLOSE_ENOUGH = 0.1 curCamPos = self.__instantaneousCamPos curCamHpr = camera.getHpr() targetCamPos = self.getCompromiseCameraPos() targetCamLookAt = self.getLookAtPoint() posDone = 0 if Vec3(curCamPos - targetCamPos).length() <= CLOSE_ENOUGH: camera.setPos(targetCamPos) posDone = 1 camera.setPos(targetCamPos) camera.lookAt(targetCamLookAt) targetCamHpr = camera.getHpr() hprDone = 0 if Vec3(curCamHpr - targetCamHpr).length() <= CLOSE_ENOUGH: hprDone = 1 if posDone and hprDone: return lerpRatio = 0.15 lerpRatio = 1 - pow(1 - lerpRatio, globalClock.getDt() * 30.0) self.__instantaneousCamPos = targetCamPos * lerpRatio + curCamPos * (1 - lerpRatio) if self.__disableSmartCam or not self.__idealCameraObstructed: newHpr = targetCamHpr * lerpRatio + curCamHpr * (1 - lerpRatio) else: newHpr = targetCamHpr camera.setPos(self.__instantaneousCamPos) camera.setHpr(newHpr) def popCameraToDest(self): newCamPos = self.getCompromiseCameraPos() newCamLookAt = self.getLookAtPoint() self.positionCameraWithPusher(newCamPos, newCamLookAt) self.__instantaneousCamPos = camera.getPos() def handleCameraObstruction(self, camObstrCollisionEntry): collisionPoint = camObstrCollisionEntry.getSurfacePoint(self.ccLineNodePath) collisionVec = Vec3(collisionPoint - self.ccLine.getPointA()) distance = collisionVec.length() self.__idealCameraObstructed = 1 self.closestObstructionDistance = distance self.popCameraToDest() def handleCameraFloorInteraction(self): self.putCameraFloorRayOnCamera() self.ccTravFloor.traverse(self.__geom) if self.__onLevelGround: return if self.camFloorCollisionQueue.getNumEntries() == 0: return self.camFloorCollisionQueue.sortEntries() camObstrCollisionEntry = self.camFloorCollisionQueue.getEntry(0) camHeightFromFloor = camObstrCollisionEntry.getSurfacePoint(self.ccRayNodePath)[2] self.cameraZOffset = camera.getPos()[2] + camHeightFromFloor if self.cameraZOffset < 0: self.cameraZOffset = 0 if self.__floorDetected == 0: self.__floorDetected = 1 self.popCameraToDest()
class RoamingRalphDemo(ShowBase): def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) # Set the background color to black self.win.setClearColor((0, 0, 0, 1)) # This is used to store which keys are currently pressed. self.keyMap = { "left": 0, "right": 0, "forward": 0, "back": 0, "cam-left": 0, "cam-right": 0} # Post the instructions self.title = addTitle( "Adventurer: 3rd Person File Manager (in progress)") self.inst1 = addInstructions(0.06, "[ESC]: Quit") self.inst2 = addInstructions(0.12, "[Arrows]: Angle Camera") self.inst3 = addInstructions(0.18, "[WASD]: Move") # 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("models/world") #self.environ.reparentTo(render) #loader.unload_model startPos = Point3(0,0,0)#self.environ.find("**/start_point").getPos() # Setup controls self.keys = {} for key in ['arrow_left', 'arrow_right', 'arrow_up', 'arrow_down', 'a', 'd', 'w', 's']: self.keys[key] = 0 self.accept(key, self.push_key, [key, 1]) self.accept('shift-%s' % key, self.push_key, [key, 1]) self.accept('%s-up' % key, self.push_key, [key, 0]) #self.accept('f', self.toggleWireframe) #self.accept('x', self.toggle_xray_mode) #self.accept('b', self.toggle_model_bounds) self.accept('escape', __import__('sys').exit, [0]) self.disableMouse() taskMgr.add(self.update, "moveTask") #insert test features #addCube(models, render, startPos + (0, 1, 0.5), 0.5) #addWall(models, render, startPos + (0, 1, 0.5), 30, 0.2) addDir(render, startPos + (0, 1, 0.5)) # Game state variables self.isMoving = False # Set up the camera self.disableMouse() lens = PerspectiveLens() lens.setFov(60) lens.setNear(0.01) lens.setFar(1000.0) self.cam.node().setLens(lens) self.camera.setPos(startPos) self.heading = -95.0 self.pitch = 0.0 # Add collision to keept he camera in the room cn = CollisionNode('camera') cn.addSolid(CollisionSphere(0, 0, 0, 0.5)) camColl = self.camera.attachNewNode(cn) self.cTrav = CollisionTraverser('camera traverser') self.camGroundHandler = CollisionHandlerPusher() self.camGroundHandler.addCollider(camColl, NodePath(self.camera)) self.cTrav.addCollider(camColl, self.camGroundHandler) # Makes colliding objects show up self.cTrav.showCollisions(render) # Create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.3, .3, .3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection((-5, -5, -5)) directionalLight.setColor((1, 1, 1, 1)) directionalLight.setSpecularColor((1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight)) def push_key(self, key, value): """Stores a value associated with a key.""" self.keys[key] = value def update(self, task): """Updates the camera based on the keyboard input. Once this is done, then the CellManager's update function is called.""" posStart = self.camera.getPos() delta = globalClock.getDt() move_x = delta * SPEED_MOVE * -self.keys['a'] + delta * SPEED_MOVE * self.keys['d'] move_z = delta * SPEED_MOVE * self.keys['s'] + delta * SPEED_MOVE * -self.keys['w'] self.camera.setHpr(self.heading, 0, 0) self.camera.setPos(self.camera, move_x, -move_z, 0) self.heading += (delta * 90 * self.keys['arrow_left'] + delta * 90 * -self.keys['arrow_right']) self.pitch += (delta * 90 * self.keys['arrow_up'] + delta * 90 * -self.keys['arrow_down']) self.camera.setHpr(self.heading, self.pitch, 0) # for entry in self.camGroundHandler.getEntries(): # if entry.getFromNode().getName() == "camera": # print "Collision", posStart, self.camera.getPos() # self.camera.setPos(posStart) # break return task.cont
class Player(): def __init__(self, camera, accept, render, loader, maxJPHeight): #initial variables and sounds self.developer = True # Developer tools (building tools) will be accessible if this is turned on. self.gameMode = self.mode0 # the current playerUpdate function that is in use # self.playerModeParameters = () # the parameters being fed into the function above. self.groundContact = False # if the player is on the ground or a surface, gravity will not pull the player below the surface self.jetPack_energy = 100 self.maximumHeight = maxJPHeight # maximum height in which the jetpack can fly to, this is dependent on the map loaded. self.jetPack_AUDIO = loader.loadSfx("assets/base/sounds/jetpack2.wav") self.jetPack_AUDIO.setLoop(True) self.vertical_velocity = 0 # Current Z velocity, positive = Upwards. self.z_velocity = 0 # Current Y velocity self.x_velocity = 0 self.movingZ = False self.movingX = False #initiate GUI self.HUD = GUI() self.playerHolder = render.attachNewNode('player') # camera control - Hiding mouse and using it to rotate the camera props = WindowProperties() props.setCursorHidden(True) props.setMouseMode(WindowProperties.M_relative) base.win.requestProperties(props) # PLAYER MODEL SCENE GRAPH self.thirdPersonCamera_ZOOM = -50 # initial distance of third person camera. self.character = loader.loadModel( 'assets/base/models/playerModel/player.bam') self.toggleFPCam = False # Whether first person camera is on, this is initially off. self.character.setPos(0, 0, 0) self.character.reparentTo(self.playerHolder) self.playerBase = self.playerHolder.attachNewNode('camParent') self.thirdPersonNode = self.playerBase.attachNewNode('thirdPersonCam') camera.reparentTo(self.thirdPersonNode) self.mouseSeconds = [] self.playerHolder.setScale(4) self.monitor = loader.loadModel( 'assets/base/models/faces/playerMonitor.bam') self.monitor.reparentTo(self.playerHolder) self.cTrav = CollisionTraverser() # Horizontal collisions self.pusher = CollisionHandlerPusher() self.pusher.horizontal = True self.colliderNode = CollisionNode("player") self.colliderNode.addSolid(CollisionSphere(0, 0, 0, 2)) self.colliderNode.setFromCollideMask(CollideMask.bit(1)) self.colliderNode.setFromCollideMask(CollideMask.bit(0)) self.colliderNode.setIntoCollideMask(BitMask32.allOff()) collider = self.playerHolder.attachNewNode(self.colliderNode) collider.show() self.pusher.addCollider(collider, self.playerHolder) self.cTrav.addCollider(collider, self.pusher) # Vertical collisions - Downwards self.groundRay = CollisionRay() self.groundRay.setDirection(0, 0, -1) self.groundRayCol = CollisionNode('playerRay') self.groundRayCol.addSolid(self.groundRay) self.groundRayCol.setFromCollideMask(CollideMask.bit(1)) self.groundRayCol.setIntoCollideMask(CollideMask.allOff()) self.groundColNp = self.playerHolder.attachNewNode(self.groundRayCol) self.groundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.groundColNp, self.groundHandler) # Third Person Camera Collision self.cameraRay = CollisionSegment() self.cameraRayNode = CollisionNode('camerRay') self.cameraRayNode.addSolid(self.cameraRay) self.cameraRayNodePath = render.attachNewNode(self.cameraRayNode) self.cameraCollisionHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.cameraRayNodePath, self.cameraCollisionHandler) # Vertical collisions - Upwards self.upwardsRay = CollisionRay() self.upwardsRay.setDirection(0, 0, 1) self.upwardsRayCol = CollisionNode('playerupRay') self.upwardsRayCol.addSolid(self.upwardsRay) self.upwardsRayCol.setFromCollideMask(CollideMask.bit(1)) self.upwardsRayCol.setIntoCollideMask(CollideMask.allOff()) self.upwardsColNp = self.playerHolder.attachNewNode(self.upwardsRayCol) self.upwardsHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.upwardsColNp, self.upwardsHandler) #self.cTrav.showCollisions(render) if self.developer == True: self.tool = buildingTool( "newbuildings", self.playerHolder, loader, accept) # Load up building tool if developer modee is on. #self.setupLighting() # light #initial position self.playerHolder.setPos(45178.3, 43109.3, 0) self.keyMap = { "left": False, "right": False, "forward": False, "backwards": False, "change_camera": False, "leftClick": False, "space": False, "p": False, "scrollup": False, "scrolldown": False } accept("escape", sys.exit) accept("w", self.updateKey, ["forward", True]) # accept("w-up", self.updateKey, ["forward", False]) accept("a", self.updateKey, ["left", True]) accept("a-up", self.updateKey, ["left", False]) accept("s", self.updateKey, ["backwards", True]) accept("s-up", self.updateKey, ["backwards", False]) accept("d", self.updateKey, ["right", True]) accept("d-up", self.updateKey, ["right", False]) accept("c", self.updateKey, ["change_camera", True]) accept("wheel_up", self.updateKey, ["scrollup", True]) accept("wheel_down", self.updateKey, ["scrolldown", True]) accept("p", self.updateKey, ["p", True]) accept("p-up", self.updateKey, ["p", False]) accept("space", self.updateKey, ["space", True]) accept("space-up", self.updateKey, ["space", False]) self.playerMode = playerModes( self.playerBase, self.playerHolder, self.character, self.vertical_velocity, self.z_velocity, self.x_velocity, self.keyMap, self.monitor, self.thirdPersonNode, self.jetPack_energy, self.jetPack_AUDIO, self.thirdPersonCamera_ZOOM, self.toggleFPCam, self.HUD, self.cTrav, self.groundHandler, self.upwardsHandler, self.maximumHeight) def playerUpdate(self, task): # our UPDATE TASK self.gameMode() return task.cont def updateKey(self, key, value): self.keyMap[key] = value if key == "change_camera": self.changeCamera() self.scrollFactor = 10 if key == "scrollup": # third person zoom in/out self.thirdPersonCamera_ZOOM += self.scrollFactor if key == "scrolldown": self.thirdPersonCamera_ZOOM -= self.scrollFactor def changeCamera(self): # Toggle first person camera. if self.toggleFPCam == False: self.toggleFPCam = True else: self.toggleFPCam = False def recenterMouse(self): base.win.movePointer(0, int(base.win.getProperties().getXSize() / 2), int(base.win.getProperties().getYSize() / 2)) def setupLighting(self): plight = PointLight('plight') plight.setColor((1, 1, 1, 1)) plnp = self.playerHolder.attachNewNode(plight) plnp.setPos(0, 1, 7) render.setLight(plnp) # PLAYER MODES, HOW THE USER INTERACTS AND CONTROLS WITH THE USER # MODE 0 # Mode 0 is the default update mode, it allows WASD movement, # mouse controlled camera rotations, first person and third # person switching, it also has GUI display and player physics. def mode0(self): #THIRD PERSON CAMERA COLLISION # print("thirdpersonnode") # print(self.playerBase.getHpr()) # print("pb") # print(self.character.getHpr()) deltaTime = globalClock.getDt() self.movingZ = False self.movingX = False self.walkConstant = 25 self.rotateConstant = 750 # Keyboard controls # LEVITATION STUFF (FORMERLY CALLED JETPACK) if self.keyMap["space"] and self.jetPack_energy > 0: jetpack = 0.00001 * (( (self.playerHolder.getZ()) - self.maximumHeight)**2) + 9.81 self.playerHolder.setZ(self.playerBase, jetpack) self.jetPack_energy -= 15 * deltaTime self.walkConstant = 70 self.jetPack_AUDIO.play() else: self.jetPack_AUDIO.stop() if self.jetPack_energy < 100: self.jetPack_energy += 10 * deltaTime if self.jetPack_energy > 100: self.jetPack_energy = 100 self.HUD.jetpackStatus.text = "Levitation Battery: " + str( int(self.jetPack_energy)) + "%" if (self.keyMap["forward"] or self.keyMap["backwards"]) and (self.keyMap["right"] or self.keyMap["left"]): self.walkConstant = int(((self.walkConstant**2) / 2)**0.5) # WASD MOVEMENT if self.keyMap["forward"]: self.monitor.setH(self.playerBase.getH() - 90) self.movingZ = True self.z_velocity += 5 if self.z_velocity > self.walkConstant: self.z_velocity = self.walkConstant if self.keyMap["right"]: self.monitor.setH(self.playerBase.getH() - 180) self.movingX = True self.x_velocity += 5 if self.x_velocity > self.walkConstant: self.x_velocity = self.walkConstant if self.keyMap["p"]: print(self.playerHolder.getPos()) print(self.thirdPersonCamera_ZOOM) self.gameMode = self.mode1 if self.keyMap["left"]: self.monitor.setH(self.playerBase.getH()) self.movingX = True self.x_velocity -= 5 if self.x_velocity < -self.walkConstant: self.x_velocity = -self.walkConstant if self.keyMap["backwards"]: self.monitor.setH(self.playerBase.getH() + 90) self.movingZ = True self.z_velocity -= 20 if self.z_velocity < -self.walkConstant: self.z_velocity = -self.walkConstant if self.movingZ == False: if self.z_velocity <= 7 or ( self.z_velocity >= -5 and self.z_velocity < 0): # Shaking bug fix self.z_velocity = 0 if self.z_velocity > 0: self.z_velocity -= 10 elif self.z_velocity < 0: self.z_velocity += 10 if self.movingX == False: if self.x_velocity <= 5 or ( self.x_velocity >= -5 and self.x_velocity < 0): # Shaking bug fix self.x_velocity = 0 if self.x_velocity > 0: self.x_velocity -= 10 elif self.x_velocity < 0: self.x_velocity += 10 # MONITOR HEADINGS FOR DOUBLE INPUT if self.keyMap["forward"] and self.keyMap["right"]: self.monitor.setH(self.playerBase.getH() - 135) elif self.keyMap["forward"] and self.keyMap["left"]: self.monitor.setH(self.playerBase.getH() - 45) elif self.keyMap["backwards"] and self.keyMap["left"]: self.monitor.setH(self.playerBase.getH() + 45) elif self.keyMap["backwards"] and self.keyMap["right"]: self.monitor.setH(self.playerBase.getH() + 135) # third person camera control if (self.toggleFPCam == False): # third person camera controls if (base.mouseWatcherNode.hasMouse() == True): mouseposition = base.mouseWatcherNode.getMouse() self.thirdPersonNode.setP(mouseposition.getY() * 30) self.playerBase.setH(mouseposition.getX() * -50) if (mouseposition.getX() < 0.1 and mouseposition.getX() > -0.1): self.playerBase.setH(self.playerBase.getH()) if self.thirdPersonNode.getP() > 90: self.recenterMouse() self.thirdPersonNode.setP(90) # TRACK MOUSE elif self.thirdPersonNode.getP() < -90: self.recenterMouse() self.thirdPersonNode.setP(-90) if self.thirdPersonCamera_ZOOM > -20: # validate zoom self.thirdPersonCamera_ZOOM = -20 elif self.thirdPersonCamera_ZOOM < -390: self.thirdPersonCamera_ZOOM = -390 # CAMERA STUFF # FIRST PERSON CAMERA if self.toggleFPCam: # first person camera controls camera.setPos(self.character.getPos()) # 0,-50,-10 camera.setZ(camera.getZ() + 6) self.playerHolder.hide() if (base.mouseWatcherNode.hasMouse() == True): mouseposition = base.mouseWatcherNode.getMouse() camera.setP(mouseposition.getY() * 20) self.playerBase.setH(mouseposition.getX() * -50) if (mouseposition.getX() < 0.1 and mouseposition.getX() > -0.1): self.playerBase.setH(self.playerBase.getH()) if camera.getP() > 90: self.recenterMouse() camera.setP(90) # TRACK MOUSE elif camera.getP() < -90: self.recenterMouse() camera.setP(-90) else: # takes out of first person perspective if toggleFPS is turned off. self.playerHolder.show() camera.setPos(0, self.thirdPersonCamera_ZOOM, 0) # 0,-50,-4 camera.lookAt(self.character) # movement updates self.playerHolder.setY(self.playerBase, (self.z_velocity * deltaTime)) self.playerHolder.setX(self.playerBase, (self.x_velocity * deltaTime)) # forward/backward rolling axis = self.playerBase.getQuat().getRight() angle = (self.z_velocity * deltaTime * -8) quat = Quat() quat.setFromAxisAngle(angle, axis) newVec = self.character.getQuat() * quat # print(newVec.getHpr()) self.character.setQuat(newVec) # sideways rolling axis = self.playerBase.getQuat().getForward() angle = (self.x_velocity * deltaTime * 8) quat = Quat() quat.setFromAxisAngle(angle, axis) newVec = self.character.getQuat() * quat # print(self.playerBase.getPos()) self.character.setQuat(newVec) self.cameraRay.setPointA(self.playerBase.getPos()) if camera.getPos() != (0, 0, 0): self.cameraRay.setPointB(camera.getPos(base.render)) self.cTrav.traverse(render) # checking for camera collisions entries = list(self.cameraCollisionHandler.entries) for entry in entries: if str(entry.getIntoNodePath())[:19] != "render/worldTerrain": #camera.setPos(entry.getSurfacePoint(self.thirdPersonNode)) self.thirdPersonCamera_ZOOM += 1 # if len(entries) > 0: # if (self.playerHolder.getZ() < entries[-1].getSurfacePoint(render).getZ() + 8): # self.playerHolder.setZ(entries[-1].getSurfacePoint(render).getZ() + 8) # self.vertical_velocity = 0 # checking for collisions - downwards entries = list(self.groundHandler.entries) entries.sort(key=lambda x: x.getSurfacePoint(render).getZ()) self.performGravity = True if self.performGravity == True: self.vertical_velocity -= (deltaTime * 9.81) if self.vertical_velocity <= -15: self.vertical_velocity = -15 self.playerHolder.setPos(self.playerHolder, Vec3(0, 0, self.vertical_velocity)) # Gravity if len(entries) > 0: if (self.playerHolder.getZ() < entries[-1].getSurfacePoint(render).getZ() + 8): self.playerHolder.setZ( entries[-1].getSurfacePoint(render).getZ() + 8) self.vertical_velocity = 0 # checking for collisions - upwards entries = list(self.upwardsHandler.entries) entries.sort(key=lambda x: x.getSurfacePoint(render).getZ()) if len(entries) > 0: for entry in entries: if (self.playerHolder.getZ() > entry.getSurfacePoint(render).getZ() - 70): self.playerHolder.setZ( entry.getSurfacePoint(render).getZ() - 130) # PLAYER MODES, HOW THE USER INTERACTS AND CONTROLS WITH THE USER # MODE 1 # Mode 1 is a test update loop used to test player loop switching. # it simply freezes the controls. def mode1(self): self.playerHolder.hide() self.playerHolder.setHpr(0, 0, 0) if self.keyMap["backwards"]: self.playerHolder.show() self.gameMode = self.mode0
class PlayerController(DirectObject): #----------------- # Initialization #----------------- def __init__(self, engine, environment): self.engine = engine self.players = {} self.environment = environment self.inputQueue = deque() self.collisionDummy = CollisionDummy() self.inputPollWait = 0 self.playerCollisionHandler = CollisionHandlerPusher() self.playerCollisionHandler.addCollider(self.collisionDummy.GetCollisionNode(), self.collisionDummy.GetNode()) self.playerCollisionTraverser = CollisionTraverser('playerCollisionTraverser') self.playerCollisionTraverser.addCollider(self.collisionDummy.GetCollisionNode(), self.playerCollisionHandler) #self.playerCollisionTraverser.showCollisions(render) self.LoadServerPosDebug() self.LoadMyself() self.accept(ViewModeChangeEvent.EventName, self.OnViewModeChange) self.accept(SelectedItemChangeEvent.EventName, self.OnSelectedItemChangeEvent) self.accept(PlayerAttackEvent.EventName, self.OnPlayerAttackEvent) self.accept(PlayerRespawnEvent.EventName, self.OnPlayerRespawnEvent) self.accept(PlayerDeathEvent.EventName, self.OnPlayerDeathEvent) self.accept(TeamSelectEvent.EventName, self.OnTeamSelectEvent) if(not Settings.IS_SERVER): self.sounds = {} self.sounds['blockBreak'] = loader.loadSfx('Assets/Sounds/blockBreak.mp3') self.sounds['blockPlace'] = loader.loadSfx('Assets/Sounds/blockPlace.mp3') #----------------------- # Game Updates / Ticks #----------------------- def FixedUpdate(self): self.UpdatePlayer(self.GetMyself(), self.GetMyself().GetPlayerState(), self.engine.input, Globals.FIXED_UPDATE_DELTA_TIME) def Update(self): if(Settings.IS_SERVER): # Move all of the players that we have input for for elem in self.inputQueue: self.ProcessInput(elem[0], elem[1]) self.inputQueue.clear() # Check to see if anyone fell off the environment self.CheckForFallingPlayers() else: self.GetMyself().UpdateLookingDirection(self.engine.camera.GetDirection()) for player in self.players.values(): player.GetPlayerOverheadName().Update() if(Globals.OFFLINE): self.CheckForFallingPlayers() def CheckForFallingPlayers(self): for player in self.players.values(): if(player.GetPlayerState().GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING): if(player.GetPlayerState().GetValue(PlayerState.POSITION).getZ() < -10): PlayerAttackEvent(player, player, 1000, False).Fire() #-------------------- # Updating a player #-------------------- def UpdatePlayer(self, player, playerState, playerInput, deltaTime): if(playerState.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING_DEAD): return playerState = self.MovePlayer(player, playerState, playerInput, deltaTime) player.SetPos(playerState.GetValue(PlayerState.POSITION)) playerState.UpdateValue(PlayerState.KEYS_PRESSED, playerInput.GetKeys()) self.HandleDeltaStates() player.Update(deltaTime) player.UpdateLookingRayDirection(playerInput.GetLookingDir()) playerState.UpdateValue(PlayerState.LOOKING_DIRECTION, playerInput.GetLookingDir()) if(playerState.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING): self.PlayerInteraction(player, playerInput.click1, playerInput.click3) def MovePlayer(self, player, playerState, playerInput, deltaTime): if(playerState.HasValue(PlayerState.TIME_ELAPSED)): timeElapsed = playerState.GetValue(PlayerState.TIME_ELAPSED) else: timeElapsed = 0 if(playerState.HasValue(PlayerState.Z_VELOCITY)): zVelocity = playerState.GetValue(PlayerState.Z_VELOCITY) else: zVelocity = 0 startPos = playerState.GetValue(PlayerState.POSITION) if(playerState.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING): newPos = self.ApplyInput(playerState, Vec3(startPos), playerInput, timeElapsed, zVelocity, deltaTime) elif(playerState.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_SPECTATE): newPos = self.ApplySpectatorInput(playerState, Vec3(startPos), playerInput, timeElapsed, zVelocity, deltaTime) playerState = self.EnvironmentCollisionCheck(self.environment, player, newPos, startPos, playerState) return playerState def ApplyInput(self, playerState, pos, playerInput, timeElapsed, zVelocity, deltaTime): fDir = Vec3(0, 0, 0) movementSpeed = 5 facingDirection = Vec3(playerInput.GetLookingDir()) facingDirection.setZ(0) facingDirection.normalize() keysPressed = playerInput.GetKeys() # Apply input commands for key in keysPressed: if(key == Globals.KEY_FWD): fDir += facingDirection elif(key == Globals.KEY_BACK): fDir -= facingDirection elif(key == Globals.KEY_RIGHT): strafePoint = facingDirection.cross(Globals.UP_VECTOR) strafePoint.normalize() fDir += strafePoint elif(key == Globals.KEY_LEFT): strafePoint = facingDirection.cross(Globals.UP_VECTOR) strafePoint.normalize() fDir -= strafePoint elif(key == Globals.KEY_JUMP): if(not playerState.HasValue(PlayerState.IS_GROUNDED)): playerState.SetValue(PlayerState.IS_GROUNDED, True) if(playerState.GetValue(PlayerState.IS_GROUNDED)): timeElapsed = 0 zVelocity = 6.55 playerState.UpdateValue(PlayerState.Z_VELOCITY, 5) playerState.UpdateValue(PlayerState.IS_GROUNDED, False) # Calculate new position fDir.normalize() pos = pos + (fDir * movementSpeed * deltaTime) #if(Settings.IS_SERVER or playerState.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING): # Update timeElapsed (for gravity) timeElapsed += deltaTime playerState.UpdateValue(PlayerState.TIME_ELAPSED, timeElapsed) # Figure out effect of gravity dz = (zVelocity * timeElapsed + 0.5 * Settings.GRAVITY * timeElapsed * timeElapsed) - (zVelocity * (timeElapsed - deltaTime) + 0.5 * Settings.GRAVITY * (timeElapsed - deltaTime) * (timeElapsed - deltaTime)) pos.setZ(pos.getZ() + dz) return pos def ApplySpectatorInput(self, playerState, pos, playerInput, timeElapsed, zVelocity, deltaTime): fDir = Vec3(0, 0, 0) movementSpeed = 8 facingDirection = Vec3(playerInput.GetLookingDir()) facingDirection.normalize() keysPressed = playerInput.GetKeys() # Apply input commands for key in keysPressed: if(key == Globals.KEY_FWD): fDir += facingDirection elif(key == Globals.KEY_BACK): fDir -= facingDirection elif(key == Globals.KEY_RIGHT): strafePoint = facingDirection.cross(Globals.UP_VECTOR) strafePoint.normalize() fDir += strafePoint elif(key == Globals.KEY_LEFT): strafePoint = facingDirection.cross(Globals.UP_VECTOR) strafePoint.normalize() fDir -= strafePoint # Calculate new position fDir.normalize() pos = pos + (fDir * movementSpeed * deltaTime) return pos # Draws bullet tracers and bullet impacts with environment def ShowShootingEffects(self, player): lookingDir = player.GetPlayerState().GetValue(PlayerState.LOOKING_DIRECTION) if(player.lookingRayCollisionEntry): loc = player.lookingRayCollisionEntry.getSurfacePoint(render) norm = player.lookingRayCollisionEntry.getSurfaceNormal(render) if(player.lookingRayCollisionEntry.getIntoNodePath().getPythonTag(Globals.TAG_COLLISION) == Globals.COLLISION_BLOCK): bid = player.lookingRayCollisionEntry.getIntoNodePath().getPythonTag(Globals.TAG_BLOCK).GetId() BlockBulletMark(loc, norm, bid) else: BloodBulletMark(loc, norm, 0) else: loc = Point3(player.camNode.getPos(render) + lookingDir * 1000) start = player.currentItem.GetPos(render) + Vec3(0, 0, -0.1) + lookingDir * 5 if((loc - start).lengthSquared() > 16): BulletTracer(start, loc) def OtherPlayerInteraction(self, player, click1, click3): if(isinstance(player.currentItem, Firearm)): player.currentItem.Use() player.PerfromLookingRayCollision(False) if(not Settings.IS_SERVER): self.ShowShootingEffects(player) def PlayerInteraction(self, player, click1, click3): traversed = False playerState = player.GetPlayerState() playerState.SetValue(PlayerState.USED_ITEM, False) currentItem = player.currentItem if(isinstance(currentItem, Firearm)): if(click1): if(currentItem.CanUse()): currentItem.Use() currentItem.Used() playerState.UpdateValue(PlayerState.USED_ITEM, True) player.camNode.setP(player.camNode.getP() + currentItem.recoil) player.camNode.setH(player.camNode.getH() + (0.5 - random.random()) * 2 * currentItem.recoil) if(Settings.IS_SERVER): self.MovePlayersToSnapshot(player, playerState.GetValue(PlayerState.CURRENT_SERVER_TIME) - playerState.GetValue(PlayerState.LAST_SERVER_TIME) + 2) # Add 2 to account for 100ms delay caused by lerping player.PerfromLookingRayCollision() if(Settings.IS_SERVER): self.ReturnPlayersToCurrentPosition() traversed = True # Check for collision with player, if so, do damage if(Settings.IS_SERVER): if(player.lookingRayCollisionEntry): np = player.lookingRayCollisionEntry.getIntoNodePath() collisionTag = np.getPythonTag(Globals.TAG_COLLISION) if(collisionTag != Globals.COLLISION_BLOCK): victim = np.getPythonTag(Globals.TAG_PLAYER) damage = currentItem.GetDamage() hs = False if(collisionTag == Globals.COLLISION_HEAD): damage *= 1.25 hs = True elif(collisionTag == Globals.COLLISION_LEG): damage *= 0.75 # Either frindly fire is on, or the attacker and victim are on separate teams if(Settings.FRIENDLY_FIRE or player.GetPlayerState().GetValue(PlayerState.TEAM) != victim.GetPlayerState().GetValue(PlayerState.TEAM)): PlayerAttackEvent(player, victim, damage, hs).Fire() if(not Settings.IS_SERVER): self.ShowShootingEffects(player) # Auto reload on the client elif(not Settings.IS_SERVER and Settings.AUTO_RELOAD and currentItem.GetCurrentClipAmmo() == 0 and currentItem.GetTotalRemainingAmmo() > 0): player.Reload() if(click3): if(not Settings.IS_SERVER): currentItem.ToggleADS() if(not traversed): player.PerfromLookingRayCollision() if(isinstance(currentItem, Builder)): if(click1): selectedBlock = player.GetSelectedBlock() if(selectedBlock and currentItem.CanUse()): playerState.UpdateValue(PlayerState.USED_ITEM, True) self.environment.DestroyBlock(int(selectedBlock.getX()), int(selectedBlock.getY()), int(selectedBlock.getZ())) currentItem.Used() if(not Settings.IS_SERVER): self.sounds['blockBreak'].play() if(click3): adjacentBlockPoint = player.GetAdjacentBlock() if(adjacentBlockPoint and currentItem.CanUse()): self.environment.AddBlock(int(adjacentBlockPoint.getX()), int(adjacentBlockPoint.getY()), int(adjacentBlockPoint.getZ()), currentItem.GetBlockId()) currentItem.Used() if(not Settings.IS_SERVER): self.sounds['blockPlace'].play() def MovePlayersToSnapshot(self, currentPlayer, numFramesBack): for player in self.players.values(): player.currentPosition = player.pNode.getPos() if(player != currentPlayer and player.GetPlayerState().GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING): player.MovePosToPriorSnapshot(numFramesBack) def ReturnPlayersToCurrentPosition(self): for player in self.players.values(): player.ReturnToCurrentPosition() def IsColliding(self, player, x, y, z): blocks = self.engine.GetEnvironment().GetBlocks() blockPoss = [[x, y, z], [x+1, y, z], [x, y+1, z], [x-1, y, z], [x, y-1, z], [x, y, z+1], [x+1, y, z+1], [x, y+1, z+1], [x-1, y, z+1], [x, y-1, z+1], [x, y, z+2], [x+1, y, z+2], [x, y+1, z+2], [x-1, y, z+2], [x, y-1, z+2], [x+1, y+1, z], [x-1, y+1, z], [x+1, y-1, z], [x-1, y-1, z], [x+1, y+1, z+1], [x-1, y+1, z+1], [x+1, y-1, z+1], [x-1, y-1, z+1], [x+1, y+1, z+2], [x-1, y+1, z+2], [x+1, y-1, z+2], [x-1, y-1, z+2]] for (x1, y1, z1) in blockPoss: if(self.engine.GetEnvironment().AreValidIndices(x1, y1, z1)): if(blocks[x1][y1][z1].IsSolid() and player.boundingBox.IsCollidingWithBlock(x1, y1, z1)): return True return False def EnvironmentCollisionCheck(self, environment, player, newPos, lastGoodPos, playerState): x = int(lastGoodPos.getX()) y = int(lastGoodPos.getY()) z = int(lastGoodPos.getZ()) # Check Z component z = int(newPos.getZ()) player.pNode.setZ(newPos.getZ()) if(self.IsColliding(player, x, y, z)): player.pNode.setZ(player.pNode.getZ() + player.boundingBox.lastAxisCollisions[2]) z = int(player.pNode.getZ()) playerState.UpdateValue(PlayerState.TIME_ELAPSED, 0) playerState.UpdateValue(PlayerState.Z_VELOCITY, 0) if(newPos.getZ() < lastGoodPos.getZ()): playerState.UpdateValue(PlayerState.IS_GROUNDED, True) else: playerState.UpdateValue(PlayerState.IS_GROUNDED, False) # Check X component x = int(newPos.getX()) player.pNode.setX(newPos.getX()) if(self.IsColliding(player, x, y, z)): player.pNode.setX(player.pNode.getX() + player.boundingBox.lastAxisCollisions[0]) x = int(player.pNode.getX()) # Check Y component y = int(newPos.getY()) player.pNode.setY(newPos.getY()) if(self.IsColliding(player, x, y, z)): player.pNode.setY(player.pNode.getY() + player.boundingBox.lastAxisCollisions[1]) y = int(player.pNode.getY()) playerState.UpdateValue(PlayerState.POSITION, player.GetPos()) return playerState #------------------------------ # Player Deaths and Respawning #------------------------------ def OnPlayerRespawnEvent(self, event): player = event.GetPlayer() pos = self.engine.game.FindRespawnPoint(None) playerState = player.GetPlayerState() if(playerState): playerState.UpdateValue(PlayerState.PLAYING_STATE, PlayerState.PS_PLAYING) playerState.UpdateValue(PlayerState.POSITION, pos) playerState.UpdateValue(PlayerState.HEALTH, 100) player.ChangeItem(player.currentItem) player.SetPos(pos) self.RefillAllAmmo(player) player.OnRespawn() if(Settings.IS_SERVER): self.engine.server.SendPlayerRespawn(playerState) print 'player respawned', playerState.GetValue(PlayerState.NAME), playerState.GetValue(PlayerState.CURRENT_ITEM) if(not Settings.IS_SERVER): self.engine.scoreboard.UpdateIsAlive(playerState.GetValue(PlayerState.PID), True) else: del player def OnPlayerDeathEvent(self, event): victim = event.GetVictim() attacker = event.GetAttacker() wasHS = event.WasHeadshot() playerState = victim.GetPlayerState() playerState.UpdateValue(PlayerState.PLAYING_STATE, PlayerState.PS_PLAYING_DEAD) print 'player Died', playerState.GetValue(PlayerState.NAME) victim.OnDeath() if(Settings.IS_SERVER or Globals.OFFLINE): taskMgr.doMethodLater(Game.RESPAWN_TIME, PlayerRespawnEvent(victim, None).Fire, 'RespawnPlayer_%s' % (playerState.GetValue(PlayerState.PID))) if(not Settings.IS_SERVER and victim == self.GetMyself()): self.engine.respawnCountdown.Start() if(not Settings.IS_SERVER): self.engine.scoreboard.UpdateIsAlive(playerState.GetValue(PlayerState.PID), False) #------------------------ # Client only functions #------------------------ # This event only gets fired when our player selects a team def OnTeamSelectEvent(self, event): teamId = event.GetTeam() self.GetMyself().OnTeamChange(teamId) self.engine.scoreboard.UpdateTeam(Globals.MY_PID, Globals.MY_TEAM) def VerifyPrediction(self, serverState, snapshots): if(not serverState.HasValue(PlayerState.POSITION)): return if(Globals.DEBUG_CSP): print 'SERVER', serverState.GetValue(PlayerState.TIMESTAMP), serverState.GetValue(PlayerState.POSITION) print 'ME', snapshots[0].GetTimestamp(), snapshots[0].GetPosition() for x in snapshots: print 'SS', x.GetTimestamp(), x.GetPosition() diff = (serverState.GetValue(PlayerState.POSITION) - snapshots[0].GetPosition()) if(diff.length() > 0.001): print 'DIFF', diff myself = self.GetMyself() myState = myself.GetPlayerState() for snapshot in snapshots: serverState.SetValue(PlayerState.PLAYING_STATE, PlayerState.PS_PLAYING) serverState = self.MovePlayer(myself, serverState, snapshot.GetInput(), Globals.FIXED_UPDATE_DELTA_TIME) snapshot.pos = serverState.GetValue(PlayerState.POSITION) myState.UpdateValue(PlayerState.POSITION, serverState.GetValue(PlayerState.POSITION)) myself.SetPos(serverState.GetValue(PlayerState.POSITION)) return snapshots def HandleDeltaStates(self): if(not Settings.IS_SERVER): for player in self.players.values(): state = player.GetPlayerState() deltaState = state.GetDeltaVars() if(not Settings.IS_SERVER): state.ClearDeltaVars() for dVar in deltaState: # If isWalking changed if(dVar == PlayerState.IS_WALKING): if(state.GetValue(dVar)): # If the player is now walking player.RequestFSMTransition('IdleToWalk') else: # If the player stopped moving player.RequestFSMTransition('WalkToIdle') # Given a dictionary of playerstate updates from the server, # apply them to the players in the game def HandleServerPlayerStates(self, playerStates): for pid, playerState in playerStates.iteritems(): if(pid != self.GetMyId()): if(not pid in self.players.keys()): continue player = self.GetPlayer(pid) for pVar, value in playerState.vars.iteritems(): if(pVar == PlayerState.POSITION): self.GetPlayerPlayerState(player).UpdateValue(PlayerState.POSITION, value) player.LerpTo(value) elif(pVar == PlayerState.LOOKING_DIRECTION): self.GetPlayerPlayerState(player).UpdateValue(PlayerState.LOOKING_DIRECTION, value) player.UpdateLookingDirection(value) player.UpdateLookingRayDirection(value) def OtherPlayerWalkingChange(self, player, isWalking): if(isWalking): player.RequestFSMTransition('IdleToWalk') else: player.RequestFSMTransition('WalkToIdle') def HealthChange(self, player, health): player.GetPlayerState().UpdateValue(PlayerState.HEALTH, health) if(player == self.GetMyself()): PlayerHealthEvent(player, health).Fire() #------------------------ # Server only functions #------------------------ def IsFull(self): return len(self.players) > Globals.MAX_PLAYERS def QueueClientInput(self, player, keys, lookingDir, clicks, timestamp): newInput = Input(keys, lookingDir, clicks, timestamp) self.inputQueue.append([player, newInput]) playerState = player.GetPlayerState() playerState.timestamp = timestamp return newInput def ProcessInput(self, player, newInput): if(player in self.players.values()): playerInputBuffer = player.GetInputBuffer() playerInputBuffer.UpdateInput(newInput) if(playerInputBuffer.GoodToGo()): newestInput = playerInputBuffer.GetNewestInput() bufferedInput = playerInputBuffer.GetBufferedInput() playerState = player.GetPlayerState() playerState.UpdateValue(PlayerState.KEYS_PRESSED, bufferedInput.GetKeys()) if(playerState.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING): # Run a Fixed MovementUpdate as many times as necessary while(newestInput.GetTimestamp() - playerState.GetValue(PlayerState.TIMESTAMP) > Globals.FIXED_UPDATE_DELTA_TIME): self.UpdatePlayer(player, playerState, bufferedInput, Globals.FIXED_UPDATE_DELTA_TIME) playerState.SetValue(PlayerState.TIMESTAMP, playerState.GetValue(PlayerState.TIMESTAMP) + Globals.FIXED_UPDATE_DELTA_TIME) #print 'processing input for player ', playerState.GetValue(PlayerState.PID) else: print 'spectator', playerState.GetValue(PlayerState.PID) else: player.GetPlayerState().SetValue(PlayerState.TIMESTAMP, newInput.GetTimestamp()) #--------------------------------------- # Adding and Removing Players from Game #--------------------------------------- def AddNewPlayer(self, pid, name, teamId, playingState = PlayerState.PS_SPECTATE): print 'adding new player', pid if(pid not in self.players.keys()): player = Player() self.players[pid] = player playerState = player.GetPlayerState() playerState.SetValue(PlayerState.PID, pid) playerState.SetValue(PlayerState.NAME, name) playerState.SetValue(PlayerState.TEAM, teamId) playerState.SetValue(PlayerState.PLAYING_STATE, playingState) print 'added player', pid, name player.CreateNameTextNode(name) player.OnTeamChange(teamId) player.ShowPlayerModel() if(pid != Globals.MY_PID): player.RemoveSelectionGeom() if(teamId == Globals.MY_TEAM): player.ShowNameAboveHead() else: player.HidePlayerModel() def RemovePlayer(self, pid): player = self.players[pid] player.Destroy() del self.players[pid] taskMgr.remove('RespawnPlayer_%s' %(pid)) def HidePlayerModel(self, playerObject): playerObject.HidePlayerModel() def ShowPlayerModel(self, playerObject): playerObject.ShowPlayerModel() # THIS IS TEMPORARY def RefillAllAmmo(self, player): for item in player.itemModels.values(): if(isinstance(item, Firearm)): item.RefillAmmo() if(not Settings.IS_SERVER and player.GetPlayerState().GetValue(PlayerState.PID) == Globals.MY_PID): inv = player.GetPlayerState().GetValue(PlayerState.MAIN_INVENTORY) for itemStack in inv.GetItemStacks(): if(isinstance(itemStack.GetItem(), Firearm)): itemStack.GetItem().RefillAmmo() #-------------------- # Event Handling #----------------- def OnSelectedItemChangeEvent(self, event): self.GetMyself().OnSelectedItemChangeEvent(event) # Figure out what item the player now has. If they've had # it before, use the already loaded model. Otherwise, # load the model def OtherPlayerItemChange(self, player, itemId, extraData = None): itemClass = ItemId.ToItem(itemId) #player.GetPlayerState().UpdateValue(PlayerState.CURRENT_ITEM, ItemId.NoItem) #player.GetPlayerState().UpdateValue(PlayerState.CURRENT_ITEM, itemId) if(itemId not in player.itemModels.keys()): if(itemClass): item = itemClass() item.playerId = player.GetPlayerState().GetValue(PlayerState.PID) else: item = None player.itemModels[itemId] = item if(extraData): print 'changing with extra data' player.GetPlayerState().SetValue(PlayerState.CURRENT_ITEM, ItemId.Unknown) player.GetPlayerState().UpdateValue(PlayerState.CURRENT_ITEM, itemId) if(itemId == ItemId.Builder): player.itemModels[itemId].SetBlockId(extraData[0]) if(not Settings.IS_SERVER): player.itemModels[itemId].UpdateTexture() #player.GetPlayerState().UpdateValue(PlayerState.CURRENT_ITEM, itemId) player.ThirdPersonChangeItem(player.itemModels[itemId]) def OnViewModeChange(self, event): if(event.GetViewMode() == Camera.FirstPersonMode): self.GetMyself().HidePlayerModel() else: self.GetMyself().ShowPlayerModel() def OnPlayerAttackEvent(self, event): victim = event.GetVictim() # Update the victim's health health = victim.GetPlayerState().GetValue(PlayerState.HEALTH) health = max(0, health - event.GetDamage()) victim.GetPlayerState().UpdateValue(PlayerState.HEALTH, health) player = event.GetPlayer() player.GetPlayerState().UpdateValue(PlayerState.VICTIM, victim) if(event.WasHeadshot() and health == 0): player.GetPlayerState().UpdateValue(PlayerState.VICTIM_ATTACK_TYPE, PlayerState.VAT_BOTH) elif(event.WasHeadshot()): player.GetPlayerState().UpdateValue(PlayerState.VICTIM_ATTACK_TYPE, PlayerState.VAT_HEADSHOT) elif(health == 0): player.GetPlayerState().UpdateValue(PlayerState.VICTIM_ATTACK_TYPE, PlayerState.VAT_KILLSHOT) else: player.GetPlayerState().UpdateValue(PlayerState.VICTIM_ATTACK_TYPE, PlayerState.VAT_NONE) if(health == 0): PlayerDeathEvent(victim, player, event.WasHeadshot()).Fire() print 'PLAYER DIEEED' def ResetPlayerNames(self): for player in self.players.values(): if(player != self.GetMyself()): if(player.GetPlayerState().GetValue(PlayerState.TEAM) != Globals.MY_TEAM): # THIS IS REALLY BAD player.nameText.reshowOnInView = False player.nameText.Hide() else: player.nameText.reshowOnInView = True player.ShowNameAboveHead() #------------------------------------------------ # Getting Information for All Players #------------------------------------------------ def GetAllPlayers(self): return self.players.values() def GetAllPlayerStates(self): ps = [] for player in self.players.values(): ps.append(player.GetPlayerState()) return ps def GetAllPlayingPlayerStates(self): ps = [] for player in self.players.values(): ps1 = player.GetPlayerState() if(ps1.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING): ps.append(ps1) return ps def GetAllPlayerNodes(self): nodes = [] for p in self.GetPlayers(): nodes.append(p.pNode) return nodes #------------------------------------------------ # Getting information for One Player #------------------------------------------------ def GetPlayer(self, pid): if(pid in self.players.keys()): return self.players[pid] else: return None def GetPlayerPlayerState(self, player, pid = None): if(player is None): return self.GetPlayerPlayerState(self.GetPlayer(pid)) else: return player.GetPlayerState() def GetPlayerPickerRay(self, player): return player.lookingRay def GetPlayerCollision(self, player): return player.collisionGeom def GetPlayerEyePosition(self, player): return player.camNode.getPos(render) def GetPlayerLookingDirection(self, player): return player.lookingDirection #------------------------------------------------ # Getting information for Myself #------------------------------------------------ def GetMyself(self): return self.players[Globals.MY_PID] def GetMyId(self): return Globals.MY_PID def GetMyCamNode(self): return self.GetMyself().camNode def GetMyPlayerState(self): return self.GetPlayerPlayerState(self.GetMyself()) def GetMyDeltaState(self): return self.GetMyself().GetPlayerState().GetDeltaVars() #-------------------------------------------------------- # Helper Functions for Setup of PlayerController Object #-------------------------------------------------------- def LoadServerPosDebug(self): self.serverPlayer = loader.loadModel('Assets/Models/Players/ralph') self.serverPlayer.setScale(0.36) self.serverPlayer.reparentTo(render) if(not Globals.DEBUG_CSP): self.serverPlayer.hide() def LoadMyself(self): print 'loading self' if(not Settings.IS_SERVER): self.AddNewPlayer(pid = Globals.MY_PID, name = Settings.NAME, teamId = Game.SPECTATE, playingState = PlayerState.PS_SPECTATE) #------------------------------------------------------------- # Helper Functions for Destruction of PlayerController Object #------------------------------------------------------------- def Destroy(self): self.ignoreAll() for player in self.players.values(): player.Destroy() del self.players del self.environment del self.inputQueue del self.collisionDummy del self.inputPollWait del self.playerCollisionHandler del self.playerCollisionTraverser
class Physics: def __init__(self): self.rayCTrav = CollisionTraverser("collision traverser for ray tests") #self.pusher = PhysicsCollisionHandler() self.pusher = CollisionHandlerPusher() self.pusher.addInPattern('%fn-in-%in') self.pusher.addOutPattern('%fn-out-%in') self.pusher.addInPattern('%fn-in') self.pusher.addOutPattern('%fn-out') def startPhysics(self): #self.actorNode = ActorNode("playerPhysicsControler") #base.physicsMgr.attachPhysicalNode(self.actorNode) #self.actorNode.getPhysicsObject().setMass(self.player_mass) #self.mainNode = render.attachNewNode(self.actorNode) self.mainNode = render.attachNewNode("CharacterColliders") self.reparentTo(self.mainNode) charCollisions = self.mainNode.attachNewNode( CollisionNode(self.char_collision_name)) #charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/4.0, self.player_height/4.0)) #charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/4.0*3.05, self.player_height/4.0)) charCollisions.node().addSolid( CollisionSphere(0, 0, self.player_height / 2.0, self.player_height / 4.0)) charCollisions.node().setIntoCollideMask(BitMask32(0x80)) # 1000 0000 if self.show_collisions: charCollisions.show() self.pusher.addCollider(charCollisions, self.mainNode) base.cTrav.addCollider(charCollisions, self.pusher) charFFootCollisions = self.attachNewNode(CollisionNode("floor_ray")) charFFootCollisions.node().addSolid(CollisionRay(0, 0, 0.5, 0, 0, -1)) #charFFootCollisions.node().addSolid(CollisionSegment((0, 0, 0.2), (0, 0, -1))) charFFootCollisions.node().setIntoCollideMask(BitMask32.allOff()) charFFootCollisions.node().setFromCollideMask( BitMask32(0x7f)) # 0111 1111 if self.show_collisions: charFFootCollisions.show() self.floor_handler = CollisionHandlerFloor() self.floor_handler.addCollider(charFFootCollisions, self.mainNode) #self.floor_handler.setOffset(0) self.floor_handler.setMaxVelocity(5) base.cTrav.addCollider(charFFootCollisions, self.floor_handler) self.accept("{}-in".format(self.char_collision_name), self.checkCharCollisions) self.raytest_segment = CollisionSegment(0, 1) self.raytest_np = render.attachNewNode(CollisionNode("testRay")) self.raytest_np.node().addSolid(self.raytest_segment) self.raytest_np.node().setIntoCollideMask(BitMask32.allOff()) self.raytest_np.node().setFromCollideMask(BitMask32(0x7f)) # 0111 1111 if self.show_collisions: self.raytest_np.show() self.raytest_queue = CollisionHandlerQueue() self.rayCTrav.addCollider(self.raytest_np, self.raytest_queue) def stopPhysics(self): self.raytest_segment.removeNode() self.pusher.clearColliders() self.floor_handler.clearColliders() self.rayCTrav.clearColliders() def updatePlayerPos(self, speed, heading, dt): if heading is not None: self.mainNode.setH(camera, heading) self.mainNode.setP(0) self.mainNode.setR(0) self.mainNode.setFluidPos(self.mainNode, speed) self.doStep() def checkCharCollisions(self, args): self.doStep() def doStep(self): # do the step height check tmpNP = self.mainNode.attachNewNode("temporary") tmpNP.setPos(self.mainNode, 0, 0, -self.stepheight) pointA = self.mainNode.getPos(render) pointA.setZ(pointA.getZ() + self.player_height / 1.8) pointB = tmpNP.getPos(render) if pointA == pointB: return char_step_collision = self.getFirstCollisionInLine(pointA, pointB) tmpNP.removeNode() if char_step_collision is not None: self.mainNode.setFluidZ(char_step_collision.getZ()) return True return False def getFirstCollisionInLine(self, pointA, pointB): """A simple raycast check which will return the first collision point as seen from point A towards pointB""" self.raytest_segment.setPointA(pointA) self.raytest_segment.setPointB(pointB) self.rayCTrav.traverse(render) self.raytest_queue.sortEntries() pos = None if self.raytest_queue.getNumEntries() > 0: pos = self.raytest_queue.getEntry(0).getSurfacePoint(render) return pos
class Game(ShowBase): def __init__(self): ShowBase.__init__(self) # Call various initialization methods on class self.windowInit(1280, 720) self.levelInit("Models/Environment/environment") self.lightingInit() self.playerInit() self.cameraInit(pos=Vec3(0, 0, 32), hpr=Vec3(0, -90, 0)) self.inputInit() self.collisionInit() self.tempEnemy = WalkingEnemy(Vec3(5, 0, 0)) # Set up a task that we'll run consistently self.updateTask = taskMgr.add(self.update, "update") def windowInit(self, h, w): properties = WindowProperties() properties.setSize(h, w) self.win.requestProperties(properties) def levelInit(self, levelname): # Load a backdrop model and attach it to the Scene Graph self.environment = loader.loadModel(levelname) self.environment.reparentTo(render) # Set up level collision self.cTrav = CollisionTraverser() self.pusher = CollisionHandlerPusher() def lightingInit(self): # Kind of dark with just an ambient light, maybe a directional light eh mainLight = DirectionalLight("main light") self.mainLightNodePath = render.attachNewNode(mainLight) self.mainLightNodePath.setHpr(45, -45, 0) render.setLight(self.mainLightNodePath) # hook us up some automatic perpixel lighting render.setShaderAuto() def playerInit(self): # Initialize and render player character self.player = Player() self.player.actor.reparentTo(render) def cameraInit(self, pos, hpr): self.camera.setPos(pos) self.camera.setHpr(hpr) def collisionInit(self): self.pusher.addCollider(self.player.collider, self.player.actor) self.cTrav.addCollider(self.player.collider, self.pusher) self.pusher.setHorizontal(True) wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setY(8.0) wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setY(-8.0) wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setX(8.0) wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setX(-8.0) def inputInit(self): # Input states self.keyMap = { "up": False, "down": False, "left": False, "right": False, "shoot": False } # Disable the default camera control self.disableMouse() # Set up events to call self.updateKeyMap with args when certain keys are pressed or released self.accept("w", self.updateKeyMap, ["up", True]) self.accept("w-up", self.updateKeyMap, ["up", False]) self.accept("s", self.updateKeyMap, ["down", True]) self.accept("s-up", self.updateKeyMap, ["down", False]) self.accept("a", self.updateKeyMap, ["left", True]) self.accept("a-up", self.updateKeyMap, ["left", False]) self.accept("d", self.updateKeyMap, ["right", True]) self.accept("d-up", self.updateKeyMap, ["right", False]) self.accept("mouse1", self.updateKeyMap, ["shoot", True]) self.accept("mouse1-up", self.updateKeyMap, ["shoot", False]) # keyMap setter def updateKeyMap(self, controlName, controlState): self.keyMap[controlName] = controlState # Main game logic we have running every frame def update(self, task): dt = globalClock.getDt() self.player.update(self.keyMap, dt) self.tempEnemy.update(self.player, dt) return task.cont
# Set the object's collision node to render as visible. smileyC.show() # Load another model. frowney = loader.loadModel('frowney') # Reparent the model to render. frowney.reparentTo(render) # Set the position of the model in the scene. frowney.setPos(5, 25, 0) # Create a collsion node for this object. cNode = CollisionNode('frowney') # Attach a collision sphere solid to the collision node. cNode.addSolid(CollisionSphere(0, 0, 0, 1.1)) # Attach the collision node to the object's model. frowneyC = frowney.attachNewNode(cNode) # Set the object's collision node to render as visible. frowneyC.show() # Add the Pusher collision handler to the collision traverser. base.cTrav.addCollider(frowneyC, pusher) # Add the 'frowney' collision node to the Pusher collision handler. pusher.addCollider(frowneyC, frowney, base.drive.node()) # Have the 'smiley' sphere moving to help show what is happening. frowney.posInterval(5, Point3(5, 25, 0), startPos=Point3(-5, 25, 0), fluid=1).loop() # Run the scene. Move around with the mouse to see how the moving sphere changes # course to avoid the one attached to the camera. run()
class RoamingRalphDemo(ShowBase): def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) # This is used to store which keys are currently pressed. self.keyMap = { "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0, } # Post the instructions self.title = addTitle( "Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)") self.inst1 = addInstructions(0.06, "[ESC]: Quit") self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left") self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right") self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward") self.inst5 = addInstructions(0.30, "[Down Arrow]: Walk Ralph Backward") self.inst6 = addInstructions(0.36, "[A]: Rotate Camera Left") self.inst7 = addInstructions(0.42, "[S]: Rotate Camera Right") # 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("models/world") self.environ.reparentTo(render) # We do not have a skybox, so we will just use a sky blue background color self.setBackgroundColor(0.53, 0.80, 0.92, 1) # Create the main character, Ralph ralphStartPos = self.environ.find("**/start_point").getPos() self.ralph = Actor("models/ralph", {"run": "models/ralph-run", "walk": "models/ralph-walk"}) self.ralph.reparentTo(render) self.ralph.setScale(.2) self.ralph.setPos(ralphStartPos + (0, 0, 1.5)) # Create a floater object, which floats 2 units above ralph. We # use this as a target for the camera to look at. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(self.ralph) self.floater.setZ(2.0) # Accept the control keys for movement and rotation self.accept("escape", sys.exit) self.accept("arrow_left", self.setKey, ["left", True]) self.accept("arrow_right", self.setKey, ["right", True]) self.accept("arrow_up", self.setKey, ["forward", True]) self.accept("arrow_down", self.setKey, ["backward", True]) self.accept("a", self.setKey, ["cam-left", True]) self.accept("s", self.setKey, ["cam-right", True]) self.accept("arrow_left-up", self.setKey, ["left", False]) self.accept("arrow_right-up", self.setKey, ["right", False]) self.accept("arrow_up-up", self.setKey, ["forward", False]) self.accept("arrow_down-up", self.setKey, ["backward", False]) self.accept("a-up", self.setKey, ["cam-left", False]) self.accept("s-up", self.setKey, ["cam-right", False]) taskMgr.add(self.move, "moveTask") # Set up the camera self.disableMouse() self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2) self.cTrav = CollisionTraverser() # Use a CollisionHandlerPusher to handle collisions between Ralph and # the environment. Ralph is added as a "from" object which will be # "pushed" out of the environment if he walks into obstacles. # # Ralph is composed of two spheres, one around the torso and one # around the head. They are slightly oversized since we want Ralph to # keep some distance from obstacles. self.ralphCol = CollisionNode('ralph') self.ralphCol.addSolid(CollisionSphere(center=(0, 0, 2), radius=1.5)) self.ralphCol.addSolid(CollisionSphere(center=(0, -0.25, 4), radius=1.5)) self.ralphCol.setFromCollideMask(CollideMask.bit(0)) self.ralphCol.setIntoCollideMask(CollideMask.allOff()) self.ralphColNp = self.ralph.attachNewNode(self.ralphCol) self.ralphPusher = CollisionHandlerPusher() self.ralphPusher.horizontal = True # Note that we need to add ralph both to the pusher and to the # traverser; the pusher needs to know which node to push back when a # collision occurs! self.ralphPusher.addCollider(self.ralphColNp, self.ralph) self.cTrav.addCollider(self.ralphColNp, self.ralphPusher) # 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 ralph'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. self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0, 0, 9) self.ralphGroundRay.setDirection(0, 0, -1) self.ralphGroundCol = CollisionNode('ralphRay') self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0)) self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0, 0, 9) self.camGroundRay.setDirection(0, 0, -1) self.camGroundCol = CollisionNode('camRay') self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(CollideMask.bit(0)) self.camGroundCol.setIntoCollideMask(CollideMask.allOff()) self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # Uncomment this line to see the collision rays #self.ralphColNp.show() #self.camGroundColNp.show() # Uncomment this line to show a visual representation of the # collisions occuring #self.cTrav.showCollisions(render) # Create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.3, .3, .3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection((-5, -5, -5)) directionalLight.setColor((1, 1, 1, 1)) directionalLight.setSpecularColor((1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight)) # Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value # Accepts arrow keys to move either the player or the menu cursor, # Also deals with grid checking and collision detection def move(self, task): # Get the time that elapsed since last frame. We multiply this with # the desired speed in order to find out with which distance to move # in order to achieve that desired speed. dt = globalClock.getDt() # If the camera-left key is pressed, move camera left. # If the camera-right key is pressed, move camera right. if self.keyMap["cam-left"]: self.camera.setX(self.camera, -20 * dt) if self.keyMap["cam-right"]: self.camera.setX(self.camera, +20 * dt) # If a move-key is pressed, move ralph in the specified direction. if self.keyMap["left"]: self.ralph.setH(self.ralph.getH() + 300 * dt) if self.keyMap["right"]: self.ralph.setH(self.ralph.getH() - 300 * dt) if self.keyMap["forward"]: self.ralph.setY(self.ralph, -20 * dt) if self.keyMap["backward"]: self.ralph.setY(self.ralph, +10 * dt) # If ralph is moving, loop the run animation. # If he is standing still, stop the animation. currentAnim = self.ralph.getCurrentAnim() if self.keyMap["forward"]: if currentAnim != "run": self.ralph.loop("run") elif self.keyMap["backward"]: # Play the walk animation backwards. if currentAnim != "walk": self.ralph.loop("walk") self.ralph.setPlayRate(-1.0, "walk") elif self.keyMap["left"] or self.keyMap["right"]: if currentAnim != "walk": self.ralph.loop("walk") self.ralph.setPlayRate(1.0, "walk") else: if currentAnim is not None: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False # If the camera is too far from ralph, move it closer. # If the camera is too close to ralph, move it farther. camvec = self.ralph.getPos() - self.camera.getPos() camvec.setZ(0) camdist = camvec.length() camvec.normalize() if camdist > 10.0: self.camera.setPos(self.camera.getPos() + camvec * (camdist - 10)) camdist = 10.0 if camdist < 5.0: self.camera.setPos(self.camera.getPos() - camvec * (5 - camdist)) camdist = 5.0 # Normally, we would have to call traverse() to check for collisions. # However, the class ShowBase that we inherit from has a task to do # this for us, if we assign a CollisionTraverser to self.cTrav. #self.cTrav.traverse(render) # Adjust ralph's Z coordinate. If ralph's ray hit terrain, # update his Z entries = list(self.ralphGroundHandler.entries) entries.sort(key=lambda x: x.getSurfacePoint(render).getZ()) for entry in entries: if entry.getIntoNode().getName() == "terrain": self.ralph.setZ(entry.getSurfacePoint(render).getZ()) # Keep the camera at one unit above the terrain, # or two units above ralph, whichever is greater. entries = list(self.camGroundHandler.entries) entries.sort(key=lambda x: x.getSurfacePoint(render).getZ()) for entry in entries: if entry.getIntoNode().getName() == "terrain": self.camera.setZ(entry.getSurfacePoint(render).getZ() + 1.5) if self.camera.getZ() < self.ralph.getZ() + 2.0: self.camera.setZ(self.ralph.getZ() + 2.0) # The camera should look in ralph's direction, # but it should also try to stay horizontal, so look at # a floater which hovers above ralph's head. self.camera.lookAt(self.floater) return task.cont
class RoamingRalphDemo(ShowBase): def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) self.orbCollisionHandler = CollisionHandlerQueue() self.cTrav = CollisionTraverser() self.cTrav.setRespectPrevTransform(True) self.startgame = False self.sound=loader.loadSfx("models/0614.ogg") self.sound2=loader.loadSfx("models/01-main-theme.mp3") self.sound2.play() status=self.sound2.status() #hbPath = NodePath() utils.setUpKeys(self) utils.loadModels(self) utils.setUpLighting(self) #utils.setUpFloatingSpheres(self) utils.setUpRalphsShot(self) utils.setUpCamera(self) utils.setUpCollisionSpheres(self) self.healthTxt = utils.addInstructions(.06,"Health: 100") self.orbTxt = utils.addInstructions(.18,"Orbs: 0") self.hitsTxt = utils.addInstructions(.28,"Enemy Hits: 0") self.strHealthStatus = str(self.healthTxt) # Create a frame frame = DirectFrame(text = "main", scale = 0.001) # Add button self.flagstartbutton = 0 self.imageObject = OnscreenImage(image = 'models/instapage.jpg', pos = (0, 0, 0), scale=1.1) self.imageObject2 = OnscreenImage(image = 'models/gap.jpg', pos = (-2.15, 0, 0), scale=1.1) self.imageObject3 = OnscreenImage(image = 'models/gap.jpg', pos = (2.15, 0, 0), scale=1.1) self.helpOn = DirectButton(text = ("Start", "on/off", "Start", "disabled"), scale=.10, pos=(-1.1,0,-.9), command=utils.buttonClickedOn, extraArgs=[self, self.imageObject,self.imageObject2,self.imageObject3, self.flagstartbutton]) #helpOff = DirectButton(text = ("helpOff", "on/off", "helpOff", "disabled"), scale=.10, pos=(-0.5,0,-1), command=utils.buttonClickedOff, extraArgs=[self, self.imageObject, self.buttonflag]) # mytimer = DirectLabel() # mytimer.reparentTo(render) # mytimer.setY(7) #Create 4 buttons #print self.strHealthStatus #incBar(100) self.vec = LVector3(0,1,0)#vector for pawns shot # Create a frame #frame = DirectFrame(text = "main", scale = 0.001) # Add button #bar = DirectWaitBar(text = "", value = 50, pos = (0,.4,.4)) #bar.reparent(render) # Game state variables self.isMoving = False self.jumping = False self.vz = 0 self.numOrbs = 0 self.healthCount = 100 self.enemyhits = 0 #self.shotList = [] #self.sphere = CollisionBox((self.ralph.getX() + -10,self.ralph.getY(),self.ralph.getZ()),10,10,10) self.ralphBox1 = CollisionBox((0,2.5,3.5),1.5,0.5,1.5) cnodepath = self.ralph.attachNewNode((CollisionNode("ralphColNode"))) cnodepath.node().addSolid(self.ralphBox1) cnodepath.node().addSolid(CollisionBox((0,-2.5,3.5),1.5,0.5,1.5)) cnodepath.node().addSolid(CollisionBox((2.5,0,3.5),0.5,1.5,1.5)) cnodepath.node().addSolid(CollisionBox((-2.5,0,3.5),0.5,1.5,1.5)) #cnodepath.show() #self.cTrav.addCollider(cnodepath, self.orbCollisionHandler) self.sphere = CollisionSphere(0,-5,4,3) self.sphere3 = CollisionSphere(0,5,5,3) self.sphere4 = CollisionSphere(-4,0,5,2) self.sphere5 = CollisionSphere(4,0,5,2) self.sphere2 = CollisionSphere(0,0,3,2) self.cnodePath = self.ralph.attachNewNode((CollisionNode("ralphColNode"))) self.cnodePath2 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck"))) self.cnodePath3 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck2"))) self.cnodePath4 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck3"))) self.cnodePath5 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck4"))) self.cnodePath.node().addSolid(self.sphere2) self.cnodePath2.node().addSolid(self.sphere) self.cnodePath3.node().addSolid(self.sphere3) self.cnodePath4.node().addSolid(self.sphere4) self.cnodePath5.node().addSolid(self.sphere5) #self.cnodePath.node().addSolid(self.sphere2) #self.cnodePath.show()#ralph pusher #self.cnodePath2.show() #self.cnodePath3.show() #self.cnodePath4.show() #self.cnodePath5.show() self.cTrav.addCollider(self.cnodePath2, self.orbCollisionHandler) self.cTrav.addCollider(self.cnodePath3, self.orbCollisionHandler) self.cTrav.addCollider(self.cnodePath4, self.orbCollisionHandler) self.cTrav.addCollider(self.cnodePath5, self.orbCollisionHandler) self.pusher = CollisionHandlerPusher() self.pusher.addCollider(self.cnodePath, self.ralph) #self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler) self.cTrav.addCollider(self.cnodePath, self.pusher) self.chrisLastShotTime = globalClock.getFrameTime() self.chrisTimer = globalClock.getDt() #def __init__(self, pos,showbase, colPathName, dir, length): self.chrisList = [utils.cheken((-249,419,0),self,"chrisColPath0","X",5), #earthroom utils.chris((-404,343,2),self,"chrisColPath1","X",5), #yellowroom utils.fetus((-141,-69,1),self,"chrisColPath2","X",5), #lightblueroom utils.cheken((-277,356,0),self,"chrisColPath3","Y",5), #between earth and y utils.rose((-102,-5,1),self,"chrisColPath4","Y",5), #between r and lb utils.cheken((-133,83,0),self,"chrisColPath5","Y",5), #blue hall utils.fetus((-246,280,1),self,"chrisColPath6","X",5), #earth hall utils.cheken((-330,241,0),self,"chrisColPath7","X",5), #yellow hall utils.chris((-60,110,2),self,"chrisColPath8","Y",5), #red hall cheken z 0 utils.fetus((-75,52,1),self, "chrisColPath9", "X", 5), utils.cheken((-75,141,0),self, "chrisColPath10", "X", 5), utils.rose((-302,202,1),self,"chrisColPath11","X",5), utils.chris((-303,304,2),self,"chrisColPath12","Y",5) ] #rose z = 1 #cheken z = 0 #chris z = 2 #fetus z = 1 #def _init_(self,showbase,pos,color,speed,radius): self.orbList = [utils.orb(self,( 18, 29,2.5),(1,0,0,1),20,2.5), #first red utils.orb(self,( -249, 419,2.5),(1,1,1,1),20,2.5),#earthroom utils.orb(self,( -404, 343,2.5),(1,1,0,1),20,2.5), #yellowroom utils.orb(self,( -141, -69,2.5),(0,0,1,1),20,2.5),#light blue room utils.orb(self,( -277, 356,2.5),(1,1,0,1),20,2.5), #between y and earth utils.orb(self,( -102, -5,2.5),(0,0,1,1),20,2.5), #between red and lb utils.orb(self,( -135, 22,2.5),(0,0,1,1),20,2.5), #lb hall utils.orb(self,( -248, 329,2.5),(1,1,1,1),20,2.5), #earthhall utils.orb(self,( -330, 241,2.5),(1,1,0,1),20,2.5), #yellow hall utils.orb(self,( -60, 110,2.5),(1,0,0,1),20,2.5) #red hall ] self.donutList = [utils.donut(self, (0,0,1),20, 2.5), utils.donut(self,( -330, 250,2.5),20,2.5), #yellow hall utils.donut(self,( -141, -80,2.5),20,2.5),#light blue room utils.donut(self,( -249, 430,2.5),20,2.5),#earthroom utils.donut(self,( -102, -10,2.5),20,2.5), #between red and lb ] self.cameraCollided = False self.ralphSpeed = 60 self.ralphHit = False self.ralphRedTime = 0 self.textTime = -1 self.textTime2 = -1 self.textTime3 = -1 self.mTextPath = utils.addInstructions2(.44,"") self.mTextPath2 = utils.addInstructions2(.55,"") self.winText2 = utils.addInstructions2(.55, "") self.timerText = utils.addInstructions4(.26,"0:00") self.introText = utils.addInstructions2(.55,"") self.minutes = 4 self.seconds = 0 self.timerTime = globalClock.getFrameTime() taskMgr.add(self.move, "moveTask") taskMgr.add(self.moveChris,"moveChrisTask") taskMgr.add(self.timerTask,"timerTask") #taskMgr.add(self.timerTask, "timerTask") # Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value def clickResponse(): pass #startgame=1; def timerTask(self,task): if self.startgame == False: return task.cont dt = globalClock.getFrameTime() if dt - self.timerTime > 1: self.seconds -= 1 if self.seconds == -1: self.seconds = 59 self.minutes -=1 self.timerText.destroy() if self.seconds < 10: str1 = "0" + str(self.minutes) + ":0" + str(self.seconds) else: str1 = "0" + str(self.minutes) + ":" + str(self.seconds) self.timerText = utils.addInstructions4(.26,str1) self.timerTime = globalClock.getFrameTime() - ((dt - self.timerTime) - 1) if self.minutes == 0 and self.seconds == 0: self.startgame = False #utils.addInstructions3(.45,"You Lose") self.imageObject2 = OnscreenImage(image = 'models/gameover.jpg', pos = (0, 0, 0), scale=1.1) self.imageObject2 = OnscreenImage(image = 'models/gap.jpg', pos = (-2.15, 0, 0), scale=1.1) self.imageObject3 = OnscreenImage(image = 'models/gap.jpg', pos = (2.15, 0, 0), scale=1.1) return task.cont def moveChris(self,task): if self.startgame == False: return task.cont else: dt = globalClock.getDt() self.gianteye.setH(self.gianteye.getH() + 100 * dt) for chris in self.chrisList: chris.moveChris(dt,self,self.chrisList) return task.cont # Accepts arrow keys to move either the player or the menu cursor, # Also deals with grid checking and collision detection def move(self, task): if self.sound2.status() != self.sound2.PLAYING: self.sound2.play() if self.startgame == False: return task.cont else: # Get the time that elapsed since last frame. We multiply this with # the desired speed in order to find out with which distance to move # in order to achieve that desired speed. dt = globalClock.getDt() dt2 = globalClock.getFrameTime() #utils.moveChris(self,dt) #self.chris2.moveChris(dt,self) #self.startEnemyThread() if dt2 - self.textTime > 2 and self.textTime != -1: self.textTime = -1; self.mTextPath.destroy() if dt2 - self.textTime2 > 2 and self.textTime2 != -1: self.textTime2 = -1; self.mTextPath2.destroy() if dt2 - self.textTime3 > 5 and self.textTime3 != -1: self.textTime3 = -1; self.introText.destroy() if globalClock.getFrameTime()- self.ralphRedTime > .3 and self.ralphHit == True: self.ralph.clearColor() self.ralphHit = False # If the camera-left key is pressed, move camera left. # If the camera-right key is pressed, move camera right. if self.keyMap["cam-left"]: self.camera.setZ(self.camera, -20 * dt) if self.keyMap["cam-right"]: self.camera.setZ(self.camera, +20 * dt) # 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"]: self.ralph.setH(self.ralph.getH() + 75 * dt) #self.camera.setX(self.camera, +15.5 * dt) if self.keyMap["right"]: self.ralph.setH(self.ralph.getH() - 75 * dt) #self.camera.setX(self.camera, -15.5 * dt) if self.keyMap["forward"]:#-1 self.ralph.setFluidY(self.ralph, -1*self.ralphSpeed * dt) #self.camera.setY(self.camera, -35 * dt) if self.keyMap["back"]: self.ralph.setFluidY(self.ralph, self.ralphSpeed * dt) #self.camera.setY(self.camera, 35 * dt) if self.keyMap["space"]: if self.jumping is False: #self.ralph.setZ(self.ralph.getZ() + 100 * dt) self.jumping = True self.vz = 8 if self.keyMap["enter"]: self.keyMap["enter"] = False self.sound.play() self.shotList[self.shotCount].lpivot.setPos(self.ralph.getPos()) self.shotList[self.shotCount].lpivot.setZ(self.ralph.getZ() + .5) self.shotList[self.shotCount].lpivot.setX(self.ralph.getX() - .25) print self.ralph.getPos() #self.shotList.append(rShot) #self.lightpivot3.setPos(self.ralph.getPos()) #self.lightpivot3.setZ(self.ralph.getZ() + .5) #self.lightpivot3.setX(self.ralph.getX() - .25) #self.myShot.setHpr(self.ralph.getHpr()) #parent to ralph #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(0,-1,0)) #self.myShotVec = vec node = NodePath("tmp") node.setHpr(self.ralph.getHpr()) vec = render.getRelativeVector(node,(0,-1,0)) self.shotList[self.shotCount].vec = vec self.shotCount = (self.shotCount + 1) % 10 else: self.sound.stop() for rs in self.shotList: rs.lpivot.setPos(rs.lpivot.getPos() + rs.vec * dt * 25 ) #if shot is too far stop updating if self.jumping is True: self.vz = self.vz - 16* dt self.ralph.setZ(self.ralph.getZ() + self.vz * dt ) if self.ralph.getZ() < 0: self.ralph.setZ(0) self.jumping = False else: if self.ralph.getZ() < 0.25: self.ralph.setZ(0.25) elif self.ralph.getZ() > 0.25: self.ralph.setZ(self.ralph.getZ() -7 * dt) # If ralph is moving, loop the run animation. # If he is standing still, stop the animation. if self.keyMap["forward"] or self.keyMap["left"] or self.keyMap["right"] or self.keyMap["space"] or self.keyMap["forward"] or self.keyMap["back"]: if self.isMoving is False: self.ralph.loop("run") self.isMoving = True else: if self.isMoving: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False # update pawns shot or set up new shot after it reaches a certain distance node = NodePath("tmp") node.setHpr(self.pawn.getHpr()) vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0)) self.shot.setPos(self.shot.getPos() + self.vec * dt * 10 ) if self.shot.getY() < -15 or self.shot.getY() > 30 or self.shot.getX() < 5 or self.shot.getX() > 15: self.shot.setPos(self.pawn.getPos() + (0,0,0)) self.vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0)) self.vec = render.getRelativeVector(node,(random.random() * random.randrange(-1,2),random.random() + 1,0)) # If the camera is too far from ralph, move it closer. # If the camera is too close to ralph, move it farther. #self.camera.lookAt(self.floater) camvec = self.ralph.getPos() - self.camera.getPos() #camvec = Vec3(0,camvec.getY(),0) camdist = camvec.length() x = self.camera.getZ() camvec.normalize() #if camdist > 6.0: # self.camera.setPos(self.camera.getPos() + camvec * (camdist - 6)) #if camdist < 6.0: # self.camera.setPos(self.camera.getPos() - camvec * (6 - camdist)) # Normally, we would have to call traverse() to check for collisions. # However, the class ShowBase that we inherit from has a task to do # this for us, if we assign a CollisionTraverser to self.cTrav. #self.cTrav.traverse(render) # Adjust camera so it stays at same height if self.cameraCollided == False: if self.camera.getZ() < self.ralph.getZ() + 1 or self.camera.getZ() > self.ralph.getZ() + 1: self.camera.setZ(self.ralph.getZ() + 1) # The camera should look in ralph's direction, # but it should also try to stay horizontal, so look at # a floater which hovers above ralph's head. self.camera.lookAt(self.floater) entries = list(self.orbCollisionHandler.getEntries()) if(len(entries) > 0): #self.lightpivot.reparentTo(NodePath()) orbCollected = False self.cameraCollided = False self.ralphSpeed = 85 ralphHit = False for entry in self.orbCollisionHandler.getEntries(): #print(entry) fromColNp = entry.getFromNodePath() toColNp = entry.getIntoNodePath() if fromColNp.getName() == "orbColPath" and toColNp.getName() == "ralphColNode": if orbCollected == False: fromColNp.getParent().reparentTo(NodePath()) self.orbTxt.destroy() self.numOrbs += 1 str1 = "Orbs: " + str(self.numOrbs) self.orbTxt = utils.addInstructions(.18, str1) orbCollected = True elif toColNp.getName() == "orbColPath" and fromColNp.getName() == "ralphColNode": if orbCollected == False: toColNp.getParent().reparentTo(NodePath()) self.orbTxt.destroy() self.numOrbs += 1 str1 = "Orbs: " + str(self.numOrbs) self.orbTxt = utils.addInstructions(.18, str1) orbCollected = True elif fromColNp.getName() == "donutCollisionNode" and toColNp.getName() == "ralphColNode": fromColNp.getParent().reparentTo(NodePath()) self.healthCount += 15 if(self.healthCount > 100): self.healthCount = 100 self.healthTxt.destroy() str1 = "Health: " + str(self.healthCount) self.healthTxt = utils.addInstructions(.06, str1) elif toColNp.getName() == "donutCollisionNode" and fromColNp.getName() == "ralphColNode": toColNp.getParent().reparentTo(NodePath()) self.healthCount += 15 if(self.healthCount > 100): self.healthCount = 100 self.healthTxt.destroy() str1 = "Health: " + str(self.healthCount) self.healthTxt = utils.addInstructions(.06, str1) elif toColNp.getName() == "ralphOrbColPath" and (fromColNp.getName()[:-1] == "chrisColPath" or fromColNp.getName()[:-2] == "chrisColPath"): toColNp.getParent().setZ(20) for chriss in self.chrisList: if chriss.chrisColName == fromColNp.getName(): chris = chriss break chris.chrisHealth = chris.chrisHealth - 1 chris.chris.setColor(1,0,0,1) chris.chrisHit = True chris.chrisRedTime = globalClock.getFrameTime() #print chris.chrisRedTime if chris.chrisHealth < 0 and chris.chrisAlive == True: fromColNp.getParent().removeNode() chris.chrisAlive = False self.hitsTxt.destroy() self.enemyhits += 1 str1 = "Enemy Hits: " + str(self.enemyhits) self.hitsTxt = utils.addInstructions(.28, str1) chris.chrisShot.setZ(26) elif (toColNp.getName()[:-1] == "chrisColPath" or toColNp.getName()[:-2] == "chrisColPath") and fromColNp.getName() == "ralphOrbColPath": fromColNp.getParent().setZ(20) for chriss in self.chrisList: if chriss.chrisColName == toColNp.getName(): chris = chriss break chris.chrisHealth = chris.chrisHealth - 1 chris.chris.setColor(1,0,0,1) chris.chrisHit = True chris.chrisRedTime = globalClock.getFrameTime() #print chris.chrisRedTime if chris.chrisHealth < 0 and chris.chrisAlive == True: toColNp.getParent().removeNode() chris.chrisAlive = False self.hitsTxt.destroy() self.enemyhits += 1 str1 = "Enemy Hits: " + str(self.enemyhits) self.hitsTxt = utils.addInstructions(.28, str1) chris.chrisShot.setZ(26) elif toColNp.getName() == "enemyOrbColPath" and fromColNp.getName() == "ralphColNode": if ralphHit == False: toColNp.getParent().setZ(26) self.healthTxt.destroy() self.healthCount -= 5 str1 = "Health: " + str(self.healthCount) self.healthTxt = utils.addInstructions(.06, str1) self.ralphHit = True self.ralph.setColor((1,0,0,1)) self.ralphRedTime = globalClock.getFrameTime() if self.healthCount <= 0: self.startgame = False #utils.addInstructions3(.45,"You Lose") self.imageObject2 = OnscreenImage(image = 'models/gameover.jpg', pos = (0, 0, 0), scale=1.1) self.imageObject2 = OnscreenImage(image = 'models/gap.jpg', pos = (-2.15, 0, 0), scale=1.1) self.imageObject3 = OnscreenImage(image = 'models/gap.jpg', pos = (2.15, 0, 0), scale=1.1) elif toColNp.getName() == "ralphColNode" and fromColNp.getName() == "enemyOrbColPath": fromColNp.getParent().setZ(26) if ralphHit == False: self.healthTxt.destroy() self.healthCount -= 5 str1 = "Health: " + str(self.healthCount) self.healthTxt = utils.addInstructions(.06, str1) self.ralphHit = True self.ralph.setColor((1,0,0,1)) self.ralphRedTime = globalClock.getFrameTime() ralphHit = True if self.healthCount <= 0: self.startgame = False #utils.addInstructions3(.45,"You Lose") self.imageObject2 = OnscreenImage(image = 'models/gameover.jpg', pos = (0, 0, 0), scale=1.1) self.imageObject2 = OnscreenImage(image = 'models/gap.jpg', pos = (-2.15, 0, 0), scale=1.1) self.imageObject3 = OnscreenImage(image = 'models/gap.jpg', pos = (2.15, 0, 0), scale=1.1) elif toColNp.getName() == "ralphColNode" and fromColNp.getName() == "portalColPath": if self.numOrbs < 3 and self.enemyhits < 4: self.mTextPath.destroy() self.mTextPath = utils.addInstructions2(.30, "Not enough orbs.") self.textTime = globalClock.getFrameTime() self.mTextPath2.destroy() self.mTextPath2 = utils.addInstructions2(.45, "Not enough kills.") self.textTime2 = globalClock.getFrameTime() elif self.numOrbs < 3: self.mTextPath.destroy() self.mTextPath = utils.addInstructions2(.30, "Not enough orbs.") self.textTime = globalClock.getFrameTime() elif self.enemyhits < 4: self.mTextPath2.destroy() self.mTextPath2 = utils.addInstructions2(.45, "Not enough kills.") self.textTime2 = globalClock.getFrameTime() else: self.winText = utils.addInstructions3(.45, "You Win") self.startgame = False #self.ralph.setPos(-196, 177, 3) if self.isMoving == True: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False elif fromColNp.getName() == "ralphOrbColPath" and toColNp.getName() == "allinclusive": fromColNp.getParent().setZ(50) elif toColNp.getName() == "ralphOrbColPath" and fromColNp.getName() == "allinclusive": toColNp.getParent().setZ(50) elif fromColNp.getName() == "enemyOrbWallCheck" and toColNp.getName() == "allinclusive": fromColNp.getParent().setZ(50) #print toColNp.getName() elif toColNp.getName() == "enemyOrbWallCheck" and fromColNp.getName() == "allinclusive": toColNp.getParent().setZ(50) #print fromColNp.getName() elif fromColNp.getName() == "ralphWallCheck" and toColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(0,-1,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #fromColNp.getParent().setZ(26) self.ralphSpeed = 60 elif toColNp.getName() == "ralphWallCheck" and fromColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(0,-1,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #print "wtf" #toColNp.getParent().setZ(26) self.ralphSpeed = 60 elif fromColNp.getName() == "ralphWallCheck2" and toColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(0,1,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #fromColNp.getParent().setZ(26) self.ralphSpeed = 60 elif toColNp.getName() == "ralphWallCheck2" and fromColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(0,1,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #self.camera.setPos(self.ralph.getPos()) #self.cameraCollided = True self.ralphSpeed = 60 elif fromColNp.getName() == "ralphWallCheck3" and toColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(-1,0,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #fromColNp.getParent().setZ(26) self.ralphSpeed = 60 elif toColNp.getName() == "ralphWallCheck3" and fromColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(-1,0,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #self.camera.setPos(self.ralph.getPos()) #self.cameraCollided = True self.ralphSpeed = 60 elif fromColNp.getName() == "ralphWallCheck4" and toColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(1,0,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #fromColNp.getParent().setZ(26) self.ralphSpeed = 60 elif toColNp.getName() == "ralphWallCheck4" and fromColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(1,0,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #self.camera.setPos(self.ralph.getPos()) #self.cameraCollided = True self.ralphSpeed = 60 utils.updateHealthBar(self.healthCount, self.bar) #utils.turnofstartbutton(self.flagstartbutton) #if self.flagstartbutton ==1: # self.helpOn.destory() return task.cont
class Player(DirectObject): def __init__(self, _main): self.main = _main self.name = "" self.points = 0 self.health = 100.0 self.runSpeed = 1.8 self.keyMap = { "left":False, "right":False, "up":False, "down":False } base.camera.setPos(0,0,0) self.model = loader.loadModel("Player") self.model.find('**/+SequenceNode').node().stop() self.model.find('**/+SequenceNode').node().pose(0) base.camera.setP(-90) self.playerHud = Hud() self.playerHud.hide() self.model.hide() # Weapons: size=2, 0=main, 1=offhand self.mountSlot = [] self.activeWeapon = None self.isAutoActive = False self.trigger = False self.lastShot = 0.0 self.fireRate = 0.0 self.playerTraverser = CollisionTraverser() self.playerEH = CollisionHandlerEvent() ## INTO PATTERNS self.playerEH.addInPattern('intoPlayer-%in') #self.playerEH.addInPattern('colIn-%fn') self.playerEH.addInPattern('intoHeal-%in') self.playerEH.addInPattern('intoWeapon-%in') ## OUT PATTERNS self.playerEH.addOutPattern('outOfPlayer-%in') playerCNode = CollisionNode('playerSphere') playerCNode.setFromCollideMask(BitMask32.bit(1)) playerCNode.setIntoCollideMask(BitMask32.bit(1)) self.playerSphere = CollisionSphere(0, 0, 0, 0.6) playerCNode.addSolid(self.playerSphere) self.playerNP = self.model.attachNewNode(playerCNode) self.playerTraverser.addCollider(self.playerNP, self.playerEH) #self.playerNP.show() self.playerPusher = CollisionHandlerPusher() self.playerPusher.addCollider(self.playerNP, self.model) self.playerPushTraverser = CollisionTraverser() self.playerPushTraverser.addCollider(self.playerNP, self.playerPusher) def acceptKeys(self): self.accept("w", self.setKey, ["up", True]) self.accept("w-up", self.setKey, ["up", False]) self.accept("a", self.setKey, ["left", True]) self.accept("a-up", self.setKey, ["left", False]) self.accept("s", self.setKey, ["down", True]) self.accept("s-up", self.setKey, ["down", False]) self.accept("d", self.setKey, ["right", True]) self.accept("d-up", self.setKey, ["right", False]) # Add mouse btn for fire() self.accept("mouse1", self.setWeaponTrigger, [True]) self.accept("mouse1-up", self.setWeaponTrigger, [False]) # Killed enemies self.accept("killEnemy", self.addPoints) # Game states self.accept("doDamageToPlayer", self.doDamage) def ignoreKeys(self): self.ignore("w") self.ignore("a") self.ignore("s") self.ignore("d") self.ignore("killEnemy") self.ignore("mouse1") self.ignore("mouse1-up") for item in self.main.itemList: if item.type == "heal": self.ignore("intoHeal-" + "itemHeal" + str(item.id)) elif item.type == "gun": self. ignore("intoWeapon-" + "itemWeapon" + str(item.id)) for enemy in self.main.enemyList: self.ignore("intoPlayer-" + "colEnemy" + str(enemy.id)) # Add mouse btn for fire to ignore def setKey(self, action, pressed): self.keyMap[action] = pressed def start(self, startPos, playerName): self.name = playerName self.points = 0 self.health = 100 self.model.reparentTo(render) self.model.setPos(startPos.x, startPos.y, 0) for slot in self.mountSlot[:]: self.mountSlot.remove(slot) # Create a basic weapon self.mountSlot.append(Weapon(self.main, "Pistol", 0.30, 25, weaponType="Pistol")) # Mount the players default weapon self.mountWeapon(self.mountSlot[0]) self.playerHud.setWeapon("Pistol") self.acceptKeys() self.playerHud.show() taskMgr.add(self.move, "moveTask") def stop(self): taskMgr.remove("moveTask") self.ignoreKeys() self.unmountWeapon() self.playerHud.hide() self.model.hide() def addPoints(self, args): self.points += 10 base.messenger.send("setHighscore", [self.points]) def move(self, task): elapsed = globalClock.getDt() #self.playerTraverser.traverse(self.main.enemyParent) #self.playerTraverser.traverse(self.main.itemParent) # set headding pos = self.main.mouse.getMousePos() pos.setZ(0) self.model.lookAt(pos) self.model.setP(-90) # new player position if self.keyMap["up"]: # follow mouse mode #self.model.setZ(self.model, 5 * elapsed * self.runSpeed) # axis move mode self.model.setY(self.model.getY() + elapsed * self.runSpeed) elif self.keyMap["down"]: #self.model.setZ(self.model, -5 * elapsed * self.runSpeed) self.model.setY(self.model.getY() - elapsed * self.runSpeed) if self.keyMap["left"]: # follow mouse mode #self.model.setX(self.model, -5 * elapsed * self.runSpeed) # axis move mode self.model.setX(self.model.getX() - elapsed * self.runSpeed) elif self.keyMap["right"]: #self.model.setX(self.model, 5 * elapsed * self.runSpeed) self.model.setX(self.model.getX() + elapsed * self.runSpeed) # actualize cam position base.camera.setPos(self.model.getPos()) base.camera.setZ(20) return task.cont def mountWeapon(self, _weaponToMount): self.activeWeapon = _weaponToMount # self.mountSlot[0] if self.activeWeapon.style == "TwoHand": self.model.find('**/+SequenceNode').node().pose(0) else: self.model.find('**/+SequenceNode').node().pose(1) self.activeWeapon.model.reparentTo(self.model) self.activeWeapon.model.setY(self.model.getY() - 0.1) self.model.show() self.activeWeapon.model.show() self.fireRate = self.activeWeapon.fireRate def unmountWeapon(self): self.activeWeapon.model.hide() def setWeaponTrigger(self, _state): self.trigger = _state if _state: mpos = self.main.mouse.getMousePos() self.activeWeapon.doFire(mpos) if self.activeWeapon.weaponType == "MG": self.fireActiveWeapon() else: self.activeWeapon.stopFire() else: self.activeWeapon.stopFire() taskMgr.remove("Fire") def fireActiveWeapon(self): if self.activeWeapon: #mpos = self.main.mouse.getMousePos() taskMgr.add(self.fireUpdate, "Fire") #self.activeWeapon.doFire(mpos) def fireUpdate(self, task): dt = globalClock.getDt() self.lastShot += dt mpos = self.main.mouse.getMousePos() #print self.lastShot if self.lastShot >= self.fireRate: self.lastShot -= self.fireRate if self.trigger: self.activeWeapon.doFire(mpos) #task.delayTime += self.fireRate return task.again def setMouseBtn(self): self.trigger = False print "Mouse Released" def addEnemyDmgEvent(self, _id): self.accept("intoPlayer-" + "colEnemy" + str(_id), self.setEnemyAttack) #self.accept("outOfPlayer-" + "colEnemy" + str(_id), self.setEnemyAttackOutOfRange) def setEnemyAttack(self, _entry): enemyColName = _entry.getIntoNodePath().node().getName() base.messenger.send("inRange-" + enemyColName, [True]) def setEnemyAttackOutOfRange(self, _entry): enemyColName = _entry.getIntoNodePath().node().getName() base.messenger.send("inRange-" + enemyColName, [False]) def doDamage(self, _dmg): if self.health <= 0: #print "KILLED IN ACTION" self.main.stop() else: self.health -= _dmg #print "Remaining Health: ", self.health base.messenger.send("setHealth", [self.health]) def addHealItemEvent(self, _id): self.accept("intoHeal-" + "itemHeal" + str(_id), self.healPlayer) def healPlayer(self, _entry): itemColName = _entry.getIntoNodePath().node().getName() if self.health == 100: pass else: self.health += 50 base.messenger.send("into-" + itemColName) if self.health > 100: self.health = 100 print self.health def addWeaponItemEvent(self, _id): self.accept("intoWeapon-" + "itemWeapon" + str(_id), self.changeWeapon) def changeWeapon(self, _entry): itemColName = _entry.getIntoNodePath().node().getName() base.messenger.send("into-" + itemColName) for weapon in self.mountSlot: if weapon.name == "MachineGun": return self.unmountWeapon() self.mountSlot.append(Weapon(self.main, "MachineGun", 0.15, 50, weaponType="MG")) self.playerHud.setWeapon("MG") self.mountWeapon(self.mountSlot[len(self.mountSlot) - 1]) self.activeWeapon.model.show()
def __init__(self): messenger.toggleVerbose() ShowBase.__init__(self) self.environ = self.loader.loadModel("models/falcon") self.environ.reparentTo(self.render) self.environ.setScale(0.25, 0.25, 0.25) self.environ.setPos(-8, 42, 0) self.taskMgr.add(self.spinCameraTask, "SpinCameraTask") self.taskMgr.add(self.moveCameraTask, "MoveCameraTask") self.taskMgr.add(self.playerGravity, "PlayerGravity") #self.taskMgr.add(self.collTask, "CollisionTask") self.pandaActor = Actor("models/panda-model", {"walk": "models/panda-walk4"}) self.pandaActor.setScale(0.005, 0.005, 0.005) self.pandaActor.setPos(0, 0, 10) self.pandaActor.reparentTo(self.render) # Initialize the collision traverser. self.cTrav = CollisionTraverser() self.cTrav.showCollisions(self.render) # Initialize the Pusher collision handler. pusher = CollisionHandlerPusher() # Create a collision node for this object. cNode = CollisionNode('panda') # Attach a collision sphere solid to the collision node. cNode.addSolid(CollisionSphere(0, 0, 0, 600)) # Attach the collision node to the object's model. pandaC = self.pandaActor.attachNewNode(cNode) # Set the object's collision node to render as visible. pandaC.show() # Create a collsion node for this object. cNode = CollisionNode('environnement') # Attach a collision sphere solid to the collision node. cNode.addSolid(CollisionSphere(-1.3, 19, 0.5, 2.5)) cNode.addSolid(CollisionPlane(Plane(Vec3(0,0,1), Point3(0,0,0.2)))) # Attach the collision node to the object's model. environC = self.environ.attachNewNode(cNode) # Set the object's collision node to render as visible. environC.show() # Add the Pusher collision handler to the collision traverser. self.cTrav.addCollider(pandaC, pusher) # Add the 'frowney' collision node to the Pusher collision handler. pusher.addCollider(pandaC, self.environ, base.drive.node()) fromObject = self.pandaActor.attachNewNode(CollisionNode('colNode')) fromObject.node().addSolid(CollisionRay(0, 0, 0, 0, 0, -1)) lifter = CollisionHandlerFloor() lifter.addCollider(fromObject, self.pandaActor) self.cTrav.addCollider(pandaC, lifter) # Have the 'smiley' sphere moving to help show what is happening. #frowney.posInterval(5, Point3(5, 25, 0), startPos=Point3(-5, 25, 0), fluid=1).loop() #self.stuff = Actor("models/panda-model") #self.stuff.setScale(0.005, 0.005, 0.005) #self.stuff.setPos(-1.3, 19., 0.5) #self.stuff.reparentTo(self.render) # cTrav = CollisionTraverser() # ceh = CollisionHandlerQueue() # #ceh.addInPattern('%fn-into-%in') # #ceh.addAgainPattern('%fn-again-%in') # #ceh.addOutPattern('%fn-outof-%in') # self.pandaColl = self.pandaActor.attachNewNode(CollisionNode('cnode')) # self.pandaColl.node().addSolid(CollisionSphere(self.pandaActor.getChild( 0 ).getBounds( ).getCenter(), 400)) # self.pandaColl.show() # cTrav.addCollider( self.pandaColl, ceh ) # self.cTrav = cTrav # self.cTrav.showCollisions(self.render) # self.queue = ceh # cs = CollisionSphere(-1.3, 19, 0.5, 2.5) # pl = CollisionPlane(Plane(Vec3(0,0,1), Point3(0,0,0.2))) # # ray = CollisionRay(self.pandaActor.getPos(), Vec3(0,0,-1)) # cnodePath = self.render.attachNewNode(CollisionNode('cnode')) # # rayNodePath = self.render.attachNewNode(CollisionNode('raynode')) # cnodePath.node().addSolid(cs) # cnodePath.node().addSolid(pl) # # rayNodePath.node().addSolid(ray) # cnodePath.show() # # rayNodePath.show() # #rayNodePath.reparentTo(self.pandaActor) #self.accept('car-into-rail', handleRailCollision) #cTrav.addCollider(cnodePath, ceh) self.camera.reparentTo(self.pandaActor) self.camera.setPos(0., 1050., 1000.) self.camAlpha = 180 self.camBeta = 0 self.moving = [] self.playerAltitude = 0 self.jumping = False self.inJump = False self.playerFallingSpeed = 0 self.player = Mass(80) base.useDrive() #base.disableMouse( ) # disable the default camera controls that are created for us self.keyBoardSetup()
class RoamingPenguinDemo(ShowBase): def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) # This is used to store which keys are currently pressed. self.keyMap = { "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0, } ########################################################################### self.environ = loader.loadModel("models/world") self.environ.reparentTo(render) # We do not have a skybox, so we will just use a sky blue background color #self.setBackgroundColor(0.53, 0.80, 0.92, 1) self.setBackgroundColor(.1, .1, .1, 1) # Create the main character, person #personStartPos = self.environ.find("**/start_point").getPos() #self.person = Actor("models/panda", # {"run": "models/panda-walk", # "walk": "models/panda-walk"}) person2StartPos = self.environ.find("**/start_point").getPos() self.person2 = Actor("models/passenger_penguin", {"run": "models/passenger_penguin", "walk": "models/passenger_penguin"}) self.person2.reparentTo(render) self.person2.setScale(.1) self.person2.setPos(person2StartPos + (px, py, 1)) person3StartPos = self.environ.find("**/start_point").getPos() self.person3 = Actor("models/MagicBunny", {"run": "models/MagicBunny", "walk": "models/MagicBunny"}) #px = random.randint(-1,1) #py = random.randint(-1,1) self.person3.reparentTo(render) self.person3.setScale(.04) #self.person.setPos(personStartPos + (0, 0, 2)) self.person3.setPos(person3StartPos + (px/1.5+3, py/2, 0)) personStartPos = self.environ.find("**/start_point").getPos() self.person = Actor("models/panda", {"run": "models/panda-walk", "walk": "models/panda-walk"}) self.person.reparentTo(render) self.person.setScale(.1) self.person.setPos(personStartPos + (0, 0, 1.5)) self.person.loop("run") arenaStartPos = self.environ.find("**/start_point").getPos() self.arena = Actor("models/FarmHouse") self.arena.reparentTo(render) self.arena.setScale(.1) self.arena.setPos(arenaStartPos + (-1, 0, 0)) arena2StartPos = self.environ.find("**/start_point").getPos() self.arena2 = Actor("models/fence") self.arena2.reparentTo(render) self.arena2.setScale(5.9) self.arena.setPos(arenaStartPos + (px, py-12, 1)) self.arena2.setPos(arenaStartPos + (8, 5, -1)) arena2StartPos = self.environ.find("**/start_point").getPos() self.arena3 = Actor("models/gate") self.arena3.reparentTo(render) self.arena3.setScale(.01) self.arena3.setPos(arenaStartPos + (px/2+random.randint(12,15), py/2, -1)) self.arena4 = Actor("models/FarmHouse") self.arena4.reparentTo(render) self.arena4.setScale(.1) self.arena4.setPos(arenaStartPos + (px/3-random.randint(18,22), py/3, -1)) self.arena5 = Actor("models/gate") self.arena5.reparentTo(render) self.arena5.setScale(.008) self.arena5.setPos(arenaStartPos + (px/1.2-9, py/1.2, -1)) ##################################################################################################################################### base.enableParticles() self.t = loader.loadModel("teapot") # for the particle enhancer self.t.setScale(10) self.t.setPos(-10, -20, -1) self.t.reparentTo(render) #self.setupLights() self.p = ParticleEffect() self.p.setScale(1000) self.loadParticleConfig('smoke.ptf') # looks like a storm at night self.p.setScale(20) #################################################3 # Create a floater object, which floats 2 units above person. We # use this as a target for the camera to look at. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(self.person) self.floater.setZ(2.0) # Accept the control keys for movement and rotation taskMgr.add(self.move, "moveTask") # Set up the camera self.disableMouse() self.camera.setPos(self.person.getX(), self.person.getY() + 10, 2) self.cTrav = CollisionTraverser() self.personCol = CollisionNode('person') self.personCol.addSolid(CollisionSphere(center=(0, 0, 2), radius=1.5)) self.personCol.addSolid(CollisionSphere(center=(0, -0.25, 4), radius=1.5)) self.personCol.setFromCollideMask(CollideMask.bit(0)) self.personCol.setIntoCollideMask(CollideMask.allOff()) self.personColNp = self.person.attachNewNode(self.personCol) self.personPusher = CollisionHandlerPusher() self.personPusher.horizontal = True self.personPusher.addCollider(self.personColNp, self.person) self.cTrav.addCollider(self.personColNp, self.personPusher) self.personGroundRay = CollisionRay() self.personGroundRay.setOrigin(0, 0, 9) self.personGroundRay.setDirection(0, 0, -1) self.personGroundCol = CollisionNode('personRay') self.personGroundCol.addSolid(self.personGroundRay) self.personGroundCol.setFromCollideMask(CollideMask.bit(0)) self.personGroundCol.setIntoCollideMask(CollideMask.allOff()) self.personGroundColNp = self.person.attachNewNode(self.personGroundCol) self.personGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.personGroundColNp, self.personGroundHandler) self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0, 0, 9) self.camGroundRay.setDirection(0, 0, -1) self.camGroundCol = CollisionNode('camRay') self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(CollideMask.bit(0)) self.camGroundCol.setIntoCollideMask(CollideMask.allOff()) self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # Create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.3, .3, .3, .2)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection((-5, -5, -5)) directionalLight.setColor((.2, .2, .2, 1)) directionalLight.setSpecularColor((.1, .1, .1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight)) def loadParticleConfig(self, filename): # Start of the code from steam.ptf self.p.cleanup() self.p = ParticleEffect() self.p.loadConfig(Filename(filename)) self.p.start(self.t) self.p.setPos(3.000, 0.000, 2.250) # Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value def move(self, task): dt = globalClock.getDt() #z = abs(py) self.person.setX(self.person, 4 * dt) self.person.setX(self.person, -4 * dt) ## this is how the Panda finds his friend if px < 0 : #if self.person.getPos() - self.person2.getPos() < (0, 0, 0) : if self.person.getY() - self.person2.getY() < 6 : #self.person.getPos(personStartPos + (0, py, 1.5)) self.person.setY(self.person, 0 * dt) self.person.stop() self.person.pose("walk", 5) self.isMoving = False else: self.person.setY(self.person, py * dt) self.person.setX(self.person, px * dt) self.person.setH(self.person, px/(abs(px)+6)* dt) else: if self.person.getY() - self.person2.getY() < 6 : #self.person.getPos(personStartPos + (0, py, 1.5)) self.person.setY(self.person, 0 * dt) self.person.stop() self.person.pose("walk", 5) self.isMoving = False else: self.person.setY(self.person, py * dt) self.person.setX(self.person, px * dt) self.person.setH(self.person, px/(abs(px)+6)* dt) if self.keyMap["cam-left"]: self.camera.setX(self.camera, -20 * dt) if self.keyMap["cam-right"]: self.camera.setX(self.camera, +20 * dt) camvec = self.person.getPos() - self.camera.getPos() camvec.setZ(0) camdist = camvec.length() camvec.normalize() if camdist > 10.0: self.camera.setPos(self.camera.getPos() + camvec * (camdist - 10)) camdist = 10.0 if camdist < 5.0: self.camera.setPos(self.camera.getPos() - camvec * (5 - camdist)) camdist = 5.0 entries = list(self.personGroundHandler.entries) entries.sort(key=lambda x: x.getSurfacePoint(render).getZ()) for entry in entries: if entry.getIntoNode().getName() == "terrain": self.person.setZ(entry.getSurfacePoint(render).getZ()) entries = list(self.camGroundHandler.entries) entries.sort(key=lambda x: x.getSurfacePoint(render).getZ()) for entry in entries: if entry.getIntoNode().getName() == "terrain": self.camera.setZ(entry.getSurfacePoint(render).getZ() + 3.5) if self.camera.getZ() < self.person.getZ() + 4.0: self.camera.setZ(self.person.getZ() + 4.0) self.camera.lookAt(self.floater) return task.cont
class RoamingRalphDemo(ShowBase): def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) base.render.setAttrib(LightRampAttrib.makeHdr0()) # Configure depth pre-pass prepass_pass = lionrender.DepthScenePass() # Configure scene pass scene_fb_props = FrameBufferProperties() scene_fb_props.set_rgb_color(True) scene_fb_props.set_rgba_bits(8, 8, 8, 0) scene_fb_props.set_depth_bits(32) scene_pass = lionrender.ScenePass( frame_buffer_properties=scene_fb_props, clear_color=LColor(0.53, 0.80, 0.92, 1), share_depth_with=prepass_pass) scene_pass.node_path.set_depth_write(False) # Configure post processing filter_pass = lionrender.FilterPass(fragment_path='shaders/fsq.frag') filter_pass.node_path.set_shader_input('inputTexture', scene_pass.output) # Enable FXAA fxaa_pass = lionrender.FxaaFilterPass() fxaa_pass.node_path.set_shader_input('inputTexture', filter_pass.output) # Output result fxaa_pass.output_to(render2d) # This is used to store which keys are currently pressed. self.keyMap = { "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0, } # Post the instructions self.title = addTitle( "Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)") self.inst1 = addInstructions(0.06, "[ESC]: Quit") self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left") self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right") self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward") self.inst5 = addInstructions(0.30, "[Down Arrow]: Walk Ralph Backward") self.inst6 = addInstructions(0.36, "[A]: Rotate Camera Left") self.inst7 = addInstructions(0.42, "[S]: Rotate Camera Right") # 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("models/world") self.environ.reparentTo(render) # We do not have a skybox, so we will just use a sky blue background color self.setBackgroundColor(0.53, 0.80, 0.92, 1) # Create the main character, Ralph ralphStartPos = self.environ.find("**/start_point").getPos() self.ralph = Actor("models/ralph", { "run": "models/ralph-run", "walk": "models/ralph-walk" }) self.ralph.reparentTo(render) self.ralph.setScale(.2) self.ralph.setPos(ralphStartPos + (0, 0, 1.5)) # Create a floater object, which floats 2 units above ralph. We # use this as a target for the camera to look at. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(self.ralph) self.floater.setZ(2.0) # Accept the control keys for movement and rotation self.accept("escape", sys.exit) self.accept("arrow_left", self.setKey, ["left", True]) self.accept("arrow_right", self.setKey, ["right", True]) self.accept("arrow_up", self.setKey, ["forward", True]) self.accept("arrow_down", self.setKey, ["backward", True]) self.accept("a", self.setKey, ["cam-left", True]) self.accept("s", self.setKey, ["cam-right", True]) self.accept("arrow_left-up", self.setKey, ["left", False]) self.accept("arrow_right-up", self.setKey, ["right", False]) self.accept("arrow_up-up", self.setKey, ["forward", False]) self.accept("arrow_down-up", self.setKey, ["backward", False]) self.accept("a-up", self.setKey, ["cam-left", False]) self.accept("s-up", self.setKey, ["cam-right", False]) self.accept("v", self.toggleCards) taskMgr.add(self.move, "moveTask") # Set up the camera self.disableMouse() self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2) self.cTrav = CollisionTraverser() # Use a CollisionHandlerPusher to handle collisions between Ralph and # the environment. Ralph is added as a "from" object which will be # "pushed" out of the environment if he walks into obstacles. # # Ralph is composed of two spheres, one around the torso and one # around the head. They are slightly oversized since we want Ralph to # keep some distance from obstacles. self.ralphCol = CollisionNode('ralph') self.ralphCol.addSolid(CollisionSphere(center=(0, 0, 2), radius=1.5)) self.ralphCol.addSolid( CollisionSphere(center=(0, -0.25, 4), radius=1.5)) self.ralphCol.setFromCollideMask(CollideMask.bit(0)) self.ralphCol.setIntoCollideMask(CollideMask.allOff()) self.ralphColNp = self.ralph.attachNewNode(self.ralphCol) self.ralphPusher = CollisionHandlerPusher() self.ralphPusher.horizontal = True # Note that we need to add ralph both to the pusher and to the # traverser; the pusher needs to know which node to push back when a # collision occurs! self.ralphPusher.addCollider(self.ralphColNp, self.ralph) self.cTrav.addCollider(self.ralphColNp, self.ralphPusher) # 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 ralph'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. self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0, 0, 9) self.ralphGroundRay.setDirection(0, 0, -1) self.ralphGroundCol = CollisionNode('ralphRay') self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0)) self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0, 0, 9) self.camGroundRay.setDirection(0, 0, -1) self.camGroundCol = CollisionNode('camRay') self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(CollideMask.bit(0)) self.camGroundCol.setIntoCollideMask(CollideMask.allOff()) self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # Uncomment this line to see the collision rays #self.ralphColNp.show() #self.camGroundColNp.show() # Uncomment this line to show a visual representation of the # collisions occuring #self.cTrav.showCollisions(render) # Create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.3, .3, .3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection((-5, -5, -5)) directionalLight.setColor((1, 1, 1, 1)) directionalLight.setSpecularColor((1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight)) # Clean up texture attributes for texture in self.render.find_all_textures(): texture.set_format(Texture.F_srgb) # Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value # Accepts arrow keys to move either the player or the menu cursor, # Also deals with grid checking and collision detection def move(self, task): # Get the time that elapsed since last frame. We multiply this with # the desired speed in order to find out with which distance to move # in order to achieve that desired speed. dt = globalClock.getDt() # If the camera-left key is pressed, move camera left. # If the camera-right key is pressed, move camera right. if self.keyMap["cam-left"]: self.camera.setX(self.camera, -20 * dt) if self.keyMap["cam-right"]: self.camera.setX(self.camera, +20 * dt) # If a move-key is pressed, move ralph in the specified direction. if self.keyMap["left"]: self.ralph.setH(self.ralph.getH() + 300 * dt) if self.keyMap["right"]: self.ralph.setH(self.ralph.getH() - 300 * dt) if self.keyMap["forward"]: self.ralph.setY(self.ralph, -20 * dt) if self.keyMap["backward"]: self.ralph.setY(self.ralph, +10 * dt) # If ralph is moving, loop the run animation. # If he is standing still, stop the animation. currentAnim = self.ralph.getCurrentAnim() if self.keyMap["forward"]: if currentAnim != "run": self.ralph.loop("run") elif self.keyMap["backward"]: # Play the walk animation backwards. if currentAnim != "walk": self.ralph.loop("walk") self.ralph.setPlayRate(-1.0, "walk") elif self.keyMap["left"] or self.keyMap["right"]: if currentAnim != "walk": self.ralph.loop("walk") self.ralph.setPlayRate(1.0, "walk") else: if currentAnim is not None: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False # If the camera is too far from ralph, move it closer. # If the camera is too close to ralph, move it farther. camvec = self.ralph.getPos() - self.camera.getPos() camvec.setZ(0) camdist = camvec.length() camvec.normalize() if camdist > 10.0: self.camera.setPos(self.camera.getPos() + camvec * (camdist - 10)) camdist = 10.0 if camdist < 5.0: self.camera.setPos(self.camera.getPos() - camvec * (5 - camdist)) camdist = 5.0 # Normally, we would have to call traverse() to check for collisions. # However, the class ShowBase that we inherit from has a task to do # this for us, if we assign a CollisionTraverser to self.cTrav. #self.cTrav.traverse(render) # Adjust ralph's Z coordinate. If ralph's ray hit terrain, # update his Z entries = list(self.ralphGroundHandler.entries) entries.sort(key=lambda x: x.getSurfacePoint(render).getZ()) for entry in entries: if entry.getIntoNode().getName() == "terrain": self.ralph.setZ(entry.getSurfacePoint(render).getZ()) # Keep the camera at one unit above the terrain, # or two units above ralph, whichever is greater. entries = list(self.camGroundHandler.entries) entries.sort(key=lambda x: x.getSurfacePoint(render).getZ()) for entry in entries: if entry.getIntoNode().getName() == "terrain": self.camera.setZ(entry.getSurfacePoint(render).getZ() + 1.5) if self.camera.getZ() < self.ralph.getZ() + 2.0: self.camera.setZ(self.ralph.getZ() + 2.0) # The camera should look in ralph's direction, # but it should also try to stay horizontal, so look at # a floater which hovers above ralph's head. self.camera.lookAt(self.floater) return task.cont def toggleCards(self): self.bufferViewer.toggleEnable()
class Player: STATE_IDLE = "Idle" STATE_WALK = "Walk" STATE_RUN = "Run" STATE_JUMP = "Jump" STATE_RUNJUMP = "RunJump" STATE_FALL = "Fall" STATE_DUCK = "Duck" STATE_UN_DUCK = "UnDuck" STATE_FLOAT = "Float" STATE_SWIM = "Swim" SUB_STATE_GRAB = "Grab" JUMP_ACCEL = 3.5 FALL_ACCEL = -9.81 TERRAIN_NONE = 0 TERRAIN_GROUND = 1 TERRAIN_WATER = 2 TERRAIN_AIR = 3 DUCK_FRAME_COUNT = 0 DUCK_FRAME_MID = 0 SUNK_CUTOFF = -0.9 def __init__(self, base): self.base = base self.keyState = { "WalkFw": False, "WalkBw": False, "Run": False, "RotateL": False, "RotateR": False, "Jump": False, "Duck": False } self.isKeyDown = self.base.mouseWatcherNode.isButtonDown self.state = Player.STATE_IDLE self.sub_state = None self.walkDir = 0 self.rotationDir = 0 self.zVelocity = 0 self.zOffset = None self.jumpHeight = None self.terrainZone = Player.TERRAIN_NONE self.terrainSurfZ = None self.waterDepth = 0 self.collidedObjects = list() # actor anims = { "idle": "models/player-idle", "walk": "models/player-walk", "run": "models/player-run", "jump": "models/player-jump", "duck": "models/player-duck", "float": "models/player-float", "swim": "models/player-swim", "grab": "models/player-grab" } self.actor = Actor("models/player", anims) self.actor.reparentTo(self.base.render) self.actor.setH(200) log.debug("actor tight bounds is %s" % str(self.actor.getTightBounds())) # animation info Player.DUCK_FRAME_COUNT = self.actor.getNumFrames("duck") Player.DUCK_FRAME_MID = int(Player.DUCK_FRAME_COUNT / 2) # camara point self.camNode = NodePath("camNode") self.camNode.reparentTo(self.actor) self.camNode.setPos(0, 0, 1) # collision # ray collRay = CollisionRay(0, 0, 1.5, 0, 0, -1) collRayN = CollisionNode("playerCollRay") collRayN.addSolid(collRay) collRayN.setFromCollideMask(1) collRayN.setIntoCollideMask(CollideMask.allOff()) collRayNP = self.actor.attachNewNode(collRayN) self.collQRay = CollisionHandlerQueue() self.base.cTrav.addCollider(collRayNP, self.collQRay) # sphere mask 2 collSphere2 = CollisionSphere(0, 0, 0.5, 0.25) collSphere2N = CollisionNode("playerCollSphere2") collSphere2N.addSolid(collSphere2) collSphere2N.setFromCollideMask(2) collSphere2N.setIntoCollideMask(CollideMask.allOff()) self.collSphere2NP = self.actor.attachNewNode(collSphere2N) self.collPSphere = CollisionHandlerPusher() self.collPSphere.addCollider(self.collSphere2NP, self.actor) self.base.cTrav.addCollider(self.collSphere2NP, self.collPSphere) # key events self.base.accept("i", self.dump_info) # task self.base.taskMgr.add(self.update, "playerUpdateTask") def defineKeys(self): for k in self.keyState.keys(): self.keyState[k] = False if self.isKeyDown(KeyboardButton.up()): self.keyState["WalkFw"] = True if self.isKeyDown(KeyboardButton.down()): self.keyState["WalkBw"] = True if self.isKeyDown(KeyboardButton.left()): self.keyState["RotateL"] = True if self.isKeyDown(KeyboardButton.right()): self.keyState["RotateR"] = True if self.isKeyDown(KeyboardButton.shift()): self.keyState["Run"] = True if self.isKeyDown(KeyboardButton.space()): self.keyState["Jump"] = True if self.isKeyDown(KeyboardButton.asciiKey("d")): self.keyState["Duck"] = True def defineState(self): # newState = self.state # keys states ks = self.keyState # state force if self.zOffset > 0.2 and self.state != Player.STATE_FALL: newState = Player.STATE_FALL # from Idle -> Walk, Jump if self.state == Player.STATE_IDLE: # Walk if ks["WalkFw"] or ks["WalkBw"] or ks["RotateL"] or ks["RotateR"]: newState = Player.STATE_WALK elif ks["Jump"]: newState = Player.STATE_JUMP elif ks["Duck"]: newState = Player.STATE_DUCK # from Walk, Run -> Walk, Run, Idle; from Run -> Jump elif self.state == Player.STATE_WALK or self.state == Player.STATE_RUN: if ks["Run"] and self.state != Player.STATE_RUN and self.terrainZone != Player.TERRAIN_WATER: newState = Player.STATE_RUN elif not ks["Run"] and self.state == Player.STATE_RUN: newState = Player.STATE_WALK if ks["WalkFw"]: self.walkDir = -1 elif ks["WalkBw"]: self.walkDir = 1 elif not ks["WalkFw"] and not ks["WalkBw"]: self.walkDir = 0 if ks["RotateL"]: self.rotationDir = 1 elif ks["RotateR"]: self.rotationDir = -1 elif not ks["RotateL"] and not ks["RotateR"]: self.rotationDir = 0 if ks["Jump"]: newState = Player.STATE_RUNJUMP if self.walkDir == 0 and self.rotationDir == 0: newState = Player.STATE_IDLE # from Jump -> Fall elif self.state == Player.STATE_JUMP or self.state == Player.STATE_RUNJUMP: if self.zVelocity > 0: newState = Player.STATE_FALL # from Fall -> Idle elif self.state == Player.STATE_FALL: if self.zOffset <= 0: newState = Player.STATE_IDLE self.jumpHeight = None self.zVelocity = 0 self.walkDir = 0 # from Duck -> UnDuck elif self.state == Player.STATE_DUCK: if not ks["Duck"]: newState = Player.STATE_UN_DUCK # from UnDuck -> Idle elif self.state == Player.STATE_UN_DUCK: if not self.actor.getCurrentAnim() == "duck": newState = Player.STATE_IDLE return newState def processState(self, dt): # terrain sdjustment if self.zOffset <= 0.2 and not self.state == Player.STATE_FALL: self.actor.setZ(self.terrainSurfZ) # idle if self.state == Player.STATE_IDLE: self.collSphere2NP.setZ(0) # walk if self.walkDir != 0: if self.zVelocity == 0: speed = 3.6 if self.state == Player.STATE_RUN else 2.4 else: speed = 3.2 if self.terrainZone == Player.TERRAIN_WATER: speed *= 0.5 self.actor.setY(self.actor, speed * self.walkDir * dt) if self.rotationDir != 0: self.actor.setH(self.actor.getH() + 3.5 * self.rotationDir) # jump if self.state == Player.STATE_JUMP or self.state == Player.STATE_RUNJUMP: self.zVelocity = Player.JUMP_ACCEL log.debug("jump start at v=%f" % self.zVelocity) if self.state == Player.STATE_RUNJUMP: self.walkDir = -1 # fall if self.state == Player.STATE_FALL: dZ = self.zVelocity * dt dV = Player.FALL_ACCEL * dt curZ = self.actor.getZ() newZ = curZ + dZ if self.jumpHeight == None and newZ < curZ: self.jumpHeight = self.zOffset log.debug("jump height=%f" % self.jumpHeight) log.debug( "falling... dt=%(dt)f getZ=%(getZ)f v=%(v)f dZ=%(dZ)f newZ=%(newZ)f dV=%(dV)f zOffset=%(zOff)f" % { "dt": dt, "getZ": self.actor.getZ(), "v": self.zVelocity, "dZ": dZ, "newZ": newZ, "dV": dV, "zOff": self.zOffset }) if newZ < self.terrainSurfZ: newZ = self.terrainSurfZ self.actor.setZ(newZ) self.zVelocity += dV # duck if self.state == Player.STATE_DUCK: if self.actor.getCurrentAnim() == "duck": collSphrZ = (self.actor.getCurrentFrame("duck") / Player.DUCK_FRAME_MID) * 0.25 self.collSphere2NP.setZ(-collSphrZ) def processTerrainRelation( self): # -> [terrainZone, terrainSurfZ, zOffset, waterDepth] collEntries = self.collQRay.getEntries() newZone = None # if len(collEntries) == 0: #log.error("out of terrain, pos=%s"%str(self.actor.getPos())) newZone = Player.TERRAIN_NONE if newZone != self.terrainZone: self.onTerrainZoneChanged(Player.TERRAIN_NONE) self.terrainZone = newZone return Player.TERRAIN_NONE, 0, 0, 0 # newZone = Player.TERRAIN_NONE gndZ, wtrZ = -1000, -1000 waterDepth = 0 for entry in collEntries: eName = entry.getIntoNodePath().getName() eZ = entry.getSurfacePoint(self.base.render).getZ() if eName.startswith("Water"): wtrZ = eZ if wtrZ > gndZ: newZone = Player.TERRAIN_WATER else: if eZ > gndZ: gndZ = eZ if gndZ > wtrZ: newZone = Player.TERRAIN_GROUND if newZone == Player.TERRAIN_WATER: waterDepth = gndZ - wtrZ #log.debug("water depth is %f"%waterDepth) zOffset = self.actor.getZ() - gndZ return newZone, gndZ, zOffset, waterDepth def onTerrainZoneChanged(self, zone): log.debug("terrain zone chaged to: %i" % zone) def onStateChanged(self, newState): curState = self.state log.debug("state change %s -> %s" % (str(curState), str(newState))) #self.actor.stop() if newState == Player.STATE_IDLE: self.actor.loop("idle") elif newState == Player.STATE_WALK: self.actor.setPlayRate(4.0, "walk") self.actor.loop("walk") elif newState == Player.STATE_RUN: self.actor.loop("run") elif newState == Player.STATE_JUMP or newState == Player.STATE_RUNJUMP: self.actor.setPlayRate(1.4, "jump") self.actor.play("jump", fromFrame=20, toFrame=59) elif newState == Player.STATE_DUCK: self.actor.play("duck", fromFrame=0, toFrame=Player.DUCK_FRAME_MID) elif newState == Player.STATE_UN_DUCK: initFrame = Player.DUCK_FRAME_MID if self.actor.getCurrentAnim() == "duck": initFrame = Player.DUCK_FRAME_COUNT - self.actor.getCurrentFrame( "duck") self.actor.stop() self.actor.play("duck", fromFrame=initFrame, toFrame=Player.DUCK_FRAME_COUNT) def updateCollidedObjectsList(self): pass def update(self, task): # clock dt = self.base.taskMgr.globalClock.getDt() # keys self.defineKeys() # terrain relation newZone, self.terrainSurfZ, self.zOffset, self.waterDepth = self.processTerrainRelation( ) if newZone != self.terrainZone: self.terrainZone = newZone self.onTerrainZoneChanged(self.terrainZone) # obstacles relation self.updateCollidedObjectsList() # state newState = self.defineState() if self.state != newState: self.onStateChanged(newState) self.state = newState self.processState(dt) # move return task.cont def dump_info(self): info = "position: %s\n" % str(self.actor.getPos()) info += "hpr: %s\n" % str(self.actor.getHpr()) info += "state: %s; sub_state: %s\n" % (str( self.state), str(self.sub_state)) info += "terrainZone: %s\n" % str(self.terrainZone) info += "terrainSurfZ: %s\n" % str(self.terrainSurfZ) info += "zOffset: %s\n" % str(self.zOffset) log.info("*INFO:\n%s" % info)
class Physics: def __init__(self): self.rayCTrav = CollisionTraverser("collision traverser for ray tests") #self.pusher = PhysicsCollisionHandler() self.pusher = CollisionHandlerPusher() self.pusher.addInPattern('%fn-in-%in') self.pusher.addOutPattern('%fn-out-%in') self.pusher.addInPattern('%fn-in') self.pusher.addOutPattern('%fn-out') def startPhysics(self): #self.actorNode = ActorNode("playerPhysicsControler") #base.physicsMgr.attachPhysicalNode(self.actorNode) #self.actorNode.getPhysicsObject().setMass(self.player_mass) #self.mainNode = render.attachNewNode(self.actorNode) self.mainNode = render.attachNewNode("CharacterColliders") self.reparentTo(self.mainNode) charCollisions = self.mainNode.attachNewNode(CollisionNode(self.char_collision_name)) #charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/4.0, self.player_height/4.0)) #charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/4.0*3.05, self.player_height/4.0)) charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/2.0, self.player_height/4.0)) charCollisions.node().setIntoCollideMask(BitMask32(0x80)) # 1000 0000 if self.show_collisions: charCollisions.show() self.pusher.addCollider(charCollisions, self.mainNode) base.cTrav.addCollider(charCollisions, self.pusher) charFFootCollisions = self.attachNewNode(CollisionNode("floor_ray")) charFFootCollisions.node().addSolid(CollisionRay(0, 0, 0.5, 0, 0, -1)) #charFFootCollisions.node().addSolid(CollisionSegment((0, 0, 0.2), (0, 0, -1))) charFFootCollisions.node().setIntoCollideMask(BitMask32.allOff()) charFFootCollisions.node().setFromCollideMask(BitMask32(0x7f)) # 0111 1111 if self.show_collisions: charFFootCollisions.show() self.floor_handler = CollisionHandlerFloor() self.floor_handler.addCollider(charFFootCollisions, self.mainNode) #self.floor_handler.setOffset(0) self.floor_handler.setMaxVelocity(5) base.cTrav.addCollider(charFFootCollisions, self.floor_handler) self.accept("{}-in".format(self.char_collision_name), self.checkCharCollisions) self.raytest_segment = CollisionSegment(0, 1) self.raytest_np = render.attachNewNode(CollisionNode("testRay")) self.raytest_np.node().addSolid(self.raytest_segment) self.raytest_np.node().setIntoCollideMask(BitMask32.allOff()) self.raytest_np.node().setFromCollideMask(BitMask32(0x7f)) # 0111 1111 if self.show_collisions: self.raytest_np.show() self.raytest_queue = CollisionHandlerQueue() self.rayCTrav.addCollider(self.raytest_np, self.raytest_queue) def stopPhysics(self): self.raytest_segment.removeNode() self.pusher.clearColliders() self.floor_handler.clearColliders() self.rayCTrav.clearColliders() def updatePlayerPos(self, speed, heading, dt): if heading is not None: self.mainNode.setH(camera, heading) self.mainNode.setP(0) self.mainNode.setR(0) self.mainNode.setFluidPos(self.mainNode, speed) self.doStep() def checkCharCollisions(self, args): self.doStep() def doStep(self): # do the step height check tmpNP = self.mainNode.attachNewNode("temporary") tmpNP.setPos(self.mainNode, 0, 0, -self.stepheight) pointA = self.mainNode.getPos(render) pointA.setZ(pointA.getZ() + self.player_height/1.8) pointB = tmpNP.getPos(render) if pointA == pointB: return char_step_collision = self.getFirstCollisionInLine(pointA, pointB) tmpNP.removeNode() if char_step_collision is not None: self.mainNode.setFluidZ(char_step_collision.getZ()) return True return False def getFirstCollisionInLine(self, pointA, pointB): """A simple raycast check which will return the first collision point as seen from point A towards pointB""" self.raytest_segment.setPointA(pointA) self.raytest_segment.setPointB(pointB) self.rayCTrav.traverse(render) self.raytest_queue.sortEntries() pos = None if self.raytest_queue.getNumEntries() > 0: pos = self.raytest_queue.getEntry(0).getSurfacePoint(render) return pos
class Project(ShowBase): def __init__(self): ShowBase.__init__(self) self.win.setClearColor((0.455, 0.816, 0.945, 1)) self.keyMap = { "left": 0, "right": 0, "forward": 0, "backward": 0, "jump": 0, "action": 0 } # Mise en place des instructions self.title = addTitle("Project : 'Escape the forest'") self.inst1 = addInstructions(0.06, "[ECHAP]: Quit") self.inst2 = addInstructions(0.12, "[Left arrow]: Turn Freddy left") self.inst3 = addInstructions(0.18, "[Right arrow]: Turn Freddy right") self.inst4 = addInstructions(0.24, "[Top arrow]: Make Freddy move forward") self.inst5 = addInstructions(0.30, "Bottom arrow]: Make Freddy move back") self.inst6 = addInstructions(0.36, "[Space]: Make Freddy jump") self.inst7 = addInstructions(0.42, "[A]: Operate the lever") # 3D objects self.map = loader.loadModel("obj/Map.egg.pz") self.map.reparentTo(render) self.walls = loader.loadModel("obj/Wall.egg") self.walls.reparentTo(render) self.bridge = Actor("obj/Bridge.egg", {"Drop": "obj/Bridge.egg"}) self.bridge.reparentTo(render) self.bridge.pose("Drop", 0) self.lever = Actor("obj/Lever.egg", {"OnOff": "obj/Lever.egg"}) self.lever.reparentTo(render) self.lever.setPos(0, 12, 1) self.lever.pose("OnOff", 0) self.lever1 = Actor("obj/Lever.egg", {"OnOff": "obj/Lever.egg"}) self.lever1.reparentTo(render) self.lever1.setPos(50, 16, 1) self.lever1.pose("OnOff", 0) self.lever2 = Actor("obj/Lever.egg", {"OnOff": "obj/Lever.egg"}) self.lever2.reparentTo(render) self.lever2.setPos(22, 92, 1) self.lever2.pose("OnOff", 0) self.dirt = Actor("obj/Dirt.egg", {"Up": "obj/Dirt.egg"}) self.dirt.reparentTo(render) self.stone = Actor("obj/Stone.egg", {"Fall": "obj/Stone.egg"}) self.stone.reparentTo(render) # Creation of the main character, Freddy FreddyStartPos = (8, -8, 1.5) self.Freddy = Actor("obj/Freddy.egg", { "Run": "obj/Run.egg", "Pose": "obj/Pose.egg" }) self.Freddy.reparentTo(render) self.Freddy.setScale(1.4) self.Freddy.setPos(FreddyStartPos) self.Freddy.setH(180) winsound.PlaySound("sound/music.wav", winsound.SND_ASYNC) self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(self.Freddy) self.floater.setZ(0) # Controls for move and interact self.accept("escape", sys.exit) self.accept("arrow_left", self.setKey, ["left", True]) self.accept("arrow_right", self.setKey, ["right", True]) self.accept("arrow_up", self.setKey, ["forward", True]) self.accept("arrow_down", self.setKey, ["backward", True]) self.accept("space", self.setKey, ["jump", True]) self.accept("a", self.setKey, ["action", True]) self.accept("arrow_left-up", self.setKey, ["left", False]) self.accept("arrow_right-up", self.setKey, ["right", False]) self.accept("arrow_up-up", self.setKey, ["forward", False]) self.accept("arrow_down-up", self.setKey, ["backward", False]) self.accept("space-up", self.setKey, ["jump", False]) self.accept("a-up", self.setKey, ["action", False]) taskMgr.add(self.movement, "Movement") self.moving = False self.disableMouse() ambientLight = AmbientLight("ambientLight") ambientLight.setColor((1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) # Collisions self.cTrav = CollisionTraverser() self.pusher = CollisionHandlerPusher() self.FreddyGroundHandler = CollisionHandlerQueue() self.FreddyGroundSphere = CollisionSphere( 0, 0, 0.5, 0.3) #Coordinates of the center and radius self.FreddyGroundCol = CollisionNode('freddySphere') self.FreddyGroundCol.addSolid(self.FreddyGroundSphere) self.FreddyGroundCol.setFromCollideMask(BitMask32.bit(0)) self.FreddyGroundCol.setIntoCollideMask(BitMask32.allOff()) self.FreddyGroundColNp = self.Freddy.attachNewNode( self.FreddyGroundCol) self.cTrav.addCollider(self.FreddyGroundColNp, self.FreddyGroundHandler) self.BridgeHandler = CollisionHandlerQueue() self.BridgeBox = CollisionBox((1, 17, 0), (5, 16.8, 10)) self.BridgeCol = CollisionNode('bridgeBox') self.BridgeCol.addSolid(self.BridgeBox) self.BridgeCol.setFromCollideMask(BitMask32.allOff()) self.BridgeCol.setIntoCollideMask(BitMask32.bit(0)) self.BridgeColNp = self.bridge.attachNewNode(self.BridgeCol) self.cTrav.addCollider(self.BridgeColNp, self.BridgeHandler) self.pusher.addCollider(self.FreddyGroundColNp, self.BridgeColNp) self.StoneHandler = CollisionHandlerQueue() self.StoneBox = CollisionBox((39, 27, 0), (41, 31, 3)) self.StoneCol = CollisionNode('stoneBox') self.StoneCol.addSolid(self.StoneBox) self.StoneCol.setFromCollideMask(BitMask32.allOff()) self.StoneCol.setIntoCollideMask(BitMask32.bit(0)) self.StoneColNp = self.stone.attachNewNode(self.StoneCol) self.cTrav.addCollider(self.StoneColNp, self.StoneHandler) self.pusher.addCollider(self.FreddyGroundColNp, self.StoneColNp) self.DirtHandler = CollisionHandlerQueue() self.DirtBox = CollisionBox((15, 83, 0), (13, 82.5, 5)) self.DirtCol = CollisionNode('dirtBox') self.DirtCol.addSolid(self.DirtBox) self.DirtCol.setFromCollideMask(BitMask32.allOff()) self.DirtCol.setIntoCollideMask(BitMask32.bit(0)) self.DirtColNp = self.dirt.attachNewNode(self.DirtCol) self.cTrav.addCollider(self.DirtColNp, self.DirtHandler) self.pusher.addCollider(self.FreddyGroundColNp, self.DirtColNp) def setKey(self, key, value): self.keyMap[key] = value def movement(self, task): dt = globalClock.getDt() startpos = self.Freddy.getPos() speed = -5 if self.keyMap["left"]: self.Freddy.setH(-90) self.Freddy.setY(self.Freddy, speed * dt) if self.keyMap["right"]: self.Freddy.setH(90) self.Freddy.setY(self.Freddy, speed * dt) if self.keyMap["forward"]: self.Freddy.setH(180) self.Freddy.setY(self.Freddy, speed * dt) if self.keyMap["backward"]: self.Freddy.setH(0) self.Freddy.setY(self.Freddy, speed * dt) relative_speed = 5 * math.sqrt(2) - 5 if self.keyMap["left"] and self.keyMap["forward"]: self.Freddy.setH(-135) self.Freddy.setY(self.Freddy, relative_speed * dt) if self.keyMap["left"] and self.keyMap["backward"]: self.Freddy.setH(-45) self.Freddy.setY(self.Freddy, relative_speed * dt) if self.keyMap["right"] and self.keyMap["forward"]: self.Freddy.setH(135) self.Freddy.setY(self.Freddy, relative_speed * dt) if self.keyMap["right"] and self.keyMap["backward"]: self.Freddy.setH(45) self.Freddy.setY(self.Freddy, relative_speed * dt) deltax = self.lever.getX() - self.Freddy.getX() deltay = self.lever.getY() - self.Freddy.getY() deltaz = self.lever.getZ() - self.Freddy.getZ() deltax1 = self.lever1.getX() - self.Freddy.getX() deltay1 = self.lever1.getY() - self.Freddy.getY() deltaz1 = self.lever1.getZ() - self.Freddy.getZ() deltax2 = self.lever2.getX() - self.Freddy.getX() deltay2 = self.lever2.getY() - self.Freddy.getY() deltaz2 = self.lever2.getZ() - self.Freddy.getZ() delta = math.sqrt(deltax**2 + deltay**2 + deltaz**2) delta1 = math.sqrt(deltax1**2 + deltay1**2 + deltaz1**2) delta2 = math.sqrt(deltax2**2 + deltay2**2 + deltaz2**2) Animb = self.bridge.getAnimControl("Drop") self.bridgeOpen = Animb.getFrame() Anims = self.stone.getAnimControl("Fall") self.stoneOpen = Anims.getFrame() Animd = self.dirt.getAnimControl("Up") self.dirtOpen = Animd.getFrame() if delta < 3 and self.keyMap["action"]: if self.bridgeOpen == 0: self.lever.play("OnOff") self.BridgeCol.setIntoCollideMask(BitMask32.allOff()) self.bridge.play("Drop") if delta1 < 3 and self.keyMap["action"]: if self.stoneOpen == 0: self.lever1.play("OnOff") self.StoneCol.setIntoCollideMask(BitMask32.allOff()) self.stone.play("Fall") if delta2 < 3 and self.keyMap["action"]: if self.dirtOpen == 0: self.lever2.play("OnOff") self.DirtCol.setIntoCollideMask(BitMask32.allOff()) self.dirt.play("Up") if self.keyMap["forward"] or self.keyMap["left"] or self.keyMap[ "right"] or self.keyMap["backward"]: if self.moving is False: self.Freddy.loop("Run") self.moving = True else: if self.moving: self.Freddy.stop() self.Freddy.loop("Pose") self.moving = False if self.Freddy.getZ() < 1: self.Freddy.setZ(1) dt = globalClock.getDt() maxZ = 3.5 if self.keyMap["jump"] == True and self.Freddy.getZ() <= 2: self.Freddy.setZ(self.Freddy.getZ() + 5 * dt) if self.Freddy.getZ() >= maxZ: self.Freddy.setZ(maxZ) if self.keyMap["jump"] == False and self.Freddy.getZ() >= 1: self.Freddy.setZ(self.Freddy, -2 * dt) # Collisions again self.cTrav.traverse(render) entries = [] for i in range(self.FreddyGroundHandler.getNumEntries()): entry = self.FreddyGroundHandler.getEntry(i) entries.append(entry) if (len(entries) > 0) and ( (entries[0].getIntoNode().getName() == "Htbox") or (entries[0].getIntoNode().getName() == "bridgeBox") or (entries[0].getIntoNode().getName() == "stoneBox") or (entries[0].getIntoNode().getName() == "dirtBox")): self.Freddy.setPos(startpos) camx = self.Freddy.getX() - self.camera.getX() if camx > 8.625 or camx < 8.625: self.camera.setX(self.Freddy.getX() + 8.625) camy = self.Freddy.getY() - self.camera.getY() if camy > -18.375 or camy < -18.375: self.camera.setY(self.Freddy.getY() - 18.375) camz = self.Freddy.getZ() - self.Freddy.getZ() if camz > 13.125 or camz < 13.125: self.camera.setZ(self.Freddy.getZ() + 13.125) self.camera.lookAt(self.floater) return task.cont
class RoamingRalphDemo(ShowBase): def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) self.orbCollisionHandler = CollisionHandlerQueue() self.cTrav = CollisionTraverser() self.cTrav.setRespectPrevTransform(True) #hbPath = NodePath() utilsKristina2.setUpKeys(self) utilsKristina2.loadModels(self) utilsKristina2.setUpLighting(self) utilsKristina2.setUpFloatingSpheres(self) utilsKristina2.setUpRalphsShot(self) utilsKristina2.setUpCamera(self) utilsKristina2.setUpCollisionSpheres(self) self.healthTxt = utilsKristina2.addInstructions(.06,"Health: 100") self.orbTxt = utilsKristina2.addInstructions(.18,"Orbs: 0") self.vec = LVector3(0,1,0)#vector for pawns shot # Create a frame #frame = DirectFrame(text = "main", scale = 0.001) # Add button #bar = DirectWaitBar(text = "", value = 50, pos = (0,.4,.4)) #bar.reparent(render) # Game state variables self.isMoving = False self.jumping = False self.vz = 0 self.numOrbs = 0 self.healthCount = 100 #self.shotList = [] #self.sphere = CollisionBox((self.ralph.getX() + -10,self.ralph.getY(),self.ralph.getZ()),10,10,10) self.sphere = CollisionSphere(0,-5,4,3) self.sphere3 = CollisionSphere(0,5,5,3) self.sphere4 = CollisionSphere(-4,0,5,2) self.sphere5 = CollisionSphere(4,0,5,2) self.sphere2 = CollisionSphere(0,0,3,2) self.cnodePath = self.ralph.attachNewNode((CollisionNode("ralphColNode"))) self.cnodePath2 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck"))) self.cnodePath3 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck2"))) self.cnodePath4 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck3"))) self.cnodePath5 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck4"))) self.cnodePath.node().addSolid(self.sphere2) self.cnodePath2.node().addSolid(self.sphere) self.cnodePath3.node().addSolid(self.sphere3) self.cnodePath4.node().addSolid(self.sphere4) self.cnodePath5.node().addSolid(self.sphere5) #self.cnodePath.node().addSolid(self.sphere2) self.cnodePath.show() #self.cnodePath2.show() #self.cnodePath3.show() #self.cnodePath4.show() #self.cnodePath5.show() self.cTrav.addCollider(self.cnodePath2, self.orbCollisionHandler) self.cTrav.addCollider(self.cnodePath3, self.orbCollisionHandler) self.cTrav.addCollider(self.cnodePath4, self.orbCollisionHandler) self.cTrav.addCollider(self.cnodePath5, self.orbCollisionHandler) self.pusher = CollisionHandlerPusher() self.pusher.addCollider(self.cnodePath, self.ralph) #self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler) self.cTrav.addCollider(self.cnodePath, self.pusher) self.chrisLastShotTime = globalClock.getFrameTime() self.chrisTimer = globalClock.getDt() #def __init__(self, pos,showbase, colPathName, dir, length): self.chrisList = [utilsKristina2.chris((15,0,0.5),self,"chrisColPath0","X",6), utilsKristina2.chris((18,29,0.5),self,"chrisColPath1","X",6), utilsKristina2.chris((-6,67,0.5),self,"chrisColPath2","X",6), utilsKristina2.chris((-41,72,0.5),self,"chrisColPath7","X",6)] #,utilsKristina2.chris((-42,106,0.5),self,"chrisColPath3","X",6)]#, utilsKristina2.chris((-62,108,0.5),self,"chrisColPath4","X",6), #utilsKristina2.chris((-74,70,0.5),self,"chrisColPath5","y",6)] #def _init_(self,showbase,pos,color,speed,radius): self.orbList = [utilsKristina2.orb(self,(0,0,2),(0,0,1,1),20,4)] self.donutList = [utilsKristina2.donut(self,(0,0,2),40,3)] self.cameraCollided = False self.ralphSpeed = 60 self.ralphHit = False self.ralphRedTime = 0 self.ralphLife=True taskMgr.add(self.move, "moveTask") taskMgr.add(self.moveChris,"moveChrisTask") # Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value def startEnemyThread(self): showbase = self class enemyThread(threading.Thread): def run(self): dt = globalClock.getDt() for chris in showbase.chrisList: chris.moveChris(dt,showbase,showbase.chrisList) def moveChris(self,task): dt = globalClock.getDt() for chris in self.chrisList: chris.moveChris(dt,self,self.chrisList) return task.cont # Accepts arrow keys to move either the player or the menu cursor, # Also deals with grid checking and collision detection def move(self, task): # Get the time that elapsed since last frame. We multiply this with # the desired speed in order to find out with which distance to move # in order to achieve that desired speed. dt = globalClock.getDt() #utilsKristina2.moveChris(self,dt) #self.chris2.moveChris(dt,self) #self.startEnemyThread() if globalClock.getFrameTime()- self.ralphRedTime > .3 and self.ralphHit == True: self.ralph.clearColor() self.ralphHit = False # If the camera-left key is pressed, move camera left. # If the camera-right key is pressed, move camera right. if self.keyMap["cam-left"]: self.camera.setZ(self.camera, -20 * dt) if self.keyMap["cam-right"]: self.camera.setZ(self.camera, +20 * dt) # 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"]: self.ralph.setH(self.ralph.getH() + 75 * dt) #self.camera.setX(self.camera, +15.5 * dt) if self.keyMap["right"]: self.ralph.setH(self.ralph.getH() - 75 * dt) #self.camera.setX(self.camera, -15.5 * dt) if self.keyMap["forward"]: self.ralph.setFluidY(self.ralph, -1*self.ralphSpeed * dt) #self.camera.setY(self.camera, -35 * dt) if self.keyMap["back"]: self.ralph.setFluidY(self.ralph, self.ralphSpeed * dt) #self.camera.setY(self.camera, 35 * dt) if self.keyMap["space"]: if self.jumping is False: #self.ralph.setZ(self.ralph.getZ() + 100 * dt) self.jumping = True self.vz = 8 if self.keyMap["c"] or self.keyMap["enter"]: if self.keyMap["c"]: self.keyMap["c"]=False if self.keyMap["enter"]: self.keyMap["enter"] = False self.shotList[self.shotCount].lpivot.setPos(self.ralph.getPos()) self.shotList[self.shotCount].lpivot.setZ(self.ralph.getZ() + .5) self.shotList[self.shotCount].lpivot.setX(self.ralph.getX() - .25) print self.ralph.getPos() #self.shotList.append(rShot) #self.lightpivot3.setPos(self.ralph.getPos()) #self.lightpivot3.setZ(self.ralph.getZ() + .5) #self.lightpivot3.setX(self.ralph.getX() - .25) #self.myShot.setHpr(self.ralph.getHpr()) #parent to ralph #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(0,-1,0)) #self.myShotVec = vec node = NodePath("tmp") node.setHpr(self.ralph.getHpr()) vec = render.getRelativeVector(node,(0,-1,0)) self.shotList[self.shotCount].vec = vec self.shotCount = (self.shotCount + 1) % 10 for rs in self.shotList: rs.lpivot.setPos(rs.lpivot.getPos() + rs.vec * dt * 25 ) #if shot is too far stop updating if self.jumping is True: self.vz = self.vz - 16* dt self.ralph.setZ(self.ralph.getZ() + self.vz * dt ) if self.ralph.getZ() < 0: self.ralph.setZ(0) self.jumping = False else: if self.ralph.getZ() < 0.25: self.ralph.setZ(0.25) elif self.ralph.getZ() > 0.25: self.ralph.setZ(self.ralph.getZ() -7 * dt) # If ralph is moving, loop the run animation. # If he is standing still, stop the animation. if self.keyMap["forward"] or self.keyMap["left"] or self.keyMap["right"] or self.keyMap["space"] or self.keyMap["forward"] or self.keyMap["back"]: if self.isMoving is False: self.ralph.loop("run") self.isMoving = True else: if self.isMoving: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False # update pawns shot or set up new shot after it reaches a certain distance node = NodePath("tmp") node.setHpr(self.pawn.getHpr()) vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0)) self.shot.setPos(self.shot.getPos() + self.vec * dt * 10 ) if self.shot.getY() < -15 or self.shot.getY() > 30 or self.shot.getX() < 5 or self.shot.getX() > 15: self.shot.setPos(self.pawn.getPos() + (0,0,0)) self.vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0)) self.vec = render.getRelativeVector(node,(random.random() * random.randrange(-1,2),random.random() + 1,0)) # If the camera is too far from ralph, move it closer. # If the camera is too close to ralph, move it farther. #self.camera.lookAt(self.floater) camvec = self.ralph.getPos() - self.camera.getPos() #camvec = Vec3(0,camvec.getY(),0) camdist = camvec.length() x = self.camera.getZ() camvec.normalize() #if camdist > 6.0: # self.camera.setPos(self.camera.getPos() + camvec * (camdist - 6)) #if camdist < 6.0: # self.camera.setPos(self.camera.getPos() - camvec * (6 - camdist)) # Normally, we would have to call traverse() to check for collisions. # However, the class ShowBase that we inherit from has a task to do # this for us, if we assign a CollisionTraverser to self.cTrav. #self.cTrav.traverse(render) # Adjust camera so it stays at same height if self.cameraCollided == False: if self.camera.getZ() < self.ralph.getZ() + 1 or self.camera.getZ() > self.ralph.getZ() + 1: self.camera.setZ(self.ralph.getZ() + 1) # The camera should look in ralph's direction, # but it should also try to stay horizontal, so look at # a floater which hovers above ralph's head. self.camera.lookAt(self.floater) entries = list(self.orbCollisionHandler.getEntries()) if(len(entries) > 0): #self.lightpivot.reparentTo(NodePath()) orbCollected = False self.cameraCollided = False self.ralphSpeed = 65 for entry in self.orbCollisionHandler.getEntries(): #print(entry) fromColNp = entry.getFromNodePath() toColNp = entry.getIntoNodePath() if fromColNp.getName() == "orbColPath" and toColNp.getName() == "ralphColNode": if orbCollected == False: fromColNp.getParent().reparentTo(NodePath()) self.orbTxt.destroy() self.numOrbs += 1 str1 = "Orbs: " + str(self.numOrbs) self.orbTxt = utilsKristina2.addInstructions(.18, str1) orbCollected = True elif toColNp.getName() == "orbColPath" and fromColNp.getName() == "ralphColNode": if orbCollected == False: toColNp.getParent().reparentTo(NodePath()) self.orbTxt.destroy() self.numOrbs += 1 str1 = "Orbs: " + str(self.numOrbs) self.orbTxt = utilsKristina2.addInstructions(.18, str1) orbCollected = True elif toColNp.getName() == "ralphOrbColPath" and (fromColNp.getName()[:-1] == "chrisColPath" or fromColNp.getName()[:-2] == "chrisColPath"): toColNp.getParent().setZ(20) for chriss in self.chrisList: if chriss.chrisColName == fromColNp.getName(): chris = chriss break chris.chrisHealth = chris.chrisHealth - 1 chris.chris.setColor(1,0,0,1) chris.chrisHit = True chris.chrisRedTime = globalClock.getFrameTime() #print chris.chrisRedTime if chris.chrisHealth < 0: fromColNp.getParent().removeNode() chris.chrisAlive = False chris.chrisShot.setZ(26) elif (toColNp.getName()[:-1] == "chrisColPath" or toColNp.getName()[:-2] == "chrisColPath") and fromColNp.getName() == "ralphOrbColPath": fromColNp.getParent().setZ(20) for chriss in self.chrisList: if chriss.chrisColName == toColNp.getName(): chris = chriss break chris.chrisHealth = chris.chrisHealth - 1 chris.chris.setColor(1,0,0,1) chris.chrisHit = True chris.chrisRedTime = globalClock.getFrameTime() #print chris.chrisRedTime if chris.chrisHealth < 0: toColNp.getParent().removeNode() chris.chrisAlive = False chris.chrisShot.setZ(26) elif toColNp.getName() == "enemyOrbColPath" and fromColNp.getName() == "ralphColNode": toColNp.getParent().setZ(26) self.healthTxt.destroy() self.healthCount -= 3 str1 = "Health: " + str(self.healthCount) self.healthTxt = utilsKristina2.addInstructions(.06, str1) self.ralphHit = True self.ralph.setColor((1,0,0,1)) self.ralphRedTime = globalClock.getFrameTime() if self.healthCount <=0: sys.exit() elif toColNp.getName() == "ralphColNode" and fromColNp.getName() == "enemyOrbColPath": fromColNp.getParent().setZ(26) self.healthTxt.destroy() self.healthCount -= 3 str1 = "Health: " + str(self.healthCount) self.healthTxt = utilsKristina2.addInstructions(.06, str1) self.ralphHit = True self.ralph.setColor((1,0,0,1)) self.ralphRedTime = globalClock.getFrameTime() if self.healthCount <=0: sys.exit() elif fromColNp.getName() == "ralphOrbColPath" and toColNp.getName() == "allinclusive": fromColNp.getParent().setZ(50) elif toColNp.getName() == "ralphOrbColPath" and fromColNp.getName() == "allinclusive": toColNp.getParent().setZ(50) elif fromColNp.getName() == "enemyOrbWallCheck" and toColNp.getName() == "allinclusive": fromColNp.getParent().setZ(50) #print toColNp.getName() elif toColNp.getName() == "enemyOrbWallCheck" and fromColNp.getName() == "allinclusive": toColNp.getParent().setZ(50) #print fromColNp.getName() elif fromColNp.getName() == "ralphWallCheck" and toColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(0,-1,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #fromColNp.getParent().setZ(26) self.ralphSpeed = 25 elif toColNp.getName() == "ralphWallCheck" and fromColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(0,-1,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #print "wtf" #toColNp.getParent().setZ(26) self.ralphSpeed = 25 elif fromColNp.getName() == "ralphWallCheck2" and toColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(0,1,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #fromColNp.getParent().setZ(26) self.ralphSpeed = 25 elif toColNp.getName() == "ralphWallCheck2" and fromColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(0,1,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #self.camera.setPos(self.ralph.getPos()) #self.cameraCollided = True self.ralphSpeed = 25 elif fromColNp.getName() == "ralphWallCheck3" and toColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(-1,0,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #fromColNp.getParent().setZ(26) self.ralphSpeed = 25 print "3" elif toColNp.getName() == "ralphWallCheck3" and fromColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(-1,0,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #self.camera.setPos(self.ralph.getPos()) #self.cameraCollided = True self.ralphSpeed = 25 print "3" elif fromColNp.getName() == "ralphWallCheck4" and toColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(1,0,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #fromColNp.getParent().setZ(26) self.ralphSpeed = 25 print "4" elif toColNp.getName() == "ralphWallCheck4" and fromColNp.getName() == "allinclusive": #node = NodePath("tmp") #node.setHpr(self.ralph.getHpr()) #vec = render.getRelativeVector(node,(1,0,0)) #self.ralph.setPos(self.ralph.getPos()-vec) #self.camera.setPos(self.ralph.getPos()) #self.cameraCollided = True self.ralphSpeed = 25 print "4" return task.cont
class RoamingRalphDemo(ShowBase): def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) #self.setupCD() # Set the background color to black # self.win.setClearColor((0.6, 0.6, 1.0, 1.0)) # self.fog = Fog('myFog') # self.fog.setColor(0, 0, 0) # self.fog.setExpDensity(.05) # render.setFog(self.fog) # This is used to store which keys are currently pressed. self.keyMap = { "left": 0, "right": 0, "forward": 0, "cam-left": 0, "cam-right": 0, "c":0, "back":0, "space":0} # Post the instructions #self.title = addTitle( # "Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)") self.inst1 = addInstructions(0.06, "[ESC]: Quit") self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left") self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right") self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward") #self.inst6 = addInstructions(0.30, "[A]: Rotate Camera Left") #self.inst7 = addInstructions(0.36, "[S]: Rotate Camera Right") # 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("models/world") #self.environ.reparentTo(render) self.room = loader.loadModel("models/room2.egg") self.room.reparentTo(render) #self.room.setScale(.1) self.room.setPos(0,0,-5) self.room.setShaderAuto() #self.room.writeBamFile("myRoom1.bam") #self.room.setColor(1,.3,.3,1) self.room2 = loader.loadModel("models/abstractroom2") self.room2.reparentTo(render) self.room2.setScale(.1) self.room2.setPos(-12,0,0) # Create the main character, Ralph #ralphStartPos = LVecBase3F(0,0,0) #self.room.find("**/start_point").getPos() self.ralph = Actor("models/ralph", {"run": "models/ralph-run", "walk": "models/ralph-walk"}) self.ralph.reparentTo(render) self.ralph.setScale(.2) self.ralph.setPos(0,0,0) #cs = CollisionSphere(0, 0, 0, 1) #cnodePath = self.ralph.attachNewNode(CollisionNode('cnode')) #cnodePath.node().addSolid(cs) #cnodePath.node().setPos(0,0,0) #cnodePath.show() self.gianteye = loader.loadModel("models/gianteye") self.gianteye.reparentTo(render) self.gianteye.setScale(.1) self.gianteye.setPos(10,10,0) #self.bluefinal = loader.loadModel("models/chrysalis") #self.bluefinal.reparentTo(render) #self.bluefinal.setScale(.1) #self.bluefinal.setPos(7,7,0) #self.blue = loader.loadModel("models/blue1") #self.blue.reparentTo(render) #self.blue.setScale(.1) #self.blue.setPos(10,5,0) self.chik = loader.loadModel("models/chik") self.chik.reparentTo(render) self.chik.setScale(.1) self.chik.setPos(3,13,0) self.pawn = loader.loadModel("pawn") self.pawn.reparentTo(render) self.pawn.setPos(0,0,0) self.shot = loader.loadModel("models/icosphere.egg") self.shot.reparentTo(render) self.shot.setScale(.5) self.shot.setPos(0,0,1) self.shot.setColor(1,.3,.3,1) self.myShot = loader.loadModel("models/icosphere.egg") #self.myShot.reparentTo(render) self.myShot.setScale(.1) self.myShot.setPos(0,0,1) self.myShotVec = LVector3(0,0,0) self.lightpivot3 = render.attachNewNode("lightpivot3") self.lightpivot3.setPos(0, 0, 0) self.lightpivot3.hprInterval(10, LPoint3(0, 0, 0)).loop() plight3 = PointLight('plight2') plight3.setColor((0, .3,0, 1)) plight3.setAttenuation(LVector3(0.7, 0.05, 0)) plnp3 = self.lightpivot3.attachNewNode(plight3) plnp3.setPos(0, 0, 0) self.room2.setLight(plnp3) self.room.setLight(plnp3) sphere3 = loader.loadModel("models/icosphere") sphere3.reparentTo(plnp3) sphere3.setScale(0.1) sphere3.setColor((0,1,0,1)) # Create a floater object, which floats 2 units above ralph. We # use this as a target for the camera to look at. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(self.ralph) self.floater.setZ(8.0) # Accept the control keys for movement and rotation self.accept("escape", sys.exit) self.accept("arrow_left", self.setKey, ["left", True]) self.accept("arrow_right", self.setKey, ["right", True]) self.accept("arrow_up", self.setKey, ["forward", True]) self.accept("arrow_down", self.setKey, ["back", True]) self.accept("a", self.setKey, ["cam-left", True]) self.accept("s", self.setKey, ["cam-right", True]) self.accept("arrow_left-up", self.setKey, ["left", False]) self.accept("arrow_right-up", self.setKey, ["right", False]) self.accept("arrow_up-up", self.setKey, ["forward", False]) self.accept("arrow_down-up", self.setKey, ["back", False]) self.accept("a-up", self.setKey, ["cam-left", False]) self.accept("s-up", self.setKey, ["cam-right", False]) self.accept("space", self.setKey, ["space", True]) self.accept("space-up", self.setKey, ["space", False]) self.accept("c",self.setKey,["c",True]) self.accept("c-up",self.setKey,["c",False]) taskMgr.add(self.move, "moveTask") # Game state variables self.isMoving = False self.jumping = False self.vz = 0 # Set up the camera self.disableMouse() self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 7, 3) self.camLens.setFov(60) # 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 ralph'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. def setupCollision(self): cs = CollisionSphere(0,0,2,1) cnodePath = self.ralph.attachNewNode(CollisionNode('cnode')) cnodePath.node().addSolid(cs) cnodePath.show() #for o in self.OBS: #ct = CollisionTube(0,0,0, 0,0,1, 0.5) #cn = o.attachNewNode(CollisionNode('ocnode')) #cn.node().addSolid(ct) #cn.show() eyecs = CollisionSphere(0,0,4,5) cnodePath = self.gianteye.attachNewNode(CollisionNode('cnode')) cnodePath.node().addSolid(eyecs) cnodePath.show() eyecs = CollisionSphere(0,0,4,2) cnodePath = self.chik.attachNewNode(CollisionNode('cnode')) cnodePath.node().addSolid(eyecs) cnodePath.show() pusher = CollisionHandlerPusher() pusher.addCollider(cnodePath, self.player) self.cTrav = CollisionTraverser() self.cTrav.add_collider(cnodePath,pusher) self.cTrav.showCollisions(render) self.walls = self.room2.find("**/wall_collide") #self.walls.node().setIntoCollideMask(BitMask32.bit(0)) self.cTrav = CollisionTraverser() self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0, 0, 9) self.ralphGroundRay.setDirection(0, 0, -1) self.ralphGroundCol = CollisionNode('ralphRay') self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0)) self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0, 0, 9) self.camGroundRay.setDirection(0, 0, -1) self.camGroundCol = CollisionNode('camRay') self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(CollideMask.bit(0)) self.camGroundCol.setIntoCollideMask(CollideMask.allOff()) self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) self.sphere = CollisionSphere(0,0,4,2) self.sphere2 = CollisionSphere(0,0,2,2) self.cnodePath = self.ralph.attachNewNode((CollisionNode('cnode'))) self.cnodePath.node().addSolid(self.sphere) self.cnodePath.node().addSolid(self.sphere2) self.cnodePath.show() self.pusher = CollisionHandlerPusher() self.pusher.addCollider(self.cnodePath, self.ralph) self.cTrav.add_collider(self.cnodePath, self.pusher) self.eyecs = CollisionSphere(0,0,22,25) self.cnodePath1 = self.gianteye.attachNewNode(CollisionNode('cnode')) self.cnodePath1.node().addSolid(self.eyecs) self.cnodePath1.show() self.pusher1 = CollisionHandlerPusher() self.pusher1.addCollider(self.cnodePath1, self.gianteye) self.cTrav.add_collider(self.cnodePath1, self.pusher1) self.cTrav.showCollisions(render) self.eyeGroundRay = CollisionRay() self.eyeGroundRay.setOrigin(0, 0, 9) self.eyeGroundRay.setDirection(0, 0, -1) self.eyeGroundCol = CollisionNode('eyeRay') self.eyeGroundCol.addSolid(self.eyeGroundRay) self.eyeGroundCol.setFromCollideMask(CollideMask.bit(0)) self.eyeGroundCol.setIntoCollideMask(CollideMask.allOff()) self.eyeGroundColNp = self.gianteye.attachNewNode(self.eyeGroundCol) self.eyeGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.eyeGroundColNp, self.eyeGroundHandler) self.chikcs = CollisionSphere(0,0,11,20) self.cnodePath2 = self.chik.attachNewNode(CollisionNode('cnode')) self.cnodePath2.node().addSolid(self.chikcs) self.cnodePath2.show() self.pusher2 = CollisionHandlerPusher() self.pusher2.addCollider(self.cnodePath, self.chik) self.cTrav.add_collider(self.cnodePath, self.pusher2) self.cTrav.showCollisions(render) self.chikGroundRay = CollisionRay() self.chikGroundRay.setOrigin(0, 0, 9) self.chikGroundRay.setDirection(0, 0, -1) self.chikGroundCol = CollisionNode('chikRay') self.chikGroundCol.addSolid(self.chikGroundRay) self.chikGroundCol.setFromCollideMask(CollideMask.bit(0)) self.chikGroundCol.setIntoCollideMask(CollideMask.allOff()) self.chikGroundColNp = self.chik.attachNewNode(self.chikGroundCol) self.chikGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.chikGroundColNp, self.chikGroundHandler) # Uncomment this line to see the collision rays self.ralphGroundColNp.show() self.camGroundColNp.show() #self.ralphroom1ColNp.show() # Uncomment this line to show a visual representation of the # collisions occuring #self.cTrav.showCollisions(render) # Create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.3, .3, .3, .4)) ambientLight2 = AmbientLight("ambientLight2") ambientLight2.setColor((1, 1, 1, 10)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection((0, 0, -2)) directionalLight.setColor((1, 1, 1, 1)) directionalLight.setSpecularColor((1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) #self.environ.setLight(self.environ.attachNewNode(ambientLight2)) render.setLight(render.attachNewNode(directionalLight)) # Add a light to the scene. self.lightpivot = render.attachNewNode("lightpivot") self.lightpivot.setPos(0, 0, 1.6) self.lightpivot.hprInterval(20, LPoint3(360, 0, 0)).loop() plight = PointLight('plight') plight.setColor((.7, .3, 0, 1)) plight.setAttenuation(LVector3(0.7, 0.05, 0)) plnp = self.lightpivot.attachNewNode(plight) plnp.setPos(5, 0, 0) self.room.setLight(plnp) sphere = loader.loadModel("models/icosphere") sphere.reparentTo(plnp) sphere.setScale(0.1) sphere.setColor((1,1,0,1)) self.lightpivot2 = render.attachNewNode("lightpivot") self.lightpivot2.setPos(-16, 0, 1.6) self.lightpivot2.hprInterval(20, LPoint3(360, 0, 0)).loop() plight2 = PointLight('plight2') plight2.setColor((0, .4,.8, 1)) plight2.setAttenuation(LVector3(0.7, 0.05, 0)) plnp2 = self.lightpivot2.attachNewNode(plight2) plnp2.setPos(5, 0, 0) self.room2.setLight(plnp2) sphere2 = loader.loadModel("models/icosphere") sphere2.reparentTo(plnp2) sphere2.setScale(0.2) sphere2.setColor((0,0,1,1)) self.vec = LVector3(0,1,0) # Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value # Accepts arrow keys to move either the player or the menu cursor, # Also deals with grid checking and collision detection def move(self, task): # Get the time that elapsed since last frame. We multiply this with # the desired speed in order to find out with which distance to move # in order to achieve that desired speed. dt = globalClock.getDt() # If the camera-left key is pressed, move camera left. # If the camera-right key is pressed, move camera right. if self.keyMap["cam-left"]: self.camera.setZ(self.camera, -20 * dt) if self.keyMap["cam-right"]: self.camera.setZ(self.camera, +20 * dt) # 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"]: self.ralph.setH(self.ralph.getH() + 150 * dt) #self.floater.setH(self.floater.getH() + 300 * dt) self.camera.setX(self.camera, +15.5 * dt) if self.keyMap["right"]: self.ralph.setH(self.ralph.getH() - 150 * dt) self.camera.setX(self.camera, -15.5 * dt) if self.keyMap["forward"]: self.ralph.setY(self.ralph, -35 * dt) if self.keyMap["back"]: self.ralph.setY(self.ralph, +35 * dt) if self.keyMap["c"]: if self.jumping is False: #self.ralph.setH(self.ralph.getH() + 300 * dt) #self.ralph.setZ(self.ralph.getZ() + 100 * dt) self.jumping = True self.vz = 7 if self.keyMap["space"]: self.lightpivot3.setPos(self.ralph.getPos()) self.lightpivot3.setZ(self.ralph.getZ() + .5) self.lightpivot3.setX(self.ralph.getX() - .25) #self.myShot.setHpr(self.ralph.getHpr()) #parent node = NodePath("tmp") node.setHpr(self.ralph.getHpr()) vec = render.getRelativeVector(node,(0,-1,0)) self.myShotVec = vec self.lightpivot3.setPos(self.lightpivot3.getPos() + self.myShotVec * dt * 15 ) if self.jumping is True: self.vz = self.vz - 16* dt self.ralph.setZ(self.ralph.getZ() + self.vz * dt ) entries = list(self.ralphGroundHandler.getEntries()) entries.sort(key=lambda x: x.getSurfacePoint(render).getZ()) if len(entries) > 0 : if self.ralph.getZ() < 0:#entries[0].getSurfacePoint(render).getZ(): #self.ralph.setZ(entries[0].getSurfacePoint(render).getZ()) self.ralph.setZ(0) self.jumping = False # If ralph is moving, loop the run animation. # If he is standing still, stop the animation. if self.keyMap["forward"] or self.keyMap["left"] or self.keyMap["right"] or self.keyMap["c"] or self.keyMap["forward"] or self.keyMap["back"]: if self.isMoving is False: self.ralph.loop("run") self.isMoving = True else: if self.isMoving: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False node = NodePath("tmp") node.setHpr(self.ralph.getHpr()) vec = render.getRelativeVector(node,(1,0,0)) #self.ralph.setPos(self.ralph.getPos() + vec * dt * 20) node = NodePath("tmp") #self.pawn.getH() node.setHpr(self.pawn.getHpr()) vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0)) self.shot.setPos(self.shot.getPos() + self.vec * dt * 10 ) if self.shot.getY() < -15 or self.shot.getY() > 15 or self.shot.getX() < -15 or self.shot.getX() > 15: self.shot.setPos(self.pawn.getPos() + (0,0,0)) self.vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0)) self.vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0)) # If the camera is too far from ralph, move it closer. # If the camera is too close to ralph, move it farther. camvec = self.ralph.getPos() - self.camera.getPos() #camvec.setZ(self.camera.getZ()) camdist = camvec.length() x = self.camera.getZ() camvec.normalize() if camdist > 6.0: self.camera.setPos(self.camera.getPos() + camvec * (camdist - 6)) camdist = 10.0 #self.camera.setZ(self.camera, x) if camdist < 6.0: self.camera.setPos(self.camera.getPos() - camvec * (6 - camdist)) camdist = 5.0 #self.camera.setZ(self.camera, x) # Normally, we would have to call traverse() to check for collisions. # However, the class ShowBase that we inherit from has a task to do # this for us, if we assign a CollisionTraverser to self.cTrav. #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 = list(self.ralphGroundHandler.getEntries()) entries.sort(key=lambda x: x.getSurfacePoint(render).getZ()) if self.jumping == False: if len(entries) > 0:# and entries[0].getIntoNode().getName() == "terrain": #self.ralph.setZ(entries[0].getSurfacePoint(render).getZ()) pass else: self.ralph.setPos(startpos) # Keep the camera at one foot above the terrain, # or two feet above ralph, whichever is greater. entries = list(self.camGroundHandler.getEntries()) entries.sort(key=lambda x: x.getSurfacePoint(render).getZ()) #if len(entries) > 0 and entries[0].getIntoNode().getName() == "ground": #self.camera.setZ(entries[0].getSurfacePoint(render).getZ() + 1.5) if self.camera.getZ() < self.ralph.getZ() + 1 or self.camera.getZ() > self.ralph.getZ() + 1: self.camera.setZ(self.ralph.getZ() + 1) #self.camera.setZ(self.ralph.getZ() + 1.5) #self.camera.setP(self.camera, 130) # The camera should look in ralph's direction, # but it should also try to stay horizontal, so look at # a floater which hovers above ralph's head. self.camera.lookAt(self.floater) return task.cont
class Game(ShowBase): def __init__(self): ShowBase.__init__(self) #Background sound (does not play infinitely) self.backgroundSound = base.loader.loadSfx("sounds/DireDireDocks.mp3") taskMgr.add(self.update, "moveTask") #Disable the mouse so that we may use it for our control scheme. self.props = WindowProperties() self.props.setSize(1920, 1080) self.props.setFullscreen(True) self.props.setCursorHidden(True) base.win.requestProperties(self.props) base.disableMouse() self.buildKeyMap() self.inMenu = True self.menuScreen = OnscreenImage("titlescreen.png", (0, .01, 0)) self.menu() def initialize(self): self.timer = 0 base.enableParticles() #base.setFrameRateMeter(True) ########## # # SETUP COLLISION HANDLERS AND FLAMIE'S MODEL # ########## #Create the collision handlers in order to build the level. WALL_MASK = BitMask32.bit(2) FLOOR_MASK = BitMask32.bit(1) #Start up the collision system self.cTrav = CollisionTraverser() #Determine how collisions with walls will be handled self.wallHandler = CollisionHandlerPusher() self.bobbing = False #Setup flamie's model self.flamieNP = base.render.attachNewNode(ActorNode('flamieNP')) self.flamieNP.reparentTo(base.render) self.flamie = loader.loadModel('models/Flame/body') self.flamie.setScale(.5) self.flamie.setTransparency(TransparencyAttrib.MAlpha) self.flamie.setAlphaScale(0) self.flamie.reparentTo(self.flamieNP) self.flamie.setCollideMask(BitMask32.allOff()) flameLight = DirectionalLight("flameLight") fl = self.flamie.attachNewNode(flameLight) fl.setColor(255, 255, 255, 1) flameLight.setDirection((-5, -5, -5)) self.flamie.setLight(fl) self.flamie2 = loader.loadModel("models/p.obj") self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f7.png")) self.flamie2.reparentTo(self.flamieNP) self.flamie2.setScale(4) self.flamie2OriZ = 2 self.flamie2.setPos(-6.5, 0, self.flamie2OriZ) #(length, depth, height) self.flamie2.setLight(fl) self.flamie2.setTransparency(TransparencyAttrib.MAlpha) self.flamieFire = PointLight('fire') self.flamieFire.setColor(VBase4(1,1,1,1)) self.flamieFire.setAttenuation((1,0,1)) plnp = render.attachNewNode(self.flamieFire) plnp.setPos(self.flamieNP.getPos()) self.flamielight = AmbientLight('light') self.flamielight.setColor(VBase4(1, 0.5, 0.6, 1)) self.flamielight = self.flamie2.attachNewNode(self.flamielight) self.flamie2.setLight(self.flamielight) self.flamie2.setLight(plnp) self.mayFlamieBob = True #self.flamie2.setAlphaScale(0.5) '''self.tree = loader.loadModel("models/p2.obj") self.tree.setTexture(loader.loadTexture("deadTree.png")) self.tree.reparentTo(render) self.tree.setScale(4) self.tree.setPos(25,25,0) #(length, depth, height) self.tree.setLight(fl) self.tree.setTransparency(TransparencyAttrib.MAlpha) self.treelight = AmbientLight('light') self.treelight.setColor(VBase4(0.9, 0.9, 0.6, 1)) self.treelight = self.tree.attachNewNode(self.treelight) self.tree.setLight(self.treelight)''' x = 150 y = 20 offset1 = 0 treeList2 = [loader.loadModel("models/p2.obj") for i in range(7)] for j in treeList2: k = random.randint(1, 100) if k%5 is 1 or k%5 is 2: j.setTexture(loader.loadTexture("deadTree.png")) else: j.setTexture(loader.loadTexture("tree.png")) j.reparentTo(render) j.setScale(random.randint(4,7)) j.setTransparency(TransparencyAttrib.MAlpha) j.setPos(x + 3*offset1, y + 4*offset1, 0) treelight = AmbientLight('light') treelight = j.attachNewNode(treelight) j.setLight(treelight) offset1 = offset1 + random.randint(4, 10) x = 4 y = 90 offset1 = 0 treeList2 = [loader.loadModel("models/p2.obj") for i in range(6)] for j in treeList2: k = random.randint(1, 100) if k%5 is 1 or k%5 is 2: j.setTexture(loader.loadTexture("deadTree.png")) else: j.setTexture(loader.loadTexture("tree.png")) j.reparentTo(render) j.setScale(random.randint(4,7)) j.setTransparency(TransparencyAttrib.MAlpha) j.setPos(x + 3*offset1, y + 4*offset1, 0) treelight = AmbientLight('light') treelight = j.attachNewNode(treelight) j.setLight(treelight) offset1 = offset1 + random.randint(4, 10) x = 3 y = 120 offset1 = 0 treeList2 = [loader.loadModel("models/p2.obj") for i in range(4)] for j in treeList2: k = random.randint(1, 100) if k%5 is 1 or k%5 is 2: j.setTexture(loader.loadTexture("deadTree.png")) else: j.setTexture(loader.loadTexture("tree.png")) j.reparentTo(render) j.setScale(random.randint(4,7)) j.setTransparency(TransparencyAttrib.MAlpha) j.setPos(x + 3*offset1, y + 4*offset1, 0) treelight = AmbientLight('light') treelight = j.attachNewNode(treelight) j.setLight(treelight) offset1 = offset1 + random.randint(4, 10) x = 200 y = 20 offset1 = 0 treeList2 = [loader.loadModel("models/p2.obj") for i in range(4)] for j in treeList2: k = random.randint(1, 100) if k%5 is 1 or k%5 is 2: j.setTexture(loader.loadTexture("deadTree.png")) else: j.setTexture(loader.loadTexture("tree.png")) j.reparentTo(render) j.setScale(random.randint(4,7)) j.setTransparency(TransparencyAttrib.MAlpha) j.setPos(x + 3*offset1, y + 4*offset1, 0) treelight = AmbientLight('light') treelight = j.attachNewNode(treelight) j.setLight(treelight) offset1 = offset1 + random.randint(4, 10) ### Something that should look like water ### w = loader.loadModel("models/flatP.obj") w.setTexture(loader.loadTexture("ice.png")) w.reparentTo(render) w.setScale(75) w.setTransparency(TransparencyAttrib.MAlpha) w.setAlphaScale(.7) w.setLight(treelight) w.setPos(-200, 0, -10) self.waterOrigiZ = -10 self.waterSecZ = -95 self.waterThirdZ = -120 self.water = w ### Reskying the sky ### w = loader.loadModel("models/biggerFlatP.obj") w.setTexture(loader.loadTexture("models/n2.jpg")) w.reparentTo(self.flamie2) w.setScale(15) w.setLight(treelight) w.setPos(-200, 450, -200) #(length, depth, height) #Give flamie gravity self.floorHandler = CollisionHandlerGravity() self.floorHandler.setGravity(9.81+100) self.floorHandler.setMaxVelocity(100) ########## # # GENERATING LEVEL PARTS # ########## self.ice_reset = () self.start = PlatformSeg(LVector3(0,0,0)) self.start.generateAllParts(render) self.checkpointCreator(70, 90, self.start.pos.z, 10) self.floater = False for p in self.start.parts: if isinstance(p, Prism): self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, p.dep, 'terraincollision', 'wallcollision') if isinstance(p, Square): self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, 3, 'terraincollision', 'wallcollision') if isinstance(p, IceCube): p.model.setCollideMask(BitMask32.allOff()) self.ice_reset += (p,) iceCubefloor= p.model.find("**/iceFloor") iceCubewall = p.model.find("**/iceWall") iceCubefloor.node().setIntoCollideMask(FLOOR_MASK) iceCubewall.node().setIntoCollideMask(WALL_MASK) self.lostWood = LostWood(LVector3(self.start.pos.x + 750, self.start.parts[0].pos.y + self.start.parts[0].wid, self.start.pos.z)) self.lostWood.generateAllParts(render) self.checkpointCreator(self.lostWood.pos.x+120, self.lostWood.pos.y+150, self.lostWood.pos.z,20) self.checkpointCreator(self.lostWood.parts[6].pos.x + self.lostWood.parts[6].len/2, self.lostWood.parts[6].pos.y + self.lostWood.parts[6].wid/2, self.lostWood.pos.z, 40) for p in self.lostWood.parts: if isinstance(p, Prism): self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, p.dep, 'terraincollision', 'wallcollision') if isinstance(p, Square): self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, 3, 'terraincollision', 'wallcollision') if isinstance(p, IceCube): p.model.setCollideMask(BitMask32.allOff()) self.ice_reset += (p,) iceCubefloor= p.model.find("**/iceFloor") iceCubewall = p.model.find("**/iceWall") iceCubefloor.node().setIntoCollideMask(FLOOR_MASK) iceCubewall.node().setIntoCollideMask(WALL_MASK) self.cave = Cave(LVector3(self.lostWood.pos.x + 1100, self.lostWood.pos.y + 2000, self.lostWood.pos.z - 50)) self.cave.generateAllParts(render) self.checkpointCreator(self.cave.thirdRoomParts[5].pos.x + self.cave.thirdRoomParts[5].len/2, self.cave.thirdRoomParts[5].pos.y + self.cave.thirdRoomParts[5].wid/2, self.cave.thirdRoomParts[5].pos.z, 30) for p in self.cave.parts: if isinstance(p, Prism): self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, p.dep, 'terraincollision', 'wallcollision') if isinstance(p, Square): self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, 3, 'terraincollision', 'wallcollision') if isinstance(p, IceCube): p.model.setCollideMask(BitMask32.allOff()) self.ice_reset += (p,) iceCubefloor= p.model.find("**/iceFloor") iceCubewall = p.model.find("**/iceWall") iceCubefloor.node().setIntoCollideMask(FLOOR_MASK) iceCubewall.node().setIntoCollideMask(WALL_MASK) self.end = End(LVector3(self.cave.thirdRoomParts[8].pos.x - 200, self.cave.thirdRoomParts[8].pos.y + self.cave.thirdRoomParts[8].wid, self.cave.thirdRoomParts[8].pos.z)) self.end.generate(render) self.collisionBoxCreator(self.end.floor.pos.x, self.end.floor.pos.y, self.end.floor.pos.z, self.end.floor.len, self.end.floor.wid, self.end.floor.dep, 'terraincollision', 'wallcollision') ######### # DRAWING THE CABIN AND FINAL CAMPFIRE ######### self.checkpointCreator(self.end.floor.pos.x + self.end.floor.len/2, self.end.floor.pos.y + self.end.floor.wid/2, self.end.floor.pos.z, 30) self.cabin = loader.loadModel("models/p2.obj") self.cabin.setTexture(loader.loadTexture("models/cabin.png")) self.cabin.setScale(50) self.cabin.reparentTo(render) self.cabin.setPos(self.end.floor.pos.x + self.end.floor.len/2, self.end.floor.pos.y + self.end.floor.wid/1.1, self.end.floor.pos.z) self.cabin.setTransparency(TransparencyAttrib.MAlpha) #Manually creating starting position. Copy and paste the first three parameters of the checkpoint you want to start at. self.startPos = LVector3(70, 90, self.start.pos.z) self.flamieNP.setPos(self.startPos) '''#Testing the tree model self.tree = loader.loadModel('models/Tree/log') self.tree.reparentTo(render) self.tree.setPos(-50,0,100) self.tree.setScale(2)''' '''#Add sky background self.sky = loader.loadModel('models/sphere.obj') self.sky.reparentTo(self.camera) self.sky.set_two_sided(True) self.skyTexture = loader.loadTexture("models/n2.jpg") self.sky.setTexture(self.skyTexture) self.sky.set_bin('background', 0) self.sky.set_depth_write(False) self.sky.set_compass()''' ########## # # CREATE FLAMIE'S COLLISION GEOMETRY # ########## #Give flamie a collision sphere in order to collide with walls flamieCollider = self.flamie.attachNewNode(CollisionNode('flamiecnode')) flamieCollider.node().addSolid(CollisionSphere(0,0,0,5)) flamieCollider.node().setFromCollideMask(WALL_MASK) flamieCollider.node().setIntoCollideMask(BitMask32.allOff()) self.wallHandler.addCollider(flamieCollider, self.flamieNP) self.cTrav.addCollider(flamieCollider, self.wallHandler) #Give flamie a collision ray to collide with the floor flamieRay = self.flamie.attachNewNode(CollisionNode('flamieRay')) flamieRay.node().addSolid(CollisionRay(0,0,8,0,0,-1)) flamieRay.node().setFromCollideMask(FLOOR_MASK) flamieRay.node().setIntoCollideMask(BitMask32.allOff()) self.floorHandler.addCollider(flamieRay, self.flamieNP) self.cTrav.addCollider(flamieRay, self.floorHandler) #Add a sensor that lets us melt ice cubes without standing on the cube. meltSensor = self.flamie.attachNewNode(CollisionNode('meltSensor')) cs = CollisionSphere(-2,0,10, 50) meltSensor.node().addSolid(cs) meltSensor.node().setFromCollideMask(WALL_MASK) meltSensor.node().setIntoCollideMask(BitMask32.allOff()) cs.setTangible(0) self.wallHandler.addCollider(meltSensor, self.flamieNP) self.cTrav.addCollider(meltSensor, self.wallHandler) self.wallHandler.addInPattern('%fn-into-%in') self.wallHandler.addAgainPattern('%fn-again-%in') self.accept('meltSensor-into-iceWall', self.melt) self.accept('meltSensor-again-iceWall', self.melt) self.accept('meltSensor-into-checkpointCol', self.newstart) #Add in an event handle to prevent the jumping glitch found on the bobbing ice cubes. self.floorHandler.addInPattern('%fn-into-%in') self.floorHandler.addAgainPattern('%fn-again-%in') self.floorHandler.addOutPattern('%fn-out-%in') self.accept('flamieRay-into-iceFloor', self.jittercancel) self.accept('flamieRay-again-iceFloor', self.jittercancel) self.accept('flamieRay-out-iceFloor', self.jittercanceloff) #Uncomment these lines to see flamie's collision geometry #flamieCollider.show() #flamieRay.show() #meltSensor.show() #Uncomment this line to see the actual collisions. #self.cTrav.showCollisions(render) #This plane is found at the very bottom of the level and adds global gravity. killfloor = CollisionPlane(Plane(Vec3(0,0,1), Point3(0,0,-1000))) killfloorCol = CollisionNode('kfcollision') killfloorCol.addSolid(killfloor) killfloorCol.setIntoCollideMask(BitMask32.bit(1)) killfloorColNp = self.render.attachNewNode(killfloorCol) #################### # # Setting light so that we could see the definition in the walls # #################### render.setShaderAuto() self.dlight = DirectionalLight('dlight') self.dlight.setColor(LVector4(0.3, 0.1, 0.7, 1)) dlnp = render.attachNewNode(self.dlight) dlnp.setHpr(90, 20, 0) render.setLight(dlnp) self.alight = render.attachNewNode(AmbientLight("Ambient")) self.alight.node().setColor(LVector4(0.5, 0.5, 1, .1)) render.setLight(self.alight) self.snow = loader.loadTexture("models/ground.jpg") #Create a floater object and have it float 2 units above fireball. #And use this as a target for the camera to focus on. #This idea is taken from the roaming ralph sample that came with the #Panda3D SDK. self.camFocus = NodePath(PandaNode("floater")) self.camFocus.reparentTo(render) self.camFocusCurrZ = self.flamie.getZ() + 10 #The camera is locked to the avatar so it always follows regardless of movement. self.camera.reparentTo(render) self.cameraTargetHeight = 8.0 self.cameraDistance = 100 self.cameraHeightModes = (self.start.parts[0].pos.z + 45, self.start.parts[0].pos.z + 125, self.camFocus.getZ() + 10, self.camFocus.getZ() + 150, self.end.floor.pos.z + 10) self.cameraHeight = self.cameraHeightModes[0] ################# # Changes Camera orientation depending on where the player is in the stage to compensate for the fact that # the player has no direct control of the camera. # Checks using the arrays from the level parts. ################## def cameraModes(self, delta): #Is the fireball within the platforming section between the starting area and the lost woods? #Is the fireball near the simple platforming sections of the LostWoods? #Is the fireball near the drop off point into the cave? #Is the fireball near the entrance to the second room in the cave? #If yes to any of these, bring the camera up to give a bird's eye view of the platforming if ((self.flamieNP.getX() > self.start.parts[1].pos.x and self.flamieNP.getY() > self.start.parts[1].pos.y - self.start.parts[1].wid and self.flamieNP.getX() < self.lostWood.parts[0].pos.x) or (self.flamieNP.getX() > self.lostWood.parts[0].pos.x + self.lostWood.parts[0].len/1.1 and self.flamieNP.getX() < self.lostWood.parts[2].pos.x + self.lostWood.parts[0].len/11 and self.flamieNP.getY() < self.lostWood.parts[0].pos.y + self.lostWood.parts[0].wid) or (self.flamieNP.getY() > self.cave.parts[0].pos.y - 20 and self.flamieNP.getY() <= self.cave.parts[0].pos.y + self.cave.parts[0].wid/2) or (self.flamieNP.getX() < self.cave.parts[1].pos.x + self.cave.parts[1].wid/10 and self.flamieNP.getY() >= self.cave.parts[1].pos.x)): camMode = 1 #Is the fireball in the beginning of the cave area? #If yes, bring the camera closer elif self.flamieNP.getY() > self.cave.parts[1].pos.y - self.cave.parts[0].wid/2 and self.flamieNP.getY() < self.cave.thirdRoomParts[5].pos.y: camMode = 2 else: camMode = 0 if self.flamieNP.getY() >= self.cave.thirdRoomParts[6].pos.y: self.cave.thirdRoomParts[0].hide() camMode = 3 if self.flamieNP.getY() >= self.cave.thirdRoomParts[8].pos.y + self.cave.thirdRoomParts[8].wid/1.5: camMode = 4 self.lerpCam(camMode, delta) def lerpCam(self, camMode, delta): CAMLERPSPEED = 25 if camMode == 0: if not self.cameraHeight == self.cameraHeightModes[camMode]: if self.cameraHeight - CAMLERPSPEED * delta <= self.cameraHeightModes[camMode]: self.cameraHeight = self.cameraHeightModes[camMode] else: self.cameraHeight = self.cameraHeight - CAMLERPSPEED * delta elif camMode == 1: if not self.cameraHeight == self.cameraHeightModes[camMode]: if self.cameraHeight - CAMLERPSPEED * delta >= self.cameraHeightModes[camMode]: self.cameraHeight = self.cameraHeightModes[camMode] else: if self.cameraHeight < self.cameraHeightModes[camMode]: self.cameraHeight = self.cameraHeight + CAMLERPSPEED * delta else: self.cameraHeight = self.cameraHeight - CAMLERPSPEED * delta elif camMode == 2: if not self.cameraHeight == self.cameraHeightModes[camMode]: if self.cameraHeight - CAMLERPSPEED * delta <= self.cameraHeightModes[camMode]: self.cameraHeight = self.cameraHeightModes[camMode] self.camFocusCurrZ = self.flamieNP.getZ() + 10 else: self.cameraHeight = self.cameraHeight - CAMLERPSPEED * delta self.camFocusCurrZ = self.flamieNP.getZ() + 10 elif camMode == 3: if not self.cameraHeight == self.cameraHeightModes[camMode]: if self.cameraHeight + CAMLERPSPEED * 3 * delta >= self.cameraHeightModes[camMode]: self.cameraHeight = self.cameraHeightModes[camMode] else: self.cameraHeight = self.cameraHeight + CAMLERPSPEED * 3 * delta elif camMode == 4: if not self.cameraHeight == self.cameraHeightModes[camMode]: if self.cameraHeight - CAMLERPSPEED * 3 * delta <= self.cameraHeightModes[camMode]: self.cameraHeight = self.cameraHeightModes[camMode] else: self.cameraHeight = self.cameraHeight - CAMLERPSPEED * 3 * delta def waterControl(self, delta): WATERLERPSPEED = .75 if self.flamieNP.getY() <= self.lostWood.parts[6].pos.y + self.lostWood.parts[6].wid/2: if not self.water.getZ() == self.waterOrigiZ: if self.water.getZ() - WATERLERPSPEED * delta < self.waterOrigiZ and self.water.getZ() > self.waterOrigiZ: self.water.setZ(self.waterOrigiZ) elif self.water.getZ() + WATERLERPSPEED * delta > self.waterOrigiZ and self.water.getZ() < self.waterOrigiZ: self.water.setZ(self.waterOrigiZ) else: if self.water.getZ() > self.waterOrigiZ: self.water.setZ(self.water, - WATERLERPSPEED * delta) if self.water.getZ() < self.waterOrigiZ: self.water.setZ(self.waterOrigiZ) else: self.water.setZ(self.water, + WATERLERPSPEED * delta) if self.water.getZ() > self.waterOrigiZ: self.water.setZ(self.waterOrigiZ) elif self.flamieNP.getY() <= self.cave.parts[1].pos.y: if not self.water.getZ() == self.waterSecZ: if self.water.getZ() - WATERLERPSPEED * delta < self.waterSecZ: self.water.setZ(self.waterSecZ) else: self.water.setZ(self.water, - WATERLERPSPEED * delta) else: if not self.water.getZ() == self.waterThirdZ: if self.water.getZ() - WATERLERPSPEED * delta < self.waterThirdZ: self.water.setZ(self.waterThirdZ) else: self.water.setZ(self.water, - WATERLERPSPEED * delta) def reset(self): self.flamieNP.setPos(self.startPos) self.camFocusCurrZ = self.flamieNP.getZ() + 10 for p in self.ice_reset: p.model.setScale(p.original_scale) def jump(self, dt): if self.bobbing: if self.floorHandler.getAirborneHeight() < 0.15: self.floorHandler.addVelocity(60) elif self.floorHandler.isOnGround(): self.floorHandler.addVelocity(60) def jittercancel(self, collEntry): model = collEntry.getIntoNodePath().getParent() modelRef = model.getPythonTag("iceRef") if model.getScale()[0] > 1.2: model.setScale(model.getScale()- modelRef.meltspeed) self.bobbing = True def jittercanceloff(self, collEntry): self.bobbing = False def melt(self, collEntry): model = collEntry.getIntoNodePath().getParent() modelRef = model.getPythonTag("iceRef") if model.getScale()[0] > 1.2 and self.bobbing != True: model.setScale(model.getScale()- modelRef.meltspeed) def newstart(self, collEntry): entry = collEntry.getInto().getCenter() self.startPos = (entry[0]+10, entry[1]+10, entry[2] +10) cp = loader.loadModel('models/Campfire/fire') cp.setPos(entry[0],entry[1], entry[2]) cp.reparentTo(render) def buildKeyMap(self): self.keyMap = {"left": 0, "right": 0, "forward": 0, "back": 0, "down": 0, "up": 0, "lookUp": 0, "lookDown": 0, "lookLeft": 0, "lookRight": 0} #I changed the control scheme let me know if you would like me to try something else. #WASD for movement, space for jump self.accept("escape", sys.exit) self.accept("a", self.setKey, ["left", True]) self.accept("a-up", self.setKey, ["left", False]) self.accept("d", self.setKey, ["right", True]) self.accept("d-up", self.setKey, ["right", False]) self.accept("w", self.setKey, ["forward", True]) self.accept("w-up", self.setKey, ["forward", False]) self.accept("s", self.setKey, ["back", True]) self.accept("s-up", self.setKey, ["back", False]) self.accept("space", self.setKey, ["down", True]) self.accept("space-up", self.setKey, ["down", False]) self.accept("shift", self.setKey, ["up", True]) self.accept("shift-up", self.setKey, ["up", False]) def setKey(self, key, value): self.keyMap[key] = value def update(self, task): delta = globalClock.getDt() if not self.inMenu: SPEED = 125 #Variable that holds what direction the player is inputting fblr = 0 self.timer += delta * 25 self.killPlane = self.water.getZ() - 25 if self.flamieNP.getZ() < self.killPlane: self.reset() if self.keyMap["left"]: fblr = 1 old_fblr = fblr self.flamieNP.setX(self.flamie, - SPEED * delta) if self.keyMap["right"]: fblr = 2 old_fblr = fblr self.flamieNP.setX(self.flamie, + SPEED * delta) if self.keyMap["forward"]: fblr = 3 old_fblr = fblr self.flamieNP.setY(self.flamie, + SPEED * delta) if self.keyMap["back"]: fblr = 4 old_fblr = fblr self.flamieNP.setY(self.flamie, - SPEED * delta) if self.keyMap["up"]: #self.flamieNP.setZ(self.flamie, - SPEED * dt) self.reset() #self.cameraDistance = 20+self.cameraDistance if self.keyMap["down"] and self.timer > 1: #self.flamieNP.setZ(self.flamie, + SPEED * dt) self.timer = 0 self.jump(delta) if fblr == 1: self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f8.png")) elif fblr == 2: self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f6.png")) elif fblr == 3: if old_fblr == 1: self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f1.png")) elif old_fblr == 2: self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f4.png")) else: self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f3.png")) else: self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f7.png")) if self.floorHandler.isOnGround: self.flamieBob(delta) #The camera control is borrowed from Kristina's Tech Demo #This is also a demo found at: http://www.panda3d.org/forums/viewtopic.php?t=8452 '''# mouse-controlled camera begins # Use mouse input to turn both the Character and the Camera if base.mouseWatcherNode.hasMouse(): md = base.win.getPointer(0) x = md.getX() y = md.getY() deltaX = md.getX() - 200 deltaY = md.getY() - 200 # reset mouse cursor position base.win.movePointer(0, 200, 200) # alter flamie's yaw by an amount proportionate to deltaX self.flamie.setH(self.flamie.getH() - 0.3* deltaX) # find the new camera pitch and clamp it to a reasonable range self.cameraPitch = self.cameraPitch + 0.1 * deltaY if (self.cameraPitch < -60): self.cameraPitch = -60 if (self.cameraPitch > 80): self.cameraPitch = 80 base.camera.setHpr(0,self.cameraPitch,0) # set the camera at around ralph's middle # We should pivot around here instead of the view target which is noticebly higher base.camera.setPos(0,0,self.cameraTargetHeight/2) # back the camera out to its proper distance base.camera.setY(base.camera,self.cameraDistance) # point the camera at the view target viewTarget = Point3(0,0,self.cameraTargetHeight) base.camera.lookAt(viewTarget) # reposition the end of the camera's obstruction ray trace #self.cameraRay.setPointB(base.camera.getPos()) # mouse-controlled camera ends''' self.waterControl(delta) self.water.setX(self.flamieNP.getX() - 250) self.water.setY(self.flamieNP.getY() - 250) self.cameraModes(delta) base.camera.setPos(self.flamieNP.getX(), self.flamieNP.getY() - self.cameraDistance, self.cameraHeight) self.camFocus.setPos(self.flamieNP.getX(), self.flamieNP.getY(), self.camFocusCurrZ) base.camera.lookAt(self.camFocus) ''' ###################### # # SIMPLE OCCLUSION FOR START AREA # ###################### for p in self.start.parts: if p.type == 'IceCube': if math.fabs((math.sqrt((p.model.getX() * p.model.getX()) + (p.model.getY() * p.model.getY())) - math.sqrt((self.camFocus.getX() * self.camFocus.getX()) + (self.camFocus.getY() * self.camFocus.getY())))) <= 400: p.show() #Ice cube movement p.bob(delta) else: p.hide() if p.type == 'Prism': if p.type == 'Prism': if math.fabs((math.sqrt((p.pos.x * p.pos.x) + (p.pos.y * p.pos.y)) - math.sqrt((self.camFocus.getX() * self.camFocus.getX()) + (self.camFocus.getY() * self.camFocus.getY())))) <= 1000: p.show() else: p.hide() ###################### # # SIMPLE OCCLUSION FOR CAVE PARTS # ###################### for p in self.cave.parts: if p.type == 'Prism': if math.fabs((math.sqrt((p.pos.x * p.pos.x) + (p.pos.y * p.pos.y)) - math.sqrt((self.flamieNP.getX() * self.flamieNP.getX()) + (self.flamieNP.getY() * self.flamieNP.getY())))) <= 2500: p.show() else: p.hide() if p.type == 'IceCube': if math.fabs((math.sqrt((p.model.getX() * p.model.getX()) + (p.model.getY() * p.model.getY())) - math.sqrt((self.flamieNP.getX() * self.flamieNP.getX()) + (self.flamieNP.getY() * self.flamieNP.getY())))) <= 2000: p.show() #Ice cube movement self.cave.moveIceCubes(delta/25) for p in self.cave.iceCubesThirdRoom: p.bob(delta/25) for p in self.cave.iceCubesSecondRoom: p.bob(delta/25) self.cave.bigCube.bob(delta/25) for p in self.start.iceCubes: p.bob(delta) else: p.hide() ''' #Ice cube movement self.cave.moveIceCubes(delta) for p in self.cave.iceCubesThirdRoom: p.bob(delta) for p in self.cave.iceCubesSecondRoom: p.bob(delta) self.cave.bigCube.bob(delta) for p in self.start.iceCubes: p.bob(delta) elif self.inMenu: self.menu() if self.backgroundSound.status() is not self.backgroundSound.PLAYING: self.backgroundSound.play() return task.cont def menu(self): if self.keyMap["down"]: self.inMenu = False self.menuScreen.destroy() self.initialize() def flamieBob(self, delta): if self.mayFlamieBob: self.flamie2.setZ(self.flamie2.getZ() + .5*delta) if self.flamie2.getZ() - self.flamie2OriZ > 1: self.mayFlamieBob = False else: self.flamie2.setZ(self.flamie2.getZ() - .5*delta) if self.flamie2.getZ() - self.flamie2OriZ < -2: self.mayFlamieBob = True #Function to create a box collision using six polygon. The top face is created as terrain and thus provides gravity. #While the rest of the faces only act as wall pushers. def collisionBoxCreator(self, posx, posy, posz, length, width, height, floorname, wallname): ret = () #Create top face terrain = CollisionPolygon(Point3(posx, posy+width, posz), Point3(posx, posy, posz), Point3(posx+length, posy, posz), Point3(posx+length, posy+width, posz)) terrainCol = CollisionNode(floorname) terrainCol.addSolid(terrain) terrainCol.setIntoCollideMask(BitMask32.bit(1)) terrainColNp = self.render.attachNewNode(terrainCol) self.cTrav.addCollider(terrainColNp, self.floorHandler) ret += (terrainColNp,) #Create left face sideLeft = CollisionPolygon(Point3(posx, posy+width, posz-height), Point3(posx, posy, posz-height), Point3(posx, posy, posz), Point3(posx, posy+width, posz)) sideLeftCol = CollisionNode(wallname) sideLeftCol.addSolid(sideLeft) sideLeftCol.setIntoCollideMask(BitMask32.bit(2)) sideLeftColNp = self.render.attachNewNode(sideLeftCol) self.cTrav.addCollider(sideLeftColNp, self.wallHandler) ret += (sideLeftColNp,) #Create right face sideRight = CollisionPolygon(Point3(posx+length, posy+width, posz), Point3(posx+length, posy, posz), Point3(posx+length, posy, posz-height), Point3(posx+length, posy+width, posz-height)) sideRightCol = CollisionNode(wallname) sideRightCol.addSolid(sideRight) sideRightCol.setIntoCollideMask(BitMask32.bit(2)) sideRightColNp = self.render.attachNewNode(sideRightCol) self.cTrav.addCollider(sideRightColNp, self.wallHandler) ret += (sideRightColNp,) #Create front face sideFront = CollisionPolygon(Point3(posx, posy+width, posz-height), Point3(posx, posy+width, posz), Point3(posx+length, posy+width, posz), Point3(posx+length, posy+width, posz-height)) sideFrontCol = CollisionNode(wallname) sideFrontCol.addSolid(sideFront) sideFrontCol.setIntoCollideMask(BitMask32.bit(2)) sideFrontColNp = self.render.attachNewNode(sideFrontCol) self.cTrav.addCollider(sideFrontColNp, self.wallHandler) ret += (sideFrontColNp,) #Create back face sideBack = CollisionPolygon(Point3(posx, posy, posz), Point3(posx, posy, posz-height), Point3(posx+length, posy, posz-height), Point3(posx+length, posy, posz)) sideBackCol = CollisionNode(wallname) sideBackCol.addSolid(sideBack) sideBackCol.setIntoCollideMask(BitMask32.bit(2)) sideBackColNp = self.render.attachNewNode(sideBackCol) self.cTrav.addCollider(sideBackColNp, self.wallHandler) ret += (sideBackColNp,) #Create bottom face sideBot = CollisionPolygon(Point3(posx, posy, posz-height), Point3(posx, posy+width, posz-height), Point3(posx+length, posy+width, posz-height), Point3(posx+length, posy, posz-height)) sideBotCol = CollisionNode(wallname) sideBotCol.addSolid(sideBot) sideBotCol.setIntoCollideMask(BitMask32.bit(2)) sideBotColNp = self.render.attachNewNode(sideBotCol) self.cTrav.addCollider(sideBotColNp, self.wallHandler) ret += (sideBotColNp,) #Uncomment these lines to see the collision polygons. '''terrainColNp.show() sideLeftColNp.show() sideRightColNp.show() sideFrontColNp.show() sideBackColNp.show() sideBotColNp.show()''' return ret #Old way of creating box collisions (left here for reference) '''box = CollisionBox((posx+(length/2), posy+(width/2),-(posz+height/2)), length/2, width/2, height/2) boxCol = CollisionNode('testcollision') boxCol.addSolid(box) boxCol.setIntoCollideMask(BitMask32.bit(2)) boxColNp = self.render.attachNewNode(boxCol) boxHandler = CollisionHandlerQueue() self.cTrav.addCollider(boxColNp, self.wallHandler) #Uncomment this line to see the collision solids. #boxColNp.show()''' def checkpointCreator(self, posx, posy, posz, radius): cp = loader.loadModel('models/Campfire/logs') cp.setPos(posx,posy, posz) cp.reparentTo(render) checkpoint = CollisionSphere(cp.getX(),cp.getY(),cp.getZ(),radius) checkpoint.setTangible(0) checkpointCol = CollisionNode('checkpointCol') checkpointCol.addSolid(checkpoint) checkpointCol.setIntoCollideMask(BitMask32.bit(2)) checkpointColNp = self.render.attachNewNode(checkpointCol) self.cTrav.addCollider(checkpointColNp, self.wallHandler)
class Labrintth(ShowBase): def __init__(self): #from panda3d bump mapping demo # Configure the parallax mapping settings (these are just the defaults) loadPrcFileData("", "parallax-mapping-samples 3\n" "parallax-mapping-scale 0.1") # Initialize the ShowBase class from which we inherit, which will # create a window and set up everything we need for rendering into it. ShowBase.__init__(self) #titles from panda3d bumb mapping demo # Check video card capabilities. if not self.win.getGsg().getSupportsBasicShaders(): addTitle("Bump Mapping: " "Video driver reports that Cg shaders are not supported.") return self.playerHealth = 10 self.loseHealth = True brickTexture = loader.loadTexture("models/brick-c.jpg") self.lstWalls = makeMaze() self.ptGrid = makePointGrid() #self.camera.setPos(self.ptGrid[len(self.ptGrid)-1][0]) self.focus = LVector3(0,1000,30) for row in range(len(self.ptGrid)): for col in range(len(self.ptGrid[row])): for n in range(2): #wall model made by 'TheCreator', https://free3d.com/3d-model/brick-wall-51172.html self.wall = loader.loadModel("models/walls") self.wall.setTexture(brickTexture) self.wall.setScale(25.3) self.wall.setPos(self.ptGrid[row][col]) self.wallC = self.wall.find("**/collideWall") self.wallC.node().setIntoCollideMask(BitMask32.bit(0)) self.wallC.show() #right of cell if n == 0: if self.lstWalls[row][col][n] == 1: self.wall.setX(self.wall, 1.05) self.wall.setZ(5) self.wall.reparentTo(render) #down of cell else: if self.lstWalls[row][col][n] == 1: self.wall.setHpr(90,0,0) self.wall.setX(self.wall, -3) self.wall.setZ(5) self.wall.reparentTo(render) self.spacing = self.ptGrid[0][1][0] - self.ptGrid[0][0][0] self.exit = loader.loadModel('models/walls') self.exit.setScale(25.3) self.exit.setColorScale(0.6,0.6,1,1) self.exitCoord, wall = generateDoor(self.ptGrid, self.lstWalls) self.exitPos = self.ptGrid[self.exitCoord[0]][self.exitCoord[1]] self.exit.setPos(self.exitPos) for n in range(2): if n == 0: if wall[n] == 2: self.exit.setX(self.exit, 1.15) self.exit.setZ(5) #down of cell else: if wall[n] == 2: self.exit.setHpr(90,0,0) self.exit.setX(self.exit, -3.2) self.exit.setZ(5) self.exit.reparentTo(render) self.exit.detachNode() numPpl = 15 #make first pos minotaur pplLst = [] pplLst = generatePosLst(pplLst, numPpl, self.ptGrid, self.spacing) targetPos = pplLst[random.randint(1, len(pplLst)-1)] print('target:',targetPos) #ball model from panda3D ball in maze demo num = 0 for pos in range(1, len(pplLst)): num += 1 #if the person in the list is the minotaur's target, set it's #name to self.target if pplLst[pos] == targetPos: self.target = loader.loadModel("models/alfred") self.target.setPos(pplLst[pos]) self.target.setScale(5) self.target.reparentTo(render) self.targetK = self.target.attachNewNode(CollisionNode('targetDie')) self.targetK.node().addSolid(CollisionSphere(0, 0, 5, 6)) self.targetK.node().setIntoCollideMask(BitMask32.bit(2)) #self.targetK.show() self.targetS = self.target.attachNewNode(CollisionNode('targetSave')) self.targetS.node().addSolid(CollisionSphere(0, 0, 5, 6)) self.targetS.node().setIntoCollideMask(BitMask32.bit(1)) #self.targetS.show() #otherwise, keep it as a self.ppl else: self.ppl = loader.loadModel("models/alfred") self.ppl.setPos(pplLst[pos]) self.ppl.setScale(5) #put a tag on each person so we can tell them apart self.ppl.setTag('personNum', str(num)) self.ppl.reparentTo(render) #make it so that the people can be collision detected self.pplC = self.ppl.attachNewNode(CollisionNode('pplCollision')) self.pplC.node().addSolid(CollisionSphere(0, 0, 5, 7)) self.pplC.node().setIntoCollideMask(BitMask32.bit(1)) self.pplC.setTag('personCNum', str(num)) #self.pplC.show() #first index in pplLst = minotar minotaurPos = pplLst[0] #Minotaur 3d model by 'Clint Bellanger' https://opengameart.org/content/minotaur self.minotaur = Actor("models/TheMinotaur") self.minotaur.setPos(minotaurPos) self.minotaur.setScale(25) self.minotaur.reparentTo(render) minotaurTexture = loader.loadTexture("models/catfur.jpg") self.minotaur.setTexture(minotaurTexture) self.minC = self.minotaur.attachNewNode(CollisionNode('minCollision')) self.minC.node().addSolid(CollisionSphere(0 , 0, 1, 0.5)) self.minC.node().setFromCollideMask(BitMask32.bit(2)) #self.minC.node().setIntoCollideMask(BitMask32.bit(1)) #self.minC.show() self.minBat = self.minotaur.attachNewNode(CollisionNode('battle')) self.minBat.node().addSolid(CollisionSphere(0, 0, 1, 4.3)) self.minBat.node().setIntoCollideMask(BitMask32.bit(1)) self.minBat.show() self.minHit = self.minotaur.attachNewNode(CollisionNode('hit')) self.minHit.node().addSolid(CollisionSphere(0, 0, 1.5, 0.4)) self.minHit.node().setIntoCollideMask(BitMask32.bit(3)) self.minAtk = self.minotaur.attachNewNode(CollisionNode('attack')) self.minAtk.node().addSolid(CollisionSphere(0, 0, 1.85, 0.4)) self.minAtk.node().setIntoCollideMask(BitMask32.bit(4)) self.minAtk.show() self.cTrav = CollisionTraverser() self.cHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.minC, self.cHandler) self.cTrav.addCollider(self.minAtk, self.cHandler) self.minotaurObj = Minotaur(self.minotaur.getPos()) #find the path the minotaur takes to kill the person self.killPath = self.minotaurObj.findPerson(minotaurPos, targetPos, self.ptGrid, self.lstWalls, self.spacing) self.minSpeed = 1 self.sleepDelay = 13 self.killFlag = True self.killDone = False self.killPause = False self.killPaused = False self.hit = False self.hurtTime = 0 self.minDied = False self.minTimeDied = 0 self.attackTrig = False self.warningTrig = True taskMgr.add(self.minotaurKilling, "minotaurKilling") taskMgr.add(self.minotaurDie, 'minotaurDied') taskMgr.add(self.pauseKill, 'pauseKill') self.saved = 0 self.addSaved = False self.saveTrig = False taskMgr.add(self.displaySaved, "saved") #collisions #create a ball for collisions self.camBall = loader.loadModel("models/ball") self.camBall.setPos(self.spacing/2, self.spacing/2, -1) self.camBall.setScale(10) #self.camBall.setColorScale(0, 1, 0.7, 1) self.camBall.reparentTo(render) self.playerPos = (0,0,0) self.camBallC = self.camBall.find("**/ball") #self.camBallC = self.camBall.attachNewNode(CollisionNode('camCollision')) #self.camBallC.node().addSolid(CollisionSphere(0, 0, 0, 1.2)) self.camBallC.node().setFromCollideMask(BitMask32.bit(0)) self.pusher = CollisionHandlerPusher() self.pusher.addCollider(self.camBallC, self.camBall) self.cTrav.addCollider(self.camBallC, self.pusher) self.camBallC.setPos(0,0.0002,0) self.camC = self.camera.attachNewNode(CollisionNode('cameraCollision')) self.camC.node().addSolid(CollisionSphere(0, 0, 0, 0.01)) self.camC.node().setFromCollideMask(BitMask32.bit(1)) self.camC.node().setIntoCollideMask(BitMask32.bit(4)) self.camC.show() self.cTrav.addCollider(self.camC, self.cHandler) taskMgr.add(self.disappear, "disappear") #sting-sword model created by KangaroOz 3D, from: https://www.turbosquid.com/FullPreview/Index.cfm/ID/1125944 self.sword = loader.loadModel('models/sting-sword') self.sword.wrtReparentTo(self.camBall) self.sword.detachNode() self.sword.setY(1) self.sword.setX(0.5) self.sword.setZ(0.2) self.sword.setScale(0.07) self.swordC = self.sword.attachNewNode(CollisionNode('stab')) self.swordC.node().addSolid(CollisionSphere(0, 25, 0, 2)) self.swordC.node().setFromCollideMask(BitMask32.bit(3)) #self.swordC.show() self.attacked = False self.stabbing = False self.cTrav.add_collider(self.swordC, self.cHandler) swordTexture = loader.loadTexture("models/Sting_Emissive.png") self.sword.setTexture(swordTexture) self.stabDelay = 0 self.redBarL = loader.loadModel('models/walls') self.redBarL.setScale(3) self.redBarL.setColorScale(250,0,0,1) self.redBarL.setPos(38.5, 60,5) self.redBarL.wrtReparentTo(self.camBall) self.redBarL.detachNode() self.redBarR = loader.loadModel('models/walls') self.redBarR.setScale(3) self.redBarR.setColorScale(250,0,0,1) self.redBarR.setPos(55.7,60,5) self.redBarR.wrtReparentTo(self.camBall) self.redBarR.detachNode() self.hurtTimeP = 0 #make list of controls self.keyMap = { "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0,\ "cam-right": 0, "stab":0, "map": 0, "instrMode":0, "gameMode":0} # Make the mouse invisible, turn off normal mouse controls self.disableMouse() props = WindowProperties() props.setCursorHidden(True) # Set the current viewing target self.heading = 0 self.pitch = 0 self.last = 0 self.startMode = True self.startTrig = True self.startDestroy = True self.instrMode = False self.instrTrig = True self.instrShown = False self.instrDestroy = True self.gameMode = False self.bkGround = loader.loadModel('models/walls') self.bkGround.reparentTo(self.camBall) self.bkGround.setColorScale(0,0.5,0.55,1) self.bkGround.setPos(-1,3,0) taskMgr.add(self.showStart, "start-screen") taskMgr.add(self.controlCamera, "camera-task") self.accept("escape", sys.exit, [0]) self.accept("o", self.setKey, ["instrMode", True]) self.accept("p", self.setKey, ["gameMode", True]) self.accept("arrow_left", self.setKey, ["left", True]) self.accept("arrow_right", self.setKey, ["right", True]) self.accept("arrow_up", self.setKey, ["forward", True]) self.accept("arrow_down", self.setKey, ["backward", True]) self.accept("w", self.setKey, ["stab", True]) self.accept("s", self.setKey, ["down", True]) self.accept("arrow_left-up", self.setKey, ["left", False]) self.accept("arrow_right-up", self.setKey, ["right", False]) self.accept("arrow_up-up", self.setKey, ["forward", False]) self.accept("arrow_down-up", self.setKey, ["backward", False]) self.accept("w-up", self.setKey, ["stab", False]) self.accept("s-up", self.setKey, ["down", False]) self.accept("a", self.setKey, ["cam-left", True]) self.accept("d", self.setKey, ["cam-right", True]) self.accept("a-up", self.setKey, ["cam-left", False]) self.accept("d-up", self.setKey, ["cam-right", False]) self.accept("space", self.setKey, ["map", True]) self.accept("space-up", self.setKey, ["map", False]) def setKey(self, key, value): self.keyMap[key] = value def startKill(self): try: self.target.setColorScale(250,0,0,1) except: pass intervalL = self.intervalLst() self.kill = Sequence(intervalL[0], name = 'kill person') for i in range(1, len(intervalL)): self.kill.append(intervalL[i]) self.kill.start() def pauseKill(self, task): print(self.killPaused, self.killPause) if self.gameMode == True: if self.killDone == True: self.kill.finish() if self.killPaused == False and self.killPause == True: print('hmmmmmmmmmmmm') self.kill.pause() self.killPaused = True if self.killPaused == True and self.killPause == False: self.kill.resume() self.killPaused = False return Task.cont def intervalLst(self): intervals = [] for i in range(len(self.killPath)): intervals += [self.minotaur.posInterval(self.minSpeed, Point3(self.killPath[i]))] return intervals def stab(self, task): timer = globalClock.getFrameTime() speed = 0.2 stabIn = LerpPosInterval(self.sword, speed, Point3(0,4,0.2)) stabOut = LerpPosInterval(self.sword, speed, Point3(0.5,1,0.2)) stab = Sequence(stabIn, stabOut, name = 'stab') stab.start() self.stabbing = True if self.hit == True: self.minotaurObj.hit() self.hurtTime = globalClock.getFrameTime() self.hurtShow(task) self.hit = False self.stabbing = False def hurtShow(self, task): if self.hit == True: timer = globalClock.getFrameTime() if timer - self.hurtTime < 2: self.minotaur.setColorScale(180,0,0,1) return Task.cont def attack(self, task): if self.attackTrig == True: speed = 1 turnSpeed = 0.5 attackPos, distance, direction = self.minotaurObj.attack(self.camera.getPos(), self.minotaur.getPos(), \ self.ptGrid, self.spacing, self.lstWalls) origPt = self.minotaur.getPos() if attackPos != None: attack = LerpPosInterval(self.minotaur, speed, Point3(attackPos)) turnToPlayer = LerpHprInterval(self.minotaur, turnSpeed, self.minotaurObj.facePlayer(direction)) if distance == 'short': retract = LerpPosInterval(self.minotaur, speed, origPt) attackSeq = Sequence(turnToPlayer, attack, retract, name = 'attack') attackSeq.start() else: attackSeq = Sequence(turnToPlayer, attack, name = 'attack') attackSeq.start() self.attackTrig = False def attackShow(self, task): if self.attacked == True: timer = globalClock.getFrameTime() if timer - self.hurtTimeP < 2: self.redBarL.reparentTo(self.camBall) self.redBarR.reparentTo(self.camBall) if self.loseHealth == True: self.playerHealth -= 10 print(self.playerHealth) self.loseHealth = False return Task.cont def displaySaved(self, task): if self.gameMode == True: if self.saved == 0 and self.saveTrig == False: msg = 'Saved: ' + str(self.saved) self.displSaved = OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), scale=.05, shadow=(0, 0, 0, 1),parent=base.a2dTopLeft, align=TextNode.ALeft, pos=(0.05, -1.9)) self.saveTrig = True if self.addSaved == True and self.saveTrig == True and self.saved > 0: print('here') self.displSaved.destroy() msg = 'Saved: ' + str(self.saved) self.displSaved = OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), scale=.05, shadow=(0, 0, 0, 1),parent=base.a2dTopLeft, align=TextNode.ALeft, pos=(0.05, -1.9)) self.addSaved = False return Task.cont def minotaurKilling(self, task): if self.gameMode == True: #timer for minotaur sleeping timer = globalClock.getFrameTime() timeLeft = self.sleepDelay - int(timer) #put up the instructions before the minotaur wakes up if timeLeft >= 0: if self.warningTrig == True: if timeLeft == 1: msg = "You have 1 second to find the Minotaur before he wakes up!" elif timeLeft == 0: msg = "He's awake!" else: msg = "You have " + str(timeLeft) + " seconds to find the Minotaur before he wakes up!" self.warning = OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), scale=0.08, shadow=(0, 0, 0, 1),parent=base.a2dTopLeft, align=TextNode.ALeft, pos=(0.05, -0.08)) self.displayWarning = timer self.warningTrig = False if timer - self.displayWarning > 0.92: self.warning.destroy() self.warningTrig = True if timeLeft < 0: self.warning.destroy() #wake the minotaur up after time ends if timeLeft < 0 and self.killFlag == True: self.startKill() self.killFlag = False #make sure minotaur is always the right color if timer - self.hurtTime > 2: self.minotaur.setColorScaleOff() if timer - self.hurtTimeP > 2: self.redBarL.detachNode() self.redBarR.detachNode() if self.minDied == True: if timer - self.minTimeDied > 20: self.minotaur.detachNode() self.exit.reparentTo(render) self.showRopes() if timer - self.hurtTimeP > 2: self.loseHealth = True return Task.cont def minotaurDie(self, task): if self.minotaurObj.health <= 0 and self.minDied == False: dieSpeed = 3 die = LerpHprInterval(self.minotaur, dieSpeed, (self.camera.getX(), 90, 5)) die.start() self.minDied = True self.minTimeDied = globalClock.getDt() return Task.cont def showropes(self): ropeHeight = 30 lastRope = findExitPos(self.exitPos, self.ptGrid, self.spacing) playerPos = findPlayerPos(self.camera.getPos(), self.spacing) playerPos = (playerPos[0], playerPos[1], ropeHeight) ropePath, ropeDir = findExit(playerPos, lastRope, self.ptGrid, self.lstWalls, self.spacing) lastDir = findDir(self.exitCoord, self.ptGrid) if ropeDir != None: ropeDir += [lastDir] #gold texture found at https://www.google.com/url?sa=i&source=images&cd=&cad=r\ #ja&uact=8&ved=2ahUKEwjw76Lbv4rfAhVpvFkKHY3JDPYQjRx6BAgBEAU&url=http%3A%2F\ #%2Fmetal.graphics%2Fgraphic%2Fbrushed%2Fgold-texture%2F&psig=AOvVaw1q3Yu\ #xuuGvetU4fhA1cIqh&ust=1544161415078294 goldTexture = loader.loadTexture("models/gold.jpg") if ropePath != None: #rope model by Robert J. Smith, https://www.cgtrader.com/free-3d-models/industrial/tool/knot-rope for pos in range(len(ropePath)): rope = loader.loadModel("models/rope1") rope.setPos(ropePath[pos]) rope.setScale(3.6) rope.setZ(-5) if pos < len(ropeDir): if ropeDir[pos] == 'e': rope.setHpr(76,0,0) rope.setX(rope.getX() + 75) rope.setY(rope.getY() + 5) if ropeDir[pos] == 'n': rope.setHpr(166,0,0) rope.setY(rope.getY() + 65) if ropeDir[pos] == 'w': rope.setHpr(256,0,0) rope.setX(rope.getX() - 60) rope.setY(rope.getY() - 9) if ropeDir[pos] == 's': rope.setHpr(-14,0,0) rope.setY(rope.getY() - 70) rope.setX(rope.getX() + 15) rope.setTexture(goldTexture) rope.reparentTo(render) def lostGame(self): lose = loader.loadModel('models/walls') lose.reparentTo(self.camBall) lose.setColorScale(0.1,0.1,0.1,1) lose.setPos(-1,3,0) def showStart(self, task): startMsg = "Welcome to Daedalus's Creation." startMsg2 = "You have to kill the minotaur, navegate the labyrinth, and save the others."+"You have 30 seconds to find the Minotaur before he wakes up and starts killing your people." startMsg3 = "Good luck doing what no man has done before." startMsg4 = "Press 'o' for instructions on how to play." if self.startMode == True and self.startTrig == True: self.start = OnscreenText(text=startMsg, style=1, fg=(1, 1, 1, 1), scale=0.08, shadow=(0, 0, 0, 1),parent=base.aspect2d, pos = (0,0.5), align=TextNode.ACenter, wordwrap= 15) self.start2 = OnscreenText(text=startMsg2, style=1, fg=(1, 1, 1, 1), scale=0.08, shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,0.2), wordwrap= 20) self.start3 = OnscreenText(text=startMsg3, style=1, fg=(1, 1, 1, 1), scale=0.08, shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,-0.2), wordwrap= 25) self.start4 = OnscreenText(text=startMsg4, style=1, fg=(1, 1, 1, 1), scale=0.1, shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,-0.5), wordwrap= 25) self.startTrig = False if self.startMode == False and self.startDestroy == True: self.start.destroy() self.start2.destroy() self.start3.destroy() self.start4.destroy() self.startDestroy = False task.remove() return Task.cont def showInstr(self): instrMsg = "Press the right and left arrow keys to move right and left." instrMsg1 = "Press the up and down arrow keys to move forwards and backwards." instrMsg2 = "Press the 'a' key to turn the camera left." instrMsg3 = "Press the 'd' key to turn the camera right." instrMsg4 = "Press the space key for a map of the labyrinth" instrMsg5 = "Press the 'w' key to attack." instrMsg6 = "Press the 'p' key to start the game." if self.instrMode == True and self.instrTrig == True: self.instr = OnscreenText(text=instrMsg, style=1, fg=(1, 1, 1, 1), scale=0.08, shadow=(0, 0, 0, 1),parent=base.aspect2d, pos = (0,0.7), align=TextNode.ACenter, wordwrap= 30) self.instr1 = OnscreenText(text=instrMsg1, style=1, fg=(1, 1, 1, 1), scale=0.08, shadow=(0, 0, 0, 1),parent=base.aspect2d, pos = (0,0.5), align=TextNode.ACenter, wordwrap= 20) self.instr2 = OnscreenText(text=instrMsg2, style=1, fg=(1, 1, 1, 1), scale=0.08, shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,0.2), wordwrap= 20) self.instr3 = OnscreenText(text=instrMsg3, style=1, fg=(1, 1, 1, 1), scale=0.08, shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,0), wordwrap= 25) self.instr4 = OnscreenText(text=instrMsg4, style=1, fg=(1, 1, 1, 1), scale=0.08, shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,-0.2), wordwrap= 25) self.instr5 = OnscreenText(text=instrMsg5, style=1, fg=(1, 1, 1, 1), scale=0.08, shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,-0.4), wordwrap= 25) self.instr6 = OnscreenText(text=instrMsg6, style=1, fg=(1, 1, 1, 1), scale=0.1, shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,-0.6), wordwrap= 25) self.instrTrig = False self.instrShown = True def endInstr(self): if self.instrMode == False and self.instrDestroy == True and self.instrShown == True: self.instr.destroy() self.instr1.destroy() self.instr2.destroy() self.instr3.destroy() self.instr4.destroy() self.instr5.destroy() self.instr6.destroy() self.instrDestroy = False #make the person disappear when it's touched def disappear(self,task): for i in range(self.cHandler.getNumEntries()): entry = self.cHandler.getEntry(i) fromNode = entry.getFromNodePath() intoNode = entry.getIntoNodePath() intoName = entry.getIntoNode().getName() fromName = entry.getFromNode().getName() #if the collision was with a person if (intoName == 'pplCollision' and fromName == 'cameraCollision'): num = intoNode.getTag("personCNum") tag = '**/=personNum=' + num #finds the person player collided into and removes them person = render.find(tag) person.removeNode() #add one to saved counter self.saved += 1 self.addSaved = True self.displSaved.destroy() return Task.cont if intoName == 'targetSave' and fromName == 'cameraCollision': print('saved!') self.target.removeNode() self.saved += 1 self.addSaved = True return Task.cont if intoName == 'targetDie' and fromName == 'minCollision': print('ahhhhhhhhh!') self.target.removeNode() self.killDone = True return Task.cont #if minotaur gets stabbed by player if intoName == 'hit' and fromName == 'stab': if self.stabbing == True: self.hit = True return Task.cont if intoName == 'cameraCollision' and fromName == 'attack': print('attacked!!!!!') self.attacked = True self.hurtTimeP = globalClock.getFrameTime() self.attackShow(task) if self.playerHealth < 0: self.lostGame() return Task.cont if (intoName == 'battle' and fromName == 'cameraCollision' and self.killFlag == False) \ or (intoName == 'minCollision' and fromName == 'cameraCollision' and self.killFlag == False): print('pause') self.killPause = True return Task.cont else: print('hereeeee') self.killPause = False print('killPause', self.killPause) return Task.cont #structure from panda3d bump mapping demo def controlCamera(self, task): dt = globalClock.getDt() self.camera.setHpr(self.heading, self.pitch, 0) self.camBall.setHpr(self.heading, self.pitch, 0) dir = self.camera.getMat().getRow3(1) camPos = (self.camBall.getPos()[0], self.camBall.getPos()[1], 6) self.camera.setPos(camPos) if self.keyMap["instrMode"] == True: self.startMode = False self.instrMode = True self.showInstr() if self.keyMap["gameMode"] == True: self.instrMode = False self.gameMode = True self.bkGround.detachNode() self.endInstr() if self.gameMode == True: #move camera right and left if self.keyMap["left"]: self.camBall.setX(self.camBall, -10*dt) if self.keyMap["right"]: self.camBall.setX(self.camBall, +10*dt) if self.keyMap["forward"]: self.camBall.setY(self.camBall, +10*dt) if self.keyMap["backward"]: self.camBall.setY(self.camBall, -10*dt) #rotate camera if self.keyMap["cam-right"]: self.heading = self.heading - 100*dt if self.keyMap["cam-left"]: self.heading = self.heading + 100*dt self.focus = self.camera.getPos() + (dir * 5) self.last = task.time if self.keyMap['stab']: timer = globalClock.getFrameTime() if timer - self.stabDelay > 0.5: self.stab(task) self.stabDelay = timer self.attack(task) self.attackTrig = True #show map if self.keyMap["map"] == True: center = (len(self.ptGrid))/2*self.spacing self.camera.setPos(center,center, 1.8*len(self.ptGrid)*self.spacing) self.camera.lookAt(center, center, 0) self.sword.detachNode() if self.killFlag == False and self.killPause == True: self.kill.pause() self.camBall.reparentTo(render) self.camBall.setScale(20) self.camBall.setColorScale(0, 0.5, 1, 1) if self.keyMap["map"] == False and self.startMode == False and self.instrMode == False: self.sword.reparentTo(self.camBall) self.camBall.setColorScaleOff() self.camBall.setScale(10) return Task.cont
class CogdoFlyingCollisions(GravityWalker): wantFloorSphere = 0 def __init__(self): GravityWalker.__init__(self, gravity=0.0) def initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius=1.4, floorOffset=1.0, reach=1.0): self.cHeadSphereNodePath = None self.cFloorEventSphereNodePath = None self.setupHeadSphere(avatarNodePath) self.setupFloorEventSphere(avatarNodePath, ToontownGlobals.FloorEventBitmask, avatarRadius) GravityWalker.initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius, floorOffset, reach) return def setupWallSphere(self, bitmask, avatarRadius): self.avatarRadius = avatarRadius cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius) cSphereNode = CollisionNode('Flyer.cWallSphereNode') cSphereNode.addSolid(cSphere) cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) if config.GetBool('want-fluid-pusher', 0): self.pusher = CollisionHandlerFluidPusher() else: self.pusher = CollisionHandlerPusher() self.pusher.addCollider(cSphereNodePath, self.avatarNodePath) self.cWallSphereNodePath = cSphereNodePath def setupEventSphere(self, bitmask, avatarRadius): self.avatarRadius = avatarRadius cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius * 1.04) cSphere.setTangible(0) cSphereNode = CollisionNode('Flyer.cEventSphereNode') cSphereNode.addSolid(cSphere) cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) self.event = CollisionHandlerEvent() self.event.addInPattern('enter%in') self.event.addOutPattern('exit%in') self.cEventSphereNodePath = cSphereNodePath def setupRay(self, bitmask, floorOffset, reach): cRay = CollisionRay(0.0, 0.0, 3.0, 0.0, 0.0, -1.0) cRayNode = CollisionNode('Flyer.cRayNode') cRayNode.addSolid(cRay) self.cRayNodePath = self.avatarNodePath.attachNewNode(cRayNode) cRayNode.setFromCollideMask(bitmask) cRayNode.setIntoCollideMask(BitMask32.allOff()) self.lifter = CollisionHandlerGravity() self.lifter.setLegacyMode(self._legacyLifter) self.lifter.setGravity(self.getGravity(0)) self.lifter.addInPattern('%fn-enter-%in') self.lifter.addAgainPattern('%fn-again-%in') self.lifter.addOutPattern('%fn-exit-%in') self.lifter.setOffset(floorOffset) self.lifter.setReach(reach) self.lifter.addCollider(self.cRayNodePath, self.avatarNodePath) def setupHeadSphere(self, avatarNodePath): collSphere = CollisionSphere(0, 0, 0, 1) collSphere.setTangible(1) collNode = CollisionNode('Flyer.cHeadCollSphere') collNode.setFromCollideMask(ToontownGlobals.CeilingBitmask) collNode.setIntoCollideMask(BitMask32.allOff()) collNode.addSolid(collSphere) self.cHeadSphereNodePath = avatarNodePath.attachNewNode(collNode) self.cHeadSphereNodePath.setZ(base.localAvatar.getHeight() + 1.0) self.headCollisionEvent = CollisionHandlerEvent() self.headCollisionEvent.addInPattern('%fn-enter-%in') self.headCollisionEvent.addOutPattern('%fn-exit-%in') base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent) def setupFloorEventSphere(self, avatarNodePath, bitmask, avatarRadius): cSphere = CollisionSphere(0.0, 0.0, 0.0, 0.75) cSphereNode = CollisionNode('Flyer.cFloorEventSphere') cSphereNode.addSolid(cSphere) cSphereNodePath = avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) self.floorCollisionEvent = CollisionHandlerEvent() self.floorCollisionEvent.addInPattern('%fn-enter-%in') self.floorCollisionEvent.addAgainPattern('%fn-again-%in') self.floorCollisionEvent.addOutPattern('%fn-exit-%in') base.cTrav.addCollider(cSphereNodePath, self.floorCollisionEvent) self.cFloorEventSphereNodePath = cSphereNodePath def deleteCollisions(self): GravityWalker.deleteCollisions(self) if self.cHeadSphereNodePath != None: base.cTrav.removeCollider(self.cHeadSphereNodePath) self.cHeadSphereNodePath.detachNode() self.cHeadSphereNodePath = None self.headCollisionsEvent = None if self.cFloorEventSphereNodePath != None: base.cTrav.removeCollider(self.cFloorEventSphereNodePath) self.cFloorEventSphereNodePath.detachNode() self.cFloorEventSphereNodePath = None self.floorCollisionEvent = None self.cRayNodePath.detachNode() del self.cRayNodePath self.cEventSphereNodePath.detachNode() del self.cEventSphereNodePath return def setCollisionsActive(self, active=1): if self.collisionsActive != active: if self.cHeadSphereNodePath != None: base.cTrav.removeCollider(self.cHeadSphereNodePath) if active: base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent) if self.cFloorEventSphereNodePath != None: base.cTrav.removeCollider(self.cFloorEventSphereNodePath) if active: base.cTrav.addCollider(self.cFloorEventSphereNodePath, self.floorCollisionEvent) GravityWalker.setCollisionsActive(self, active) return def enableAvatarControls(self): pass def disableAvatarControls(self): pass def handleAvatarControls(self, task): pass
class TheWorld(ShowBase): def __init__(self): ShowBase.__init__(self) self.params = { "mouse_x": 0, "mouse_y": 0, } self.disableMouse() self.cmd_mgr = commandmgr.TheWorldCommandMgr(self) util.hidden_relative_mouse(self) for cmd_str, cmd_fn in self.cmd_mgr.mapping.items(): self.accept(cmd_str, cmd_fn) # environment self.setBackgroundColor(.0, .0, .0, 1) # # ground self.ground_cube = self.loader.loadModel("cuby.gltf") self.ground_cube.setColor(1, 1, 1, 1) ground_cube_size = Vec3(2, 2, .4) self.ground_cube.setScale(ground_cube_size) self.ground = self.render.attachNewNode("ground") grid_size = 5 grid_max = grid_size - 1 dist = 8 grid_coordinates = itertools.product(range(grid_size), range(grid_size)) def normalize(x_y): x, y = x_y return (x - grid_max / 2) * dist, (y - grid_max / 2) * dist for x, y in map(normalize, grid_coordinates): placeholder = self.ground.attachNewNode("placeholder") placeholder.setPos(x, y, -ground_cube_size.z) self.ground_cube.instanceTo(placeholder) # collision ground coll_node = CollisionNode(f"ground_{x}_{y}") coll_node.setFromCollideMask(CollideMask.allOff()) coll_node.setIntoCollideMask(CollideMask.bit(0)) nodepath = placeholder.attachNewNode(coll_node) nodepath.node().addSolid( CollisionBox(Point3(0, 0, 0), ground_cube_size.x, ground_cube_size.y, ground_cube_size.z)) # lighting ambient_light = AmbientLight("ambient_light") ambient_light.setColor((.2, .2, .2, 1)) alight = self.render.attachNewNode(ambient_light) self.render.setLight(alight) # actor self.actor_obj = Actor(self, self.render, "cuby.gltf") self.actor = self.actor_obj.node self.actor.setColor(cube_color) # # collision actor self.cTrav = CollisionTraverser('traverser') self.cTrav.showCollisions(self.actor) self.actor_coll = CollisionNode('actor') self.actor_coll.addSolid(CollisionBox(Point3(0, 0, 0), 1, 1, 1)) self.actor_coll.setFromCollideMask(CollideMask.bit(0)) self.actor_coll.setIntoCollideMask(CollideMask.allOff()) self.actor_coll_np = self.actor.attachNewNode(self.actor_coll) self.pusher = CollisionHandlerPusher() self.pusher.addCollider(self.actor_coll_np, self.actor) self.cTrav.addCollider(self.actor_coll_np, self.pusher) # lighting self.centerlight_np = self.render.attachNewNode("basiclightcenter") self.centerlight_np.hprInterval(4, (360, 0, 0)).loop() d, h = 8, 1 self.basic_point_light((-d, 0, h), (.0, .0, .7, 1), "left_light") self.basic_point_light((d, 0, h), (.0, .7, 0, 1), "right_light") self.basic_point_light((0, d, h), (.7, .0, .0, 1), "front_light") self.basic_point_light((0, -d, h), (1, 1, 1, 1), "back_light") self.actor_stater = Stater(self.actor) self.cmd_mgr.set_actor_stater(self.actor_stater) self.actor_mover = Mover(self, self.actor_obj, self.actor_stater) self.camera.wrtReparentTo(self.actor) self.camera.setPos(Vec3(0, 4, 1).normalized() * cam_dist) self.camera.lookAt(0, 0, 0) self.taskMgr.add(self.update_params, "paramsTask") self.taskMgr.add(self.actor_mover.execute, "moveTask") self.taskMgr.add(self.log, "logTask") self.render.setShaderAuto() def update_params(self, task): if self.mouseWatcherNode.hasMouse(): self.params["mouse_x"] = self.mouseWatcherNode.getMouseX() self.params["mouse_y"] = self.mouseWatcherNode.getMouseY() self.win.movePointer(0, self.win.getProperties().getXSize() // 2, self.win.getProperties().getYSize() // 2) self.params["actor_pos"] = self.actor.getPos() return Task.cont def log(self, task): return Task.cont def basic_point_light(self, position, color, name, attenuation=(1, 0, 0.02)): light = PointLight(name) light.setColor(color) light.setAttenuation(attenuation) # light.setShadowCaster(True) # light.getLens().setNearFar(5, 20) plight = self.centerlight_np.attachNewNode(light) plight.setPos(position) self.render.setLight(plight) light_cube = self.loader.loadModel("cuby.gltf") light_cube.reparentTo(plight) light_cube.setScale(0.25) material = Material() material.setEmission(color) light_cube.setMaterial(material)