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()
