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 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 __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 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 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 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 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)
def sphere(self, name, bitmask, pos=(0, 0, 1), radius=0.2): col = CollisionNode(self.node.getName() + "-sphere-" + name) shape = CollisionSphere(pos, radius) col.add_solid(shape) col.set_from_collide_mask(bitmask) col.set_into_collide_mask(CollideMask.allOff()) col_node = self.node.attachNewNode(col) handler = CollisionHandlerPusher() handler.add_collider(col_node, self.node) self.traverser.add_collider(col_node, handler) return { "collider": col, "shape": shape, "handler": handler, "node": col_node }
def postInit(self): # # initialize game content # base.cTrav = CollisionTraverser("base collision traverser") base.pusher = CollisionHandlerPusher() self.menu = Menu() self.credits = Credits() self.charSelection = CharacterSelection() self.levelSelection = LevelSelection() self.koScreen = KoScreen() self.hud = Hud() self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg") self.menuMusic.setLoop(True) self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg") self.fightMusic.setLoop(True) base.audio3d = Audio3DManager(base.sfxManagerList[0], camera) # # Event handling # self.accept("escape", self.__escape) # # Start with the menu # self.request("Menu")
def postInit(self): """Post initialization necessary for running from p3d files""" # # initialize game content base.cTrav = CollisionTraverser("base collision traverser") base.pusher = CollisionHandlerPusher() # #TODO: put game content initialization stuff here self.player = Player(0, 1, "p1") self.player2 = Player(1, 2, "p2") self.player.setEnemy(self.player2.collisionNodeName) self.player2.setEnemy(self.player.collisionNodeName) # # Event handling # self.accept("escape", self.__escape) # # Start with the menu # #TODO: Change this to any state you want the game to start with self.request("Game")
def __init__(self): """initialise the engine""" ShowBase.__init__(self) base.camLens.setNearFar(1.0, 10000) base.camLens.setFov(75) a = 33 base.camera.setPos(0,-a,a+3)#80) # collision base.cTrav = CollisionTraverser("base collision traverser") base.cHandler = CollisionHandlerEvent() base.cPusher = CollisionHandlerPusher() base.cQueue = CollisionHandlerQueue() base.globalClock=ClockObject.getGlobalClock() base.cHandler.addInPattern('%fn-into-%in') base.cHandler.addOutPattern('%fn-out-%in') base.cHandler.addAgainPattern('%fn-again-%in') # ai init base.AIworld = AIWorld(render) # 3d manager base.audio3d = Audio3DManager(base.sfxManagerList[0], camera) self.monsters = [] self.accept('c',self._create) base.enableParticles()
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')
def postInit(self): # # initialize game content # # camera base.camLens.setNearFar(1.0, 10000) base.camLens.setFov(75) a = 33 base.camera.setPos(0, -a, a + 3) #80) # collision base.cTrav = CollisionTraverser("base collision traverser") base.cHandler = CollisionHandlerEvent() base.cPusher = CollisionHandlerPusher() base.cQueue = CollisionHandlerQueue() base.globalClock = ClockObject.getGlobalClock() base.cHandler.addInPattern('%fn-into-%in') base.cHandler.addOutPattern('%fn-out-%in') base.cHandler.addAgainPattern('%fn-again-%in') # ai init base.AIworld = AIWorld(render) # 3d manager base.audio3d = Audio3DManager(base.sfxManagerList[0], camera) # manager self.archiveManager = ArchiveManager() self.mapManager = MapManager() self.initHeroInfo = None # Lock self.lock = threading.Lock() self.gameThread = None self.filters = CommonFilters(base.win, base.cam) # UI self.menu = Menu() self.option = Option() self.archive = Archive() self.death = Death() # self.oobe() #self.Archive_status = 0 # self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg") # self.menuMusic.setLoop(True) # self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg") # self.fightMusic.setLoop(True) # base.audio3d = Audio3DManager(base.sfxManagerList[0], camera) self.titleVideo, self.titleCard = loadVideo('title.mp4') self.isInited = False self.isSkip = False self.isRenew = False # # Event handling # self.accept("escape", self.__escape) # # Start with the menu # self.request("Menu")
def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) self.orbCollisionHandler = CollisionHandlerQueue() self.cTrav = CollisionTraverser() #hbPath = NodePath() utilsKristina.HealthBar() utilsKristina.setUpKeys(self) utilsKristina.loadModels(self) utilsKristina.setUpLighting(self) utilsKristina.setUpFloatingSpheres(self) utilsKristina.setUpRalphsShot(self) utilsKristina.setUpCamera(self) utilsKristina.setUpCollisionSpheres(self) self.healthTxt = utilsKristina.addInstructions(.06,"Health: 100") self.orbTxt = utilsKristina.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) # Uncomment this line to show a visual representation of the # collisions occuring self.cTrav.showCollisions(render) self.chrisLastShotTime = globalClock.getFrameTime() self.chrisTimer = globalClock.getDt()
def __init__(self, showBase): self.showBase = showBase Common.initialise() Common.framework = self showBase.render.setShaderAuto() self.keyMap = { "up" : False, "down" : False, "left" : False, "right" : False, "shoot" : False, "shootSecondary" : False } showBase.accept("w", self.updateKeyMap, ["up", True]) showBase.accept("w-up", self.updateKeyMap, ["up", False]) showBase.accept("s", self.updateKeyMap, ["down", True]) showBase.accept("s-up", self.updateKeyMap, ["down", False]) showBase.accept("mouse1", self.updateKeyMap, ["shoot", True]) showBase.accept("mouse1-up", self.updateKeyMap, ["shoot", False]) showBase.accept("mouse3", self.updateKeyMap, ["shootSecondary", True]) showBase.accept("mouse3-up", self.updateKeyMap, ["shootSecondary", False]) showBase.accept("\\", self.toggleFriction) self.pusher = CollisionHandlerPusher() self.traverser = CollisionTraverser() self.traverser.setRespectPrevTransform(True) self.pusher.add_in_pattern("%fn-into-%in") self.pusher.add_in_pattern("%fn-into") self.pusher.add_again_pattern("%fn-again-into") showBase.accept("projectile-into", self.projectileImpact) showBase.accept("projectile-again-into", self.projectileImpact) showBase.accept("player-into", self.gameObjectPhysicalImpact) showBase.accept("enemy-into", self.gameObjectPhysicalImpact) self.updateTask = showBase.taskMgr.add(self.update, "update") self.player = None self.currentLevel = None
def __init__(self): base.cTrav = CollisionTraverser() base.pusher = CollisionHandlerPusher() ConfigRender.__init__(self) self.elapsedSeconds = 0 self.mapData = MapsModel() self.gameData = GameModel('./saves/') self.load_fonts() # this needs to be called only when game starts taskMgr.add(self.updateTime, 'updateTime')
def __init__(self): ShowBase.__init__(self) properties = WindowProperties() properties.setSize(SCREEN_WIDTH, SCREEN_HEIGHT) self.win.requestProperties(properties) self.disableMouse() self.cTrav = CollisionTraverser() self.pusher = CollisionHandlerPusher() self.pusher.setHorizontal(True) self.scene = Scene(self.render, self.loader, self, 5) self.player = Player("models/panda", {"walk": "models/panda-walk"}, 2, 15, "player", self, Vec3(0, 0, 0), Vec3(180, 0, 0)) self.camera_init() self.control_service() self.updateTask = taskMgr.add(self.update, "update") self.mouse_check_value = 0.7 self.pusher.add_in_pattern("%fn-into-%in")
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)
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 __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 __init__(self): ShowBase.__init__(self) self.keyMap = { "up": False, "down": False, "left": False, "right": False, "shoot": False } self.base = base self.boule_time = 0 base.setFrameRateMeter(True) # mesure le FPS # Création du plateau de jeu self.environment = loader.loadModel("./Environment/environment") self.environment.reparentTo(render) # Positionnement de la caméra self.Cam_init() # Réglages des éclairages self.ambientLight = AmbientLight("ambient light") self.Init_eclairage() # Gestions des collisions avec les autres objets (MUR pour l'instant) self.pusher = CollisionHandlerPusher() # Pour la gestion de l'arbre de collisions base.cTrav = CollisionTraverser() # gestion des déplacements self.Init_mvt() # création du heros selon le modele ./fox/Fox self.heros = Heros(self, Vec3(0, 0, 0), "./fox/Fox", { "stand": "./fox/Fox-Idle_fp", "walk": "./fox/Fox-Walk_fp" }, 5, 10, "HEROS", 2) self.heros.actor.reparentTo(render) # création des objets de décors self.tour1 = obj_inactifs(Vec3(12, 9, 1), "tour/tour", 0, "T1", 1) self.tour1.obj.reparentTo(render) self.tour2 = obj_inactifs(Vec3(-12, 9, 1), "tour/tour", 0, "T2", 1) self.tour2.obj.reparentTo(render) self.sorcier = obj_inactifs(Vec3(12, 9, 6), "sorcier/wizard", 130, "SORCIER", 0.45) self.sorcier.obj.reparentTo(render) #init des armes self.boule = Boule_feu(self) # initialisation des déplacements self.Init_mvt() # initialisation des zones de collisions du decor self.Init_coll() # activation des évènements self.updateTask = taskMgr.add(self.update, "update")
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)
def loadMainCharacter(self, mainCharModel): # loads the main character object with specified model self.tempActor = Actor( mainCharModel, { "walk": "MorgansModels/shape-boi-grab-test-point_level2-ArmatureAction", "lift": "MorgansModels/shape-boi-grab-test-point_level2-IcosphereAction" }) self.tempActor.reparentTo(render) self.tempActor.setH(0) self.tempActor.setPos(0, 54, -3) self.tempActor.setScale(0.5, 0.5, 0.5) self.tempActor.loop("walk") #player 1 self.cTrav = CollisionTraverser() self.pusher = CollisionHandlerPusher() colliderNode = CollisionNode("player") colliderNode.addSolid(CollisionSphere(0, 0, 1, 1.7)) collider = self.tempActor.attachNewNode(colliderNode) #collider.show() base.pusher.addCollider(collider, self.tempActor) base.cTrav.addCollider(collider, self.pusher) self.pusher.setHorizontal(True)
def test_collision_handler_pusher_pickle(): from panda3d.core import CollisionHandlerPusher collider1 = NodePath(CollisionNode("collider1")) collider2 = NodePath(CollisionNode("collider2")) target1 = NodePath("target1") target2 = NodePath("target2") handler = CollisionHandlerPusher() handler.add_again_pattern("again pattern") handler.add_collider(collider1, target1) handler.add_collider(collider2, target2) handler.horizontal = True handler = loads(dumps(handler, -1)) assert tuple(handler.in_patterns) == () assert tuple(handler.again_patterns) == ("again pattern", ) assert tuple(handler.out_patterns) == () assert not handler.has_center() assert handler.horizontal
def __init__(self): # self.load_assets() base.cTrav = CollisionTraverser() base.pusher = CollisionHandlerPusher() base.groundHandler = CollisionHandlerQueue() self.AIworld = AIWorld(render) ConfigRender.__init__(self) self.elapsedSeconds = 0 self.sound = ConfigSound() self.rpgField = RPGField() self.enemyData = EnemyModel() self.itemData = ItemModel() self.magicData = MagicModel() self.cutsceneManager = CutsceneManager() # print(PandaSystem.getVersionString()) self.load_fonts() # this needs to be called only when game starts taskMgr.add(self.updateTime, 'updateTime')
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 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
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))
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 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
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")
def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) #hbPath = NodePath() utils.setUpKeys(self) utils.loadModels(self) utils.setUpLighting(self) utils.setUpFloatingSpheres(self) utils.setUpRalphsShot(self) utils.setUpCamera(self) utils.addInstructions(.06,"Health: 100") self.orbTxt = utils.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.shotList = [] taskMgr.add(self.move, "moveTask") self.cTrav = CollisionTraverser() self.wallHandler = CollisionHandlerPusher() 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.ySphereCollisionHandler = CollisionHandlerQueue() #self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler) self.cTrav.addCollider(self.cnodePath, self.pusher) ct = CollisionSphere(0,0,0,1) cn = self.pawn.attachNewNode(CollisionNode('pawnCollisionNode')) cn.node().addSolid(ct) #cn.show() 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(0,3,0,5) chco = self.chris.attachNewNode(CollisionNode('catidolCollisionNode')) chco.node().addSolid(chi) #chco.show() donut= CollisionSphere(0,3,0,5) donutx = self.donut.attachNewNode(CollisionNode('donutCollisionNode')) donutx.node().addSolid(donut) #chco.show() cs2 = CollisionSphere(0,0,0,.2) cs2path = self.plnp.attachNewNode((CollisionNode('ySphereColPath'))) cs2path.node().addSolid(cs2) cs2path.show() self.cTrav.addCollider(cs2path, self.ySphereCollisionHandler) cs3 = CollisionSphere(0,0,0,1) cs3path = self.plnp2.attachNewNode((CollisionNode('bSphereColPath'))) cs3path.node().addSolid(cs2) cs3path.show() self.cTrav.addCollider(cs3path, self.ySphereCollisionHandler) # Uncomment this line to show a visual representation of the # collisions occuring self.cTrav.showCollisions(render)
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")
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)
def __init__(self): self.bspLoader = Py_CL_BSPLoader() self.bspLoader.setGlobalPtr(self.bspLoader) if metadata.USE_RENDER_PIPELINE: from rpcore import RenderPipeline self.pipeline = RenderPipeline() self.pipeline.create(self) else: ShowBase.__init__(self) self.loader.destroy() self.loader = CogInvasionLoader(self) __builtin__.loader = self.loader self.graphicsEngine.setDefaultLoader(self.loader.loader) self.cam.node().getDisplayRegion(0).setClearDepthActive(1) from panda3d.core import RenderAttribRegistry from panda3d.core import ShaderAttrib, TransparencyAttrib from libpandabsp import BSPMaterialAttrib attribRegistry = RenderAttribRegistry.getGlobalPtr() attribRegistry.setSlotSort(BSPMaterialAttrib.getClassSlot(), 0) attribRegistry.setSlotSort(ShaderAttrib.getClassSlot(), 1) attribRegistry.setSlotSort(TransparencyAttrib.getClassSlot(), 2) gsg = self.win.getGsg() # Let's print out the Graphics information. self.notify.info( 'Graphics Information:\n\tVendor: {0}\n\tRenderer: {1}\n\tVersion: {2}\n\tSupports Cube Maps: {3}\n\tSupports 3D Textures: {4}\n\tSupports Compute Shaders: {5}' .format(gsg.getDriverVendor(), gsg.getDriverRenderer(), gsg.getDriverVersion(), str(gsg.getSupportsCubeMap()), str(gsg.getSupports3dTexture()), str(gsg.getSupportsComputeShaders()))) # Enable shader generation on all of the main scenes if gsg.getSupportsBasicShaders() and gsg.getSupportsGlsl(): render.setShaderAuto() render2d.setShaderAuto() render2dp.setShaderAuto() else: # I don't know how this could be possible self.notify.error("GLSL shaders unsupported by graphics driver.") return # Let's disable fog on Intel graphics if gsg.getDriverVendor() == "Intel": metadata.NO_FOG = 1 self.notify.info('Applied Intel-specific graphical fix.') self.win.disableClears() self.camNode.setCameraMask(CIGlobals.MainCameraBitmask) from direct.distributed.ClockDelta import globalClockDelta __builtin__.globalClockDelta = globalClockDelta # Any ComputeNodes should be parented to this node, not render. # We isolate ComputeNodes to avoid traversing the same ComputeNodes # when doing multi-pass rendering. self.computeRoot = NodePath('computeRoot') self.computeCam = self.makeCamera(base.win) self.computeCam.node().setCullBounds(OmniBoundingVolume()) self.computeCam.node().setFinal(True) self.computeCam.reparentTo(self.computeRoot) # Initialized in initStuff() self.shaderGenerator = None render.hide() self.camLens.setNearFar(0.5, 10000) self.physicsWorld = BulletWorld() # Panda units are in feet, so the gravity is 32 feet per second, # not 9.8 meters per second. self.physicsWorld.setGravity(Vec3(0, 0, -32.1740)) self.physicsWorld.setGroupCollisionFlag(7, 1, True) self.physicsWorld.setGroupCollisionFlag(7, 2, True) self.physicsWorld.setGroupCollisionFlag(7, 3, False) self.physicsWorld.setGroupCollisionFlag(7, 4, False) self.physicsWorld.setGroupCollisionFlag(7, 8, True) self.taskMgr.add(self.__physicsUpdate, "physicsUpdate", sort=30) debugNode = BulletDebugNode('Debug') self.debugNP = render.attachNewNode(debugNode) self.physicsWorld.setDebugNode(self.debugNP.node()) self.physicsDbgFlag = False self.setPhysicsDebug(self.config.GetBool('physics-debug', False)) #self.shadowCaster = ShadowCaster(Vec3(163, -67, 0)) #self.shadowCaster.enable() self.bspLoader.setGamma(2.2) self.bspLoader.setWin(self.win) self.bspLoader.setCamera(self.camera) self.bspLoader.setRender(self.render) self.bspLoader.setMaterialsFile("phase_14/etc/materials.txt") #self.bspLoader.setTextureContentsFile("phase_14/etc/texturecontents.txt") self.bspLoader.setWantVisibility(True) self.bspLoader.setVisualizeLeafs(False) self.bspLoader.setWantLightmaps(True) #self.bspLoader.setShadowCamPos(Point3(-15, 5, 40)) #self.bspLoader.setShadowResolution(60 * 2, 1024 * 1) self.bspLoader.setPhysicsWorld(self.physicsWorld) self.bspLevel = None self.materialData = {} self.skyBox = None self.skyBoxUtil = None #self.nmMgr = RNNavMeshManager.get_global_ptr() #self.nmMgr.set_root_node_path(self.render) #self.nmMgr.get_reference_node_path().reparentTo(self.render) #self.nmMgr.start_default_update() #self.nmMgr.get_reference_node_path_debug().reparentTo(self.render) self.navMeshNp = None # Setup 3d audio run before igLoop so 3d positioning doesn't lag behind base.audio3d = Audio3DManager(base.sfxManagerList[0], camera, render) base.audio3d.setDropOffFactor(0.15) base.audio3d.setDopplerFactor(0.15) # Setup collision handlers base.cTrav = CollisionTraverser() base.lifter = CollisionHandlerFloor() base.pusher = CollisionHandlerPusher() base.queue = CollisionHandlerQueue() base.lightingCfg = None self.cl_attackMgr = None #self.accept('/', self.projectShadows) # Let's setup the user input storage system uis = UserInputStorage() self.inputStore = uis self.userInputStorage = uis __builtin__.inputStore = uis __builtin__.userInputStorage = uis self.credits2d = self.render2d.attachNewNode(PGTop("credits2d")) self.credits2d.setScale(1.0 / self.getAspectRatio(), 1.0, 1.0) self.wakeWaterHeight = -30.0 self.bloomToggle = False self.hdrToggle = False self.fxaaToggle = CIGlobals.getSettingsMgr().getSetting( "aa").getValue() == "FXAA" self.aoToggle = False self.music = None self.currSongName = None render.show(CIGlobals.ShadowCameraBitmask) self.avatars = [] wrm = WaterReflectionManager() self.waterReflectionMgr = wrm __builtin__.waterReflectionMgr = wrm # Let's setup our margins base.marginManager = MarginManager() base.margins = aspect2d.attachNewNode( base.marginManager, DirectGuiGlobals.MIDGROUND_SORT_INDEX + 1) base.leftCells = [ base.marginManager.addCell(0.1, -0.6, base.a2dTopLeft), base.marginManager.addCell(0.1, -1.0, base.a2dTopLeft), base.marginManager.addCell(0.1, -1.4, base.a2dTopLeft) ] base.bottomCells = [ base.marginManager.addCell(0.4, 0.1, base.a2dBottomCenter), base.marginManager.addCell(-0.4, 0.1, base.a2dBottomCenter), base.marginManager.addCell(-1.0, 0.1, base.a2dBottomCenter), base.marginManager.addCell(1.0, 0.1, base.a2dBottomCenter) ] base.rightCells = [ base.marginManager.addCell(-0.1, -0.6, base.a2dTopRight), base.marginManager.addCell(-0.1, -1.0, base.a2dTopRight), base.marginManager.addCell(-0.1, -1.4, base.a2dTopRight) ] base.mouseWatcherNode.setEnterPattern('mouse-enter-%r') base.mouseWatcherNode.setLeavePattern('mouse-leave-%r') base.mouseWatcherNode.setButtonDownPattern('button-down-%r') base.mouseWatcherNode.setButtonUpPattern('button-up-%r') cbm = CullBinManager.getGlobalPtr() cbm.addBin('ground', CullBinManager.BTUnsorted, 18) # The portal uses the shadow bin by default, # but we still want to see it with real shadows. cbm.addBin('portal', CullBinManager.BTBackToFront, 19) if not metadata.USE_REAL_SHADOWS: cbm.addBin('shadow', CullBinManager.BTBackToFront, 19) else: cbm.addBin('shadow', CullBinManager.BTFixed, -100) cbm.addBin('gui-popup', CullBinManager.BTUnsorted, 60) cbm.addBin('gsg-popup', CullBinManager.BTFixed, 70) self.setBackgroundColor(CIGlobals.DefaultBackgroundColor) self.disableMouse() self.enableParticles() base.camLens.setNearFar(CIGlobals.DefaultCameraNear, CIGlobals.DefaultCameraFar) base.transitions = CITransitions(loader) base.transitions.IrisModelName = "phase_3/models/misc/iris.bam" base.transitions.FadeModelName = "phase_3/models/misc/fade.bam" self.accept(self.inputStore.TakeScreenshot, ScreenshotHandler.takeScreenshot) #self.accept('u', render.setShaderOff) #self.accept('i', render.setShaderOff, [1]) #self.accept('o', render.setShaderOff, [2]) # Disabled oobe culling #self.accept('o', self.oobeCull) #self.accept('c', self.reportCam) self.taskMgr.add(self.__updateShadersAndPostProcess, 'CIBase.updateShadersAndPostProcess', 47) self.taskMgr.add(self.__update3DAudio, 'CIBase.update3DAudio', 59)
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")
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
def startGame(self): # remove menu main elements if hasattr(game, "startBtn"): self.startBtn.destroy() if hasattr(game, "gameNameText"): self.gameNameText.destroy() if hasattr(game, "controlsText"): self.controlsText.destroy() if self.startAudio.status() == self.startAudio.PLAYING: self.startAudio.stop() self.gameAudio.play() # HUD information (time, health) self.time_text = addInstruction((-1.2, 0.9), "Time Reamining :: %i" % TIME) self.health_text = addInstruction((0.9, 0.9), "Health :: %i" % HEALTH) # the environment self.env = loader.loadModel("../assets/models/world") self.env.reparentTo(render) self.env.setPos(0, 0, 0) # the flag(destination) self.flag = loader.loadModel("../assets/models/flag/flag") self.flag.reparentTo(render) self.flag.setScale(0.1) self.flag.setPos(0, 0, 5) self.DESTINATION = self.flag.getPos() # main character(sonic) self.START = self.env.find("**/start_point").getPos() self.sonic = Actor( "../assets/models/sonic/sonic", { "run": "../assets/models/sonic/sonic-run", "win": "../assets/models/sonic/sonic-win", "board": "../assets/models/sonic/sonic-board", "fwboard": "../assets/models/sonic/sonic-fallingwboard", "fwoboard": "../assets/models/sonic/sonic-fallingwoboard", }, ) self.sonic.reparentTo(render) self.sonic.setScale(0.05) self.sonic.setPos(self.START) # create a floater object to be used as a temporary # variable in a variety of calculations self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) taskMgr.add(self.move, "moveTask") # varible to keep track of moving state self.isMoving = False # variable to keep track of speed boost self.speedBoost = False # variable to keep track of invulnerability self.invul = False # setup the camera base.disableMouse() base.camera.setPos(self.sonic.getX(), self.sonic.getY() + 10, 2) self.cTrav = CollisionTraverser() # self.pusher = CollisionHandlerPusher() self.sonicGroundRay = CollisionRay() self.sonicGroundRay.setOrigin(0, 0, 1000) self.sonicGroundRay.setDirection(0, 0, -1) self.sonicGroundCol = CollisionNode("sonicRay") self.sonicGroundCol.addSolid(self.sonicGroundRay) # self.sonicGroundCol.addSolid(CollisionSphere(0, 0, 1.5, 1.5)) self.sonicGroundCol.setFromCollideMask(BitMask32.bit(0)) self.sonicGroundCol.setIntoCollideMask(BitMask32.allOff()) self.sonicGroundColNp = self.sonic.attachNewNode(self.sonicGroundCol) self.sonicGroundHandler = CollisionHandlerQueue() self.sonicPusher = CollisionHandlerPusher() self.sonicPusher.addInPattern("%fn-into-%in") self.cTrav.addCollider(self.sonicGroundColNp, self.sonicGroundHandler) # self.cTrav.addCollider(self.sonicGroundColNp, self.sonicPusher) # self.sonicPusher.addCollider(self.sonicGroundColNp, self.sonic) self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0, 0, 1000) self.camGroundRay.setDirection(0, 0, -1) self.camGroundCol = CollisionNode("camRay") self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(BitMask32.bit(0)) self.camGroundCol.setIntoCollideMask(BitMask32.allOff()) self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # see the collision rays # self.sonicGroundColNp.show() # self.camGroundColNp.show() # visual representation of the collisions occuring # self.cTrav.showCollisions(render) # create AI characters self.createTrexAI() self.createMilesAI() # place the presents self.createPresents() # check winning condition taskMgr.add(self.checkWin, "checkWin") # check time conditions taskMgr.add(self.checkTime, "checkTime") # check health conditions taskMgr.add(self.checkGameOver, "checkGameOver") # check other conditions taskMgr.add(self.checkConditions, "checkConditions") taskMgr.add(self.checkSpeed, "checkSpeed") taskMgr.add(self.checkSpeed2, "checkSpeed2") taskMgr.add(self.checkHealthBoost, "checkHealthBoost") taskMgr.add(self.checkTimeAdd, "checkTimeAdd")
class Game(ShowBase): def __init__(self): ShowBase.__init__(self) self.disableMouse() properties = WindowProperties() properties.setSize(1000, 750) self.win.requestProperties(properties) self.exitFunc = self.cleanup mainLight = DirectionalLight("main light") self.mainLightNodePath = render.attachNewNode(mainLight) self.mainLightNodePath.setHpr(45, -45, 0) render.setLight(self.mainLightNodePath) ambientLight = AmbientLight("ambient light") ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) self.ambientLightNodePath = render.attachNewNode(ambientLight) render.setLight(self.ambientLightNodePath) render.setShaderAuto() self.environment = loader.loadModel("Models/Misc/environment") self.environment.reparentTo(render) self.camera.setPos(0, 0, 32) self.camera.setP(-90) self.keyMap = { "up" : False, "down" : False, "left" : False, "right" : False, "shoot" : False } 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]) self.pusher = CollisionHandlerPusher() self.cTrav = CollisionTraverser() self.pusher.setHorizontal(True) self.pusher.add_in_pattern("%fn-into-%in") self.accept("trapEnemy-into-wall", self.stopTrap) self.accept("trapEnemy-into-trapEnemy", self.stopTrap) self.accept("trapEnemy-into-player", self.trapHitsSomething) self.accept("trapEnemy-into-walkingEnemy", self.trapHitsSomething) 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) self.updateTask = taskMgr.add(self.update, "update") self.player = None self.enemies = [] self.trapEnemies = [] self.deadEnemies = [] self.spawnPoints = [] numPointsPerWall = 5 for i in range(numPointsPerWall): coord = 7.0/numPointsPerWall + 0.5 self.spawnPoints.append(Vec3(-7.0, coord, 0)) self.spawnPoints.append(Vec3(7.0, coord, 0)) self.spawnPoints.append(Vec3(coord, -7.0, 0)) self.spawnPoints.append(Vec3(coord, 7.0, 0)) self.initialSpawnInterval = 1.0 self.minimumSpawnInterval = 0.2 self.spawnInterval = self.initialSpawnInterval self.spawnTimer = self.spawnInterval self.maxEnemies = 2 self.maximumMaxEnemies = 20 self.numTrapsPerSide = 2 self.difficultyInterval = 5.0 self.difficultyTimer = self.difficultyInterval self.enemySpawnSound = loader.loadSfx("Sounds/enemySpawn.ogg") self.gameOverScreen = DirectDialog(frameSize = (-0.7, 0.7, -0.7, 0.7), fadeScreen = 0.4, relief = DGG.FLAT, frameTexture = "UI/stoneFrame.png") self.gameOverScreen.hide() self.font = loader.loadFont("Fonts/Wbxkomik.ttf") buttonImages = ( loader.loadTexture("UI/UIButton.png"), loader.loadTexture("UI/UIButtonPressed.png"), loader.loadTexture("UI/UIButtonHighlighted.png"), loader.loadTexture("UI/UIButtonDisabled.png") ) label = DirectLabel(text = "Game Over!", parent = self.gameOverScreen, scale = 0.1, pos = (0, 0, 0.2), text_font = self.font, relief = None) self.finalScoreLabel = DirectLabel(text = "", parent = self.gameOverScreen, scale = 0.07, pos = (0, 0, 0), text_font = self.font, relief = None) btn = DirectButton(text = "Restart", command = self.startGame, pos = (-0.3, 0, -0.2), parent = self.gameOverScreen, scale = 0.07, text_font = self.font, clickSound = loader.loadSfx("Sounds/UIClick.ogg"), frameTexture = buttonImages, frameSize = (-4, 4, -1, 1), text_scale = 0.75, relief = DGG.FLAT, text_pos = (0, -0.2)) btn.setTransparency(True) btn = DirectButton(text = "Quit", command = self.quit, pos = (0.3, 0, -0.2), parent = self.gameOverScreen, scale = 0.07, text_font = self.font, clickSound = loader.loadSfx("Sounds/UIClick.ogg"), frameTexture = buttonImages, frameSize = (-4, 4, -1, 1), text_scale = 0.75, relief = DGG.FLAT, text_pos = (0, -0.2)) btn.setTransparency(True) self.titleMenuBackdrop = DirectFrame(frameColor = (0, 0, 0, 1), frameSize = (-1, 1, -1, 1), parent = render2d) self.titleMenu = DirectFrame(frameColor = (1, 1, 1, 0)) title = DirectLabel(text = "Panda-chan", scale = 0.1, pos = (0, 0, 0.9), parent = self.titleMenu, relief = None, text_font = self.font, text_fg = (1, 1, 1, 1)) title2 = DirectLabel(text = "and the", scale = 0.07, pos = (0, 0, 0.79), parent = self.titleMenu, text_font = self.font, frameColor = (0.5, 0.5, 0.5, 1)) title3 = DirectLabel(text = "Endless Horde", scale = 0.125, pos = (0, 0, 0.65), parent = self.titleMenu, relief = None, text_font = self.font, text_fg = (1, 1, 1, 1)) btn = DirectButton(text = "Start Game", command = self.startGame, pos = (0, 0, 0.2), parent = self.titleMenu, scale = 0.1, text_font = self.font, clickSound = loader.loadSfx("Sounds/UIClick.ogg"), frameTexture = buttonImages, frameSize = (-4, 4, -1, 1), text_scale = 0.75, relief = DGG.FLAT, text_pos = (0, -0.2)) btn.setTransparency(True) btn = DirectButton(text = "Quit", command = self.quit, pos = (0, 0, -0.2), parent = self.titleMenu, scale = 0.1, text_font = self.font, clickSound = loader.loadSfx("Sounds/UIClick.ogg"), frameTexture = buttonImages, frameSize = (-4, 4, -1, 1), text_scale = 0.75, relief = DGG.FLAT, text_pos = (0, -0.2)) btn.setTransparency(True) music = loader.loadMusic("Music/Defending-the-Princess-Haunted.ogg") music.setLoop(True) music.setVolume(0.075) music.play() def startGame(self): self.titleMenu.hide() self.titleMenuBackdrop.hide() self.gameOverScreen.hide() self.cleanup() self.player = Player() self.maxEnemies = 2 self.spawnInterval = self.initialSpawnInterval self.difficultyTimer = self.difficultyInterval sideTrapSlots = [ [], [], [], [] ] trapSlotDistance = 0.4 slotPos = -8 + trapSlotDistance while slotPos < 8: if abs(slotPos) > 1.0: sideTrapSlots[0].append(slotPos) sideTrapSlots[1].append(slotPos) sideTrapSlots[2].append(slotPos) sideTrapSlots[3].append(slotPos) slotPos += trapSlotDistance for i in range(self.numTrapsPerSide): slot = sideTrapSlots[0].pop(random.randint(0, len(sideTrapSlots[0])-1)) trap = TrapEnemy(Vec3(slot, 7.0, 0)) self.trapEnemies.append(trap) slot = sideTrapSlots[1].pop(random.randint(0, len(sideTrapSlots[1])-1)) trap = TrapEnemy(Vec3(slot, -7.0, 0)) self.trapEnemies.append(trap) slot = sideTrapSlots[2].pop(random.randint(0, len(sideTrapSlots[2])-1)) trap = TrapEnemy(Vec3(7.0, slot, 0)) trap.moveInX = True self.trapEnemies.append(trap) slot = sideTrapSlots[3].pop(random.randint(0, len(sideTrapSlots[3])-1)) trap = TrapEnemy(Vec3(-7.0, slot, 0)) trap.moveInX = True self.trapEnemies.append(trap) def updateKeyMap(self, controlName, controlState): self.keyMap[controlName] = controlState def spawnEnemy(self): if len(self.enemies) < self.maxEnemies: spawnPoint = random.choice(self.spawnPoints) newEnemy = WalkingEnemy(spawnPoint) self.enemies.append(newEnemy) self.enemySpawnSound.play() def stopTrap(self, entry): collider = entry.getFromNodePath() if collider.hasPythonTag("owner"): trap = collider.getPythonTag("owner") trap.moveDirection = 0 trap.ignorePlayer = False trap.movementSound.stop() trap.stopSound.play() def trapHitsSomething(self, entry): collider = entry.getFromNodePath() if collider.hasPythonTag("owner"): trap = collider.getPythonTag("owner") if trap.moveDirection == 0: return collider = entry.getIntoNodePath() if collider.hasPythonTag("owner"): obj = collider.getPythonTag("owner") if isinstance(obj, Player): if not trap.ignorePlayer: obj.alterHealth(-1) trap.ignorePlayer = True else: obj.alterHealth(-10) trap.impactSound.play() def update(self, task): dt = globalClock.getDt() if self.player is not None: if self.player.health > 0: self.player.update(self.keyMap, dt) self.spawnTimer -= dt if self.spawnTimer <= 0: self.spawnTimer = self.spawnInterval self.spawnEnemy() [enemy.update(self.player, dt) for enemy in self.enemies] [trap.update(self.player, dt) for trap in self.trapEnemies] newlyDeadEnemies = [enemy for enemy in self.enemies if enemy.health <= 0] self.enemies = [enemy for enemy in self.enemies if enemy.health > 0] for enemy in newlyDeadEnemies: enemy.collider.removeNode() enemy.actor.play("die") self.player.score += enemy.scoreValue if len(newlyDeadEnemies) > 0: self.player.updateScore() self.deadEnemies += newlyDeadEnemies enemiesAnimatingDeaths = [] for enemy in self.deadEnemies: deathAnimControl = enemy.actor.getAnimControl("die") if deathAnimControl is None or not deathAnimControl.isPlaying(): enemy.cleanup() else: enemiesAnimatingDeaths.append(enemy) self.deadEnemies = enemiesAnimatingDeaths self.difficultyTimer -= dt if self.difficultyTimer <= 0: self.difficultyTimer = self.difficultyInterval if self.maxEnemies < self.maximumMaxEnemies: self.maxEnemies += 1 if self.spawnInterval > self.minimumSpawnInterval: self.spawnInterval -= 0.1 else: if self.gameOverScreen.isHidden(): self.gameOverScreen.show() self.finalScoreLabel["text"] = "Final score: " + str(self.player.score) self.finalScoreLabel.setText() return task.cont def cleanup(self): for enemy in self.enemies: enemy.cleanup() self.enemies = [] for enemy in self.deadEnemies: enemy.cleanup() self.deadEnemies = [] for trap in self.trapEnemies: trap.cleanup() self.trapEnemies = [] if self.player is not None: self.player.cleanup() self.player = None def quit(self): self.cleanup() base.userExit()
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 Game(DirectObject): def __init__(self): self.setAI() self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0} base.win.setClearColor(Vec4(0, 0, 0, 1)) # the menu self.loadAudio() self.showMenu() # keyboard and mouse events self.accept("escape", sys.exit) self.accept("w", self.setKey, ["forward", 1]) self.accept("a", self.setKey, ["left", 1]) self.accept("s", self.setKey, ["backward", 1]) self.accept("d", self.setKey, ["right", 1]) self.accept("w-up", self.setKey, ["forward", 0]) self.accept("a-up", self.setKey, ["left", 0]) self.accept("s-up", self.setKey, ["backward", 0]) self.accept("d-up", self.setKey, ["right", 0]) self.accept("arrow_left", self.setKey, ["cam-left", 1]) self.accept("arrow_left-up", self.setKey, ["cam-left", 0]) self.accept("arrow_right", self.setKey, ["cam-right", 1]) self.accept("arrow_right-up", self.setKey, ["cam-right", 0]) # create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(0.3, 0.3, 0.3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(-5, -5, -5)) directionalLight.setColor(Vec4(1, 1, 1, 1)) directionalLight.setSpecularColor(Vec4(1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight)) def loadAudio(self): self.startAudio = base.loader.loadSfx("../assets/audio/start.mp3") self.gameAudio = base.loader.loadSfx("../assets/audio/game.mp3") self.winAudio = base.loader.loadSfx("../assets/audio/win.mp3") self.loseAudio = base.loader.loadSfx("../assets/audio/lose.mp3") def createPresents(self): self.speedPill = loader.loadModel("../assets/models/capsule/capsule") self.speedPill.reparentTo(render) self.speedPill.setScale(0.025) self.speedPill.setPos(-43.9744, 32.031, 0.6) self.speedPillb = loader.loadModel("../assets/models/capsule/capsule") self.speedPillb.reparentTo(render) self.speedPillb.setScale(0.025) self.speedPillb.setPos(-57.7858, -61.5068, 3.80818) self.banana = loader.loadModel("../assets/models/banana/banana") self.banana.reparentTo(render) self.banana.setScale(3) self.banana.setPos(-72.484, -7.14435, 5.05246) self.sphinx = loader.loadModel("../assets/models/sphinx/sphinx") self.sphinx.reparentTo(render) self.sphinx.setScale(0.0025) self.sphinx.setPos(-48.0702, -39.4669, 0.5) def createMilesAI(self): startPos = self.env.find("**/start_point").getPos() # load miles actor self.miles1 = Actor( "../assets/models/miles/tails", { "board": "../assets/models/miles/tails-board", "win": "../assets/models/miles/tails-win", "fwboard": "../assets/models/miles/tails-fallingwboard", "fwoboard": "../assets/models/miles/tails-fallingwoboard", }, ) self.miles2 = Actor( "../assets/models/miles/tails", { "board": "../assets/models/miles/tails-board", "win": "../assets/models/miles/tails-win", "fwboard": "../assets/models/miles/tails-fallingwboard", "fwoboard": "../assets/models/miles/tails-fallingwoboard", }, ) self.miles = [self.miles1, self.miles2] self.miles1.reparentTo(render) self.miles1.setScale(0.05) self.miles1.setPlayRate(3, "run") self.miles1.loop("board") self.miles1.setPos(startPos[0] + 5, startPos[1] - 20, startPos[2]) self.miles1GroundRay = CollisionRay() self.miles1GroundRay.setOrigin(0, 0, 1000) self.miles1GroundRay.setDirection(0, 0, -1) self.miles1GroundCol = CollisionNode("miles1Ray") self.miles1GroundCol.addSolid(self.miles1GroundRay) self.miles1GroundCol.setFromCollideMask(BitMask32.bit(0)) self.miles1GroundCol.setIntoCollideMask(BitMask32.allOff()) self.miles1GroundColNp = self.miles1.attachNewNode(self.miles1GroundCol) self.miles1GroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.miles1GroundColNp, self.miles1GroundHandler) # AI code for miles1 self.miles1AI = AICharacter("miles1", self.miles1, 100, 1, 7) self.AIworld.addAiChar(self.miles1AI) self.miles1AIbehaviors = self.miles1AI.getAiBehaviors() # pursue behavior self.miles1AIbehaviors.pursue(self.sonic) taskMgr.add(self.moveMiles1AI, "moveMiles1AI") self.miles2.reparentTo(render) self.miles2.setScale(0.05) self.miles2.setPlayRate(3, "run") self.miles2.loop("win") self.miles2.setPos(startPos[0] - 5, startPos[1] - 20, startPos[2]) self.miles2GroundRay = CollisionRay() self.miles2GroundRay.setOrigin(0, 0, 1000) self.miles2GroundRay.setDirection(0, 0, -1) self.miles2GroundCol = CollisionNode("miles2Ray") self.miles2GroundCol.addSolid(self.miles2GroundRay) self.miles2GroundCol.setFromCollideMask(BitMask32.bit(0)) self.miles2GroundCol.setIntoCollideMask(BitMask32.allOff()) self.miles2GroundColNp = self.miles2.attachNewNode(self.miles2GroundCol) self.miles2GroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.miles2GroundColNp, self.miles2GroundHandler) self.miles2AI = AICharacter("miles2", self.miles2, 100, 1, 7) self.AIworld.addAiChar(self.miles2AI) self.miles2AIbehaviors = self.miles2AI.getAiBehaviors() # puruse behavior self.miles2AIbehaviors.pursue(self.sonic) taskMgr.add(self.moveMiles2AI, "moveMiles2AI") def createTrexAI(self): startPos = self.env.find("**/start_point").getPos() # Load the trex actor and loop its animation self.trex = Actor( "../assets/models/trex/trex", {"run": "../assets/models/trex/trex-run", "eat": "../assets/models/trex/trex-eat"}, ) self.trex.reparentTo(render) self.trex.setScale(0.25) self.trex.setPlayRate(3, "run") self.trex.loop("run") self.trex.setPos(startPos[0], startPos[-1] - 20, startPos[2]) self.trexGroundRay = CollisionRay() self.trexGroundRay.setOrigin(0, 0, 1000) self.trexGroundRay.setDirection(0, 0, -1) self.trexGroundCol = CollisionNode("trexRay") self.trexGroundCol.addSolid(self.trexGroundRay) self.trexGroundCol.setFromCollideMask(BitMask32.bit(0)) self.trexGroundCol.setIntoCollideMask(BitMask32.allOff()) self.trexGroundColNp = self.trex.attachNewNode(self.trexGroundCol) self.trexGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.trexGroundColNp, self.trexGroundHandler) # self.pusher.addCollider(self.trexGroundColNp, self.sonic) # AI code for trex self.trexAI = AICharacter("trex", self.trex, 100, 1, 7) self.AIworld.addAiChar(self.trexAI) self.trexAIbehaviors = self.trexAI.getAiBehaviors() # pursue behavior # self.trexAIbehaviors.pursue(self.sonic) self.trexAIbehaviors.pursue(self.sonic) taskMgr.add(self.moveTrexAI, "moveTrexAI") # to create the AI world def setAI(self): self.AIworld = AIWorld(render) taskMgr.add(self.AIUpdate, "AIUpdate") def AIUpdate(self, task): self.AIworld.update() return task.cont def moveMiles1AI(self, task): startpos = self.miles1.getPos() entries = [] for i in range(self.miles1GroundHandler.getNumEntries()): entry = self.miles1GroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries) > 0) and (entries[0].getIntoNode().getName() == "terrain"): miles1Z = entries[0].getSurfacePoint(render).getZ() miles1Y = entries[0].getSurfacePoint(render).getY() miles1X = entries[0].getSurfacePoint(render).getX() self.miles1.setZ(entries[0].getSurfacePoint(render).getZ()) else: self.miles1.setPos(startpos) return task.cont def moveMiles2AI(self, task): startpos = self.miles2.getPos() entries = [] for i in range(self.miles2GroundHandler.getNumEntries()): entry = self.miles2GroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries) > 0) and (entries[0].getIntoNode().getName() == "terrain"): miles2Z = entries[0].getSurfacePoint(render).getZ() miles2Y = entries[0].getSurfacePoint(render).getY() miles2X = entries[0].getSurfacePoint(render).getX() self.miles2.setZ(entries[0].getSurfacePoint(render).getZ()) else: self.miles2.setPos(startpos) return task.cont def moveTrexAI(self, task): startpos = self.trex.getPos() entries = [] for i in range(self.trexGroundHandler.getNumEntries()): entry = self.trexGroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries) > 0) and (entries[0].getIntoNode().getName() == "terrain"): trexZ = entries[0].getSurfacePoint(render).getZ() trexY = entries[0].getSurfacePoint(render).getY() trexX = entries[0].getSurfacePoint(render).getX() self.trex.setZ(entries[0].getSurfacePoint(render).getZ()) else: self.trex.setPos(startpos) return task.cont def setKey(self, action, value): self.keyMap[action] = value def move(self, task): base.camera.lookAt(self.sonic) if self.keyMap["cam-left"] != 0: base.camera.setX(base.camera, -30 * globalClock.getDt()) if self.keyMap["cam-right"] != 0: base.camera.setX(base.camera, +30 * globalClock.getDt()) startpos = self.sonic.getPos() if self.keyMap["left"] != 0: self.sonic.setH(self.sonic.getH() + 300 * globalClock.getDt()) if self.keyMap["right"] != 0: self.sonic.setH(self.sonic.getH() - 300 * globalClock.getDt()) if self.keyMap["forward"] != 0: self.sonic.setY(self.sonic, -100 * globalClock.getDt() * SPEED) if self.keyMap["backward"] != 0: self.sonic.setY(self.sonic, 100 * globalClock.getDt() * SPEED) # If sonic is moving, loop the run animation # If he is standing still, stop the animation if ( (self.keyMap["forward"] != 0) or (self.keyMap["left"] != 0) or (self.keyMap["right"] != 0) or (self.keyMap["backward"] != 0) ): if self.isMoving is False: self.sonic.loop("board") self.isMoving = True else: if self.isMoving: self.sonic.stop() self.sonic.pose("fwboard", 5) self.isMoving = False # If the camera is too far from sonic, move it closer # If the camera is too close to sonic, move it farther camvec = self.sonic.getPos() - base.camera.getPos() camvec.setZ(0) camdist = camvec.length() camvec.normalize() if camdist > 10.0: base.camera.setPos(base.camera.getPos() + (camvec * (camdist - 10))) camdist = 10.0 if camdist < 5.0: base.camera.setPos(base.camera.getPos() - (camvec * (5 - camdist))) camdist = 5.0 # now check for collisions self.cTrav.traverse(render) entries = [] for i in range(self.sonicGroundHandler.getNumEntries()): entry = self.sonicGroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries) > 0) and (entries[0].getIntoNode().getName() == "terrain"): self.sonic.setZ(entries[0].getSurfacePoint(render).getZ()) else: self.sonic.setPos(startpos) # keep the camera at one foot avoce the terrian # or two feet above sonic, whichever is greater entries = [] for i in range(self.camGroundHandler.getNumEntries()): entry = self.camGroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries) > 0) and (entries[0].getIntoNode().getName() == "terrain"): base.camera.setZ(entries[0].getSurfacePoint(render).getZ() + 1.0) if base.camera.getZ() < self.sonic.getZ() + 2.0: base.camera.setZ(self.sonic.getZ() + 2.0) # The camera should look in sonic's direction, # but it should also try to stay horizontal, so look at # a floater which hovers above sonic's head self.floater.setPos(self.sonic.getPos()) self.floater.setZ(self.sonic.getZ() + 2.0) base.camera.lookAt(self.floater) # Update the camera based on mouse movement md = base.win.getPointer(0) x = md.getX() y = md.getY() if base.win.movePointer(0, base.win.getXSize() / 2, base.win.getYSize() / 2): base.camera.setX(base.camera, (x - base.win.getXSize() / 2) * globalClock.getDt() * 0.1) # timer countdown global TIME TIME = TOTAL_TIME - int(task.time) self.time_text.setText("Time Remaining :: %i" % TIME) return task.cont def checkWin(self, task): delta = self.sonic.getDistance(self.flag) if delta < 25: self.winText = OnscreenText( text="You Win!", style=1, fg=(1, 1, 1, 1), pos=(0, 0), align=TextNode.ACenter, scale=0.4 ) self.resetBtn = DirectButton( text=("Restart", "Restart", "Restart"), scale=0.1, command=self.resetGame, pos=(0, 0, -0.7) ) taskMgr.remove("moveTask") if self.gameAudio.status() == self.gameAudio.PLAYING: self.gameAudio.stop() self.winAudio.play() return task.done return task.cont def checkTime(self, task): time_left = TIME if time_left == 0: taskMgr.remove("moveTask") self.gameOverText = OnscreenText( text="Game Over!", style=1, fg=(1, 1, 1, 1), pos=(0, 0), align=TextNode.ACenter, scale=0.4 ) self.resetBtn = DirectButton( text=("Restart", "Restart", "Restart"), scale=0.1, command=self.resetGame, pos=(0, 0, -0.7) ) return task.done return task.cont def checkGameOver(self, task): health_left = HEALTH if 1 <= health_left <= 10: global SPEED SPEED = 0.5 if health_left <= 0: taskMgr.remove("moveTask") self.gameOverText = OnscreenText( text="Game Over!", style=1, fg=(1, 1, 1, 1), pos=(0, 0), align=TextNode.ACenter, scale=0.4 ) self.resetBtn = DirectButton( text=("Restart", "Restart", "Restart"), scale=0.1, command=self.resetGame, pos=(0, 0, -0.7) ) if self.gameAudio.status() == self.gameAudio.PLAYING: self.gameAudio.stop() self.loseAudio.play() return task.done return task.cont def resetGame(self): # re-add the move task taskMgr.add(self.move, "moveTask") # remove GUI elements if hasattr(game, "gameOverText"): self.gameOverText.destroy() if hasattr(game, "resetBtn"): self.resetBtn.destroy() if hasattr(game, "winText"): self.winText.destroy() if (self.winAudio.status() == self.winAudio.PLAYING) or (self.loseAudio.status() == self.loseAudio.PLAYING): self.winAudio.stop() self.loseAudio.stop() self.gameAudio.play() # reset position self.sonic.setPos(self.START) # reset time count global TIME, TOTAL_TIME TIME = 120 TOTAL_TIME = 120 def showMenu(self): # TODO: add more controls text self.startAudio.play() self.gameNameText = OnscreenText( text="Run, Baby, Run", style=1, fg=(1, 1, 1, 1), pos=(0, 0.5), align=TextNode.ACenter, scale=0.3 ) text = """ Controls =============== [W] - Move Forward [A] - Move Left [S] - Move Backwards [D] - Move Right [<-] - Rotate Camera (Left) [->] - Rotate Camera (Right) Camera Movements are also controlled by mouse """ self.controlsText = OnscreenText( text=text, style=1, fg=(1, 1, 1, 1), pos=(0, 0), align=TextNode.ACenter, scale=0.05 ) self.startBtn = DirectButton( text=("Start", "Start", "Start"), scale=0.1, command=self.startGame, pos=(0, 0, -0.7) ) def checkConditions(self, task): trexDelta = self.sonic.getDistance(self.trex) miles1Delta = self.sonic.getDistance(self.miles1) miles2Delta = self.sonic.getDistance(self.miles2) if trexDelta <= 5 or miles1Delta <= 15 or miles2Delta <= 15: global HEALTH HEALTH = HEALTH - 1 if HEALTH < 0: HEALTH = 0 self.health_text.setText("Health :: %i" % HEALTH) return task.cont def checkSpeed(self, task): speedDelta = self.sonic.getDistance(self.speedPill) if speedDelta <= 30: global SPEED SPEED = SPEED + 1 self.speedPill.removeNode() return task.done return task.cont def checkSpeed2(self, task): speedDelta2 = self.sonic.getDistance(self.speedPillb) if speedDelta2 <= 3720: global SPEED SPEED = SPEED + 1 self.speedPillb.removeNode() return task.done return task.cont def checkHealthBoost(self, task): healthDelta = self.sonic.getDistance(self.banana) if healthDelta <= 3: global HEALTH HEALTH = HEALTH + 10 if HEALTH > 100: HEALTH = 100 self.banana.removeNode() self.health_text.setText("Health :: %i" % HEALTH) return task.done return task.cont def checkTimeAdd(self, task): timeAddDelta = self.sonic.getDistance(self.sphinx) if timeAddDelta <= 507: global TOTAL_TIME TOTAL_TIME = TOTAL_TIME + 10 self.time_text.setText("Time Remaining :: %i" % TOTAL_TIME) self.sphinx.removeNode() return task.done return task.cont def startGame(self): # remove menu main elements if hasattr(game, "startBtn"): self.startBtn.destroy() if hasattr(game, "gameNameText"): self.gameNameText.destroy() if hasattr(game, "controlsText"): self.controlsText.destroy() if self.startAudio.status() == self.startAudio.PLAYING: self.startAudio.stop() self.gameAudio.play() # HUD information (time, health) self.time_text = addInstruction((-1.2, 0.9), "Time Reamining :: %i" % TIME) self.health_text = addInstruction((0.9, 0.9), "Health :: %i" % HEALTH) # the environment self.env = loader.loadModel("../assets/models/world") self.env.reparentTo(render) self.env.setPos(0, 0, 0) # the flag(destination) self.flag = loader.loadModel("../assets/models/flag/flag") self.flag.reparentTo(render) self.flag.setScale(0.1) self.flag.setPos(0, 0, 5) self.DESTINATION = self.flag.getPos() # main character(sonic) self.START = self.env.find("**/start_point").getPos() self.sonic = Actor( "../assets/models/sonic/sonic", { "run": "../assets/models/sonic/sonic-run", "win": "../assets/models/sonic/sonic-win", "board": "../assets/models/sonic/sonic-board", "fwboard": "../assets/models/sonic/sonic-fallingwboard", "fwoboard": "../assets/models/sonic/sonic-fallingwoboard", }, ) self.sonic.reparentTo(render) self.sonic.setScale(0.05) self.sonic.setPos(self.START) # create a floater object to be used as a temporary # variable in a variety of calculations self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) taskMgr.add(self.move, "moveTask") # varible to keep track of moving state self.isMoving = False # variable to keep track of speed boost self.speedBoost = False # variable to keep track of invulnerability self.invul = False # setup the camera base.disableMouse() base.camera.setPos(self.sonic.getX(), self.sonic.getY() + 10, 2) self.cTrav = CollisionTraverser() # self.pusher = CollisionHandlerPusher() self.sonicGroundRay = CollisionRay() self.sonicGroundRay.setOrigin(0, 0, 1000) self.sonicGroundRay.setDirection(0, 0, -1) self.sonicGroundCol = CollisionNode("sonicRay") self.sonicGroundCol.addSolid(self.sonicGroundRay) # self.sonicGroundCol.addSolid(CollisionSphere(0, 0, 1.5, 1.5)) self.sonicGroundCol.setFromCollideMask(BitMask32.bit(0)) self.sonicGroundCol.setIntoCollideMask(BitMask32.allOff()) self.sonicGroundColNp = self.sonic.attachNewNode(self.sonicGroundCol) self.sonicGroundHandler = CollisionHandlerQueue() self.sonicPusher = CollisionHandlerPusher() self.sonicPusher.addInPattern("%fn-into-%in") self.cTrav.addCollider(self.sonicGroundColNp, self.sonicGroundHandler) # self.cTrav.addCollider(self.sonicGroundColNp, self.sonicPusher) # self.sonicPusher.addCollider(self.sonicGroundColNp, self.sonic) self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0, 0, 1000) self.camGroundRay.setDirection(0, 0, -1) self.camGroundCol = CollisionNode("camRay") self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(BitMask32.bit(0)) self.camGroundCol.setIntoCollideMask(BitMask32.allOff()) self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # see the collision rays # self.sonicGroundColNp.show() # self.camGroundColNp.show() # visual representation of the collisions occuring # self.cTrav.showCollisions(render) # create AI characters self.createTrexAI() self.createMilesAI() # place the presents self.createPresents() # check winning condition taskMgr.add(self.checkWin, "checkWin") # check time conditions taskMgr.add(self.checkTime, "checkTime") # check health conditions taskMgr.add(self.checkGameOver, "checkGameOver") # check other conditions taskMgr.add(self.checkConditions, "checkConditions") taskMgr.add(self.checkSpeed, "checkSpeed") taskMgr.add(self.checkSpeed2, "checkSpeed2") taskMgr.add(self.checkHealthBoost, "checkHealthBoost") taskMgr.add(self.checkTimeAdd, "checkTimeAdd")
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 __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)
def __init__(self): ''' class constructor Creates environment, player objects ''' # initialize #ShowBase.__init__(self) # set keybinds setKeybinds() mission = self self.nextValidSpawn = 0 # handle collisions # collision traversal 'traverses' instances of collides base.cTrav = CollisionTraverser() #switched to base base.pusher = CollisionHandlerPusher() #switched to base base.pusher.addInPattern('entityCollision') base.groundHandler = CollisionHandlerQueue() # add catch-all handler #base.entityCollisionHandler.addInPattern('entityCollision') # handle entity collisions # pass to entityCollided base.accept('entityCollision', entityCollided) # handle bullet collisions # accept this event and pass it to method bulletCollided base.accept('bulletCollision', bulletCollided) # self.render references base.render self.render = base.render mission.CAPTURE_TIME = 15 #time to capture single flag mission.CAPTURE_RADIUS = 300 #radius that needs to be controlled to cap flag #cleanup is list that saves items to destroy on mission end base.cleanup = [] # entities is list of all entities in gamespace. Used for applying gravity etc base.entities = [] # also keep a running list of all structures base.structures = [] #setup for AI base.AIworld = AIWorld(base.render) # load environment self.makeEnviron("example") # sfx handler for 3D audio #base.audio3d = Audio3DManager(base.sfxManagerList[0], base.camera) #background music self.music = base.loader.loadSfx("sounds/dramatic.ogg") self.music.setLoop(True) self.music.setVolume(0.15) self.music.play() # load GUI self.makeGUI() #set up player and camera #set mouse mode to relative base.disableMouse() setMouseMode(1) #find nodes in environment and store on game object self.team0Node = self.environment.find("**/team0") self.team0BaseNode = self.environment.find("**/team0base") self.team1Node = self.environment.find("**/team1") self.team1BaseNode = self.environment.find("**/team1base") #load occlusion nodes from environment #format in blender: #occlusion planes all parented to base level 'occluders' empty #occlusion planes named 'occluder#' occluder_nodes = self.environment.findAllMatches( '**/occluders/+OccluderNode') for occluder_nodepath in occluder_nodes: base.render.setOccluder(occluder_nodepath) occluder_nodepath.node().setDoubleSided(True) #for now will attempt to load up to 12 flags, and reject entries that don't work #TODO: dynamically load based on amount of flag nodes found #also may change capture time depending on flag self.flags = [] self.outposts = [] for i in range(12): thisFlag = self.environment.find("**/flag" + str(i)) #only append if found successfully if thisFlag.error_type == 0: self.flags.append(thisFlag) thisFlag.setPythonTag('lastCapture', None) #last capture attempt thisFlag.setPythonTag('lastCaptureTeam', None) #last team that tried to cap self.spawnPlayer() #standing=rifleman(base,self.team0Node.getPos(),0) #running = rifleman(base, self.team0Node.getPos(), 0) #soldat = rifleman(base, self.team0Node.getPos(), 0) #instancee=base.render.attachNewNode('blast') #instancee.setX(instancee.getX()+200) #instance=soldat.instanceTo(instancee) #instancee.setX(instancee.getX()-180) #enemy = rifleman(base, (20, 300, 0),1) #friendly = rifleman(base, self.team0Node.getPos(), 0) #friendly.setGoal(self.flags[1]) #load gameplay logic # update all entities taskMgr.add(self.updateEntities, "updateEntitiesTask") self.playerScore = 0 self.spawnBases() self.spawnEnemies()
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 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]
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 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)
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()
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
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 __init__(self): ShowBase.__init__(self) self.disableMouse() properties = WindowProperties() properties.setSize(1000, 750) self.win.requestProperties(properties) self.exitFunc = self.cleanup mainLight = DirectionalLight("main light") self.mainLightNodePath = render.attachNewNode(mainLight) self.mainLightNodePath.setHpr(45, -45, 0) render.setLight(self.mainLightNodePath) ambientLight = AmbientLight("ambient light") ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) self.ambientLightNodePath = render.attachNewNode(ambientLight) render.setLight(self.ambientLightNodePath) render.setShaderAuto() self.environment = loader.loadModel("Models/Misc/environment") self.environment.reparentTo(render) self.camera.setPos(0, 0, 32) self.camera.setP(-90) self.keyMap = { "up" : False, "down" : False, "left" : False, "right" : False, "shoot" : False } 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]) self.pusher = CollisionHandlerPusher() self.cTrav = CollisionTraverser() self.pusher.setHorizontal(True) self.pusher.add_in_pattern("%fn-into-%in") self.accept("trapEnemy-into-wall", self.stopTrap) self.accept("trapEnemy-into-trapEnemy", self.stopTrap) self.accept("trapEnemy-into-player", self.trapHitsSomething) self.accept("trapEnemy-into-walkingEnemy", self.trapHitsSomething) 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) self.updateTask = taskMgr.add(self.update, "update") self.player = None self.enemies = [] self.trapEnemies = [] self.deadEnemies = [] self.spawnPoints = [] numPointsPerWall = 5 for i in range(numPointsPerWall): coord = 7.0/numPointsPerWall + 0.5 self.spawnPoints.append(Vec3(-7.0, coord, 0)) self.spawnPoints.append(Vec3(7.0, coord, 0)) self.spawnPoints.append(Vec3(coord, -7.0, 0)) self.spawnPoints.append(Vec3(coord, 7.0, 0)) self.initialSpawnInterval = 1.0 self.minimumSpawnInterval = 0.2 self.spawnInterval = self.initialSpawnInterval self.spawnTimer = self.spawnInterval self.maxEnemies = 2 self.maximumMaxEnemies = 20 self.numTrapsPerSide = 2 self.difficultyInterval = 5.0 self.difficultyTimer = self.difficultyInterval self.enemySpawnSound = loader.loadSfx("Sounds/enemySpawn.ogg") self.gameOverScreen = DirectDialog(frameSize = (-0.7, 0.7, -0.7, 0.7), fadeScreen = 0.4, relief = DGG.FLAT, frameTexture = "UI/stoneFrame.png") self.gameOverScreen.hide() self.font = loader.loadFont("Fonts/Wbxkomik.ttf") buttonImages = ( loader.loadTexture("UI/UIButton.png"), loader.loadTexture("UI/UIButtonPressed.png"), loader.loadTexture("UI/UIButtonHighlighted.png"), loader.loadTexture("UI/UIButtonDisabled.png") ) label = DirectLabel(text = "Game Over!", parent = self.gameOverScreen, scale = 0.1, pos = (0, 0, 0.2), text_font = self.font, relief = None) self.finalScoreLabel = DirectLabel(text = "", parent = self.gameOverScreen, scale = 0.07, pos = (0, 0, 0), text_font = self.font, relief = None) btn = DirectButton(text = "Restart", command = self.startGame, pos = (-0.3, 0, -0.2), parent = self.gameOverScreen, scale = 0.07, text_font = self.font, clickSound = loader.loadSfx("Sounds/UIClick.ogg"), frameTexture = buttonImages, frameSize = (-4, 4, -1, 1), text_scale = 0.75, relief = DGG.FLAT, text_pos = (0, -0.2)) btn.setTransparency(True) btn = DirectButton(text = "Quit", command = self.quit, pos = (0.3, 0, -0.2), parent = self.gameOverScreen, scale = 0.07, text_font = self.font, clickSound = loader.loadSfx("Sounds/UIClick.ogg"), frameTexture = buttonImages, frameSize = (-4, 4, -1, 1), text_scale = 0.75, relief = DGG.FLAT, text_pos = (0, -0.2)) btn.setTransparency(True) self.titleMenuBackdrop = DirectFrame(frameColor = (0, 0, 0, 1), frameSize = (-1, 1, -1, 1), parent = render2d) self.titleMenu = DirectFrame(frameColor = (1, 1, 1, 0)) title = DirectLabel(text = "Panda-chan", scale = 0.1, pos = (0, 0, 0.9), parent = self.titleMenu, relief = None, text_font = self.font, text_fg = (1, 1, 1, 1)) title2 = DirectLabel(text = "and the", scale = 0.07, pos = (0, 0, 0.79), parent = self.titleMenu, text_font = self.font, frameColor = (0.5, 0.5, 0.5, 1)) title3 = DirectLabel(text = "Endless Horde", scale = 0.125, pos = (0, 0, 0.65), parent = self.titleMenu, relief = None, text_font = self.font, text_fg = (1, 1, 1, 1)) btn = DirectButton(text = "Start Game", command = self.startGame, pos = (0, 0, 0.2), parent = self.titleMenu, scale = 0.1, text_font = self.font, clickSound = loader.loadSfx("Sounds/UIClick.ogg"), frameTexture = buttonImages, frameSize = (-4, 4, -1, 1), text_scale = 0.75, relief = DGG.FLAT, text_pos = (0, -0.2)) btn.setTransparency(True) btn = DirectButton(text = "Quit", command = self.quit, pos = (0, 0, -0.2), parent = self.titleMenu, scale = 0.1, text_font = self.font, clickSound = loader.loadSfx("Sounds/UIClick.ogg"), frameTexture = buttonImages, frameSize = (-4, 4, -1, 1), text_scale = 0.75, relief = DGG.FLAT, text_pos = (0, -0.2)) btn.setTransparency(True) music = loader.loadMusic("Music/Defending-the-Princess-Haunted.ogg") music.setLoop(True) music.setVolume(0.075) music.play()
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