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 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 __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 initCollisions(self): self.collNodePath.setCollideMask(BitMask32(0)) self.collNodePath.node().setFromCollideMask(CIGlobals.WallBitmask) pusher = CollisionHandlerPusher() pusher.setInPattern('%in') pusher.addCollider(self.collNodePath, self) base.cTrav.addCollider(self.collNodePath, pusher)
def 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 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): # # 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): 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 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): 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) 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, 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 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 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 __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): # 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')
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 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): 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 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 __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 __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 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]
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()
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) # 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): ShowBase.__init__(self) self.disableMouse() properties = WindowProperties() properties.setSize(1000, 750) self.win.requestProperties(properties) 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.tempActor = Actor("Models/PandaChan/act_p3d_chan", {"walk" : "Models/PandaChan/a_p3d_chan_run"}) self.tempActor.getChild(0).setH(180) self.tempActor.reparentTo(render) self.tempActor.loop("walk") 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) colliderNode = CollisionNode("player") colliderNode.addSolid(CollisionSphere(0, 0, 0, 0.3)) collider = self.tempActor.attachNewNode(colliderNode) base.pusher.addCollider(collider, self.tempActor) base.cTrav.addCollider(collider, self.pusher) 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")
def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) base.render.setAttrib(LightRampAttrib.makeHdr0()) # Configure depth pre-pass prepass_pass = lionrender.DepthScenePass() # Configure scene pass scene_fb_props = FrameBufferProperties() scene_fb_props.set_rgb_color(True) scene_fb_props.set_rgba_bits(8, 8, 8, 0) scene_fb_props.set_depth_bits(32) scene_pass = lionrender.ScenePass( frame_buffer_properties=scene_fb_props, clear_color=LColor(0.53, 0.80, 0.92, 1), share_depth_with=prepass_pass) scene_pass.node_path.set_depth_write(False) # Configure post processing filter_pass = lionrender.FilterPass(fragment_path='shaders/fsq.frag') filter_pass.node_path.set_shader_input('inputTexture', scene_pass.output) # Enable FXAA fxaa_pass = lionrender.FxaaFilterPass() fxaa_pass.node_path.set_shader_input('inputTexture', filter_pass.output) # Output result fxaa_pass.output_to(render2d) # This is used to store which keys are currently pressed. self.keyMap = { "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0, } # Post the instructions self.title = addTitle( "Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)") self.inst1 = addInstructions(0.06, "[ESC]: Quit") self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left") self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right") self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward") self.inst5 = addInstructions(0.30, "[Down Arrow]: Walk Ralph Backward") self.inst6 = addInstructions(0.36, "[A]: Rotate Camera Left") self.inst7 = addInstructions(0.42, "[S]: Rotate Camera Right") # Set up the environment # # This environment model contains collision meshes. If you look # in the egg file, you will see the following: # # <Collide> { Polyset keep descend } # # This tag causes the following mesh to be converted to a collision # mesh -- a mesh which is optimized for collision, not rendering. # It also keeps the original mesh, so there are now two copies --- # one optimized for rendering, one for collisions. self.environ = loader.loadModel("models/world") self.environ.reparentTo(render) # We do not have a skybox, so we will just use a sky blue background color self.setBackgroundColor(0.53, 0.80, 0.92, 1) # Create the main character, Ralph ralphStartPos = self.environ.find("**/start_point").getPos() self.ralph = Actor("models/ralph", { "run": "models/ralph-run", "walk": "models/ralph-walk" }) self.ralph.reparentTo(render) self.ralph.setScale(.2) self.ralph.setPos(ralphStartPos + (0, 0, 1.5)) # Create a floater object, which floats 2 units above ralph. We # use this as a target for the camera to look at. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(self.ralph) self.floater.setZ(2.0) # Accept the control keys for movement and rotation self.accept("escape", sys.exit) self.accept("arrow_left", self.setKey, ["left", True]) self.accept("arrow_right", self.setKey, ["right", True]) self.accept("arrow_up", self.setKey, ["forward", True]) self.accept("arrow_down", self.setKey, ["backward", True]) self.accept("a", self.setKey, ["cam-left", True]) self.accept("s", self.setKey, ["cam-right", True]) self.accept("arrow_left-up", self.setKey, ["left", False]) self.accept("arrow_right-up", self.setKey, ["right", False]) self.accept("arrow_up-up", self.setKey, ["forward", False]) self.accept("arrow_down-up", self.setKey, ["backward", False]) self.accept("a-up", self.setKey, ["cam-left", False]) self.accept("s-up", self.setKey, ["cam-right", False]) self.accept("v", self.toggleCards) taskMgr.add(self.move, "moveTask") # Set up the camera self.disableMouse() self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2) self.cTrav = CollisionTraverser() # Use a CollisionHandlerPusher to handle collisions between Ralph and # the environment. Ralph is added as a "from" object which will be # "pushed" out of the environment if he walks into obstacles. # # Ralph is composed of two spheres, one around the torso and one # around the head. They are slightly oversized since we want Ralph to # keep some distance from obstacles. self.ralphCol = CollisionNode('ralph') self.ralphCol.addSolid(CollisionSphere(center=(0, 0, 2), radius=1.5)) self.ralphCol.addSolid( CollisionSphere(center=(0, -0.25, 4), radius=1.5)) self.ralphCol.setFromCollideMask(CollideMask.bit(0)) self.ralphCol.setIntoCollideMask(CollideMask.allOff()) self.ralphColNp = self.ralph.attachNewNode(self.ralphCol) self.ralphPusher = CollisionHandlerPusher() self.ralphPusher.horizontal = True # Note that we need to add ralph both to the pusher and to the # traverser; the pusher needs to know which node to push back when a # collision occurs! self.ralphPusher.addCollider(self.ralphColNp, self.ralph) self.cTrav.addCollider(self.ralphColNp, self.ralphPusher) # We will detect the height of the terrain by creating a collision # ray and casting it downward toward the terrain. One ray will # start above ralph's head, and the other will start above the camera. # A ray may hit the terrain, or it may hit a rock or a tree. If it # hits the terrain, we can detect the height. self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0, 0, 9) self.ralphGroundRay.setDirection(0, 0, -1) self.ralphGroundCol = CollisionNode('ralphRay') self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0)) self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0, 0, 9) self.camGroundRay.setDirection(0, 0, -1) self.camGroundCol = CollisionNode('camRay') self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(CollideMask.bit(0)) self.camGroundCol.setIntoCollideMask(CollideMask.allOff()) self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # Uncomment this line to see the collision rays #self.ralphColNp.show() #self.camGroundColNp.show() # Uncomment this line to show a visual representation of the # collisions occuring #self.cTrav.showCollisions(render) # Create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.3, .3, .3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection((-5, -5, -5)) directionalLight.setColor((1, 1, 1, 1)) directionalLight.setSpecularColor((1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight)) # Clean up texture attributes for texture in self.render.find_all_textures(): texture.set_format(Texture.F_srgb)
def __init__(self): ShowBase.__init__(self) self.disableMouse() properties = WindowProperties() properties.setSize(1000, 750) self.win.requestProperties(properties) ambientLight = AmbientLight("ambient light") ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) self.ambientLightNodePath = render.attachNewNode(ambientLight) render.setLight(self.ambientLightNodePath) mainLight = DirectionalLight("main light") self.mainLightNodePath = render.attachNewNode(mainLight) # Turn it around by 45 degrees, and tilt it down by 45 degrees self.mainLightNodePath.setHpr(45, -45, 0) render.setLight(self.mainLightNodePath) render.setShaderAuto() self.environment = loader.loadModel("Models/Misc/environment") self.environment.reparentTo(render) self.tempActor = Actor("Models/PandaChan/act_p3d_chan", {"walk" : "Models/PandaChan/a_p3d_chan_run"}) self.tempActor.getChild(0).setH(180) self.tempActor.reparentTo(render) self.tempActor.setPos(0, 2, 0) self.tempActor.loop("walk") 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.updateTask = taskMgr.add(self.update, "update") # Panda should now automatically update that traverser! self.cTrav = CollisionTraverser() self.pusher = CollisionHandlerPusher() # prevents nominated solid objects from intersecting other solid objects. colliderNode = CollisionNode("player") # Add a collision-sphere centred on (0, 0, 0), and with a radius of 0.3 colliderNode.addSolid(CollisionSphere(0, 0, 0, 0.4)) collider = self.tempActor.attachNewNode(colliderNode) collider.show() # The pusher wants a collider, and a NodePath that # should be moved by that collider's collisions. # In this case, we want our player-Actor to be moved. base.pusher.addCollider(collider, self.tempActor) # The traverser wants a collider, and a handler # that responds to that collider's collisions base.cTrav.addCollider(collider, self.pusher) self.pusher.setHorizontal(True) # Tubes are defined by their start-points, end-points, and radius. # In this first case, the tube goes from (-8, 0, 0) to (8, 0, 0), # and has a radius of 0.2. wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setY(8.0) wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setY(-8.0) wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setX(8.0) wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setX(-8.0)
def __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.startGame()