def initializeSmartCameraCollisions(self):
if self.initialized:
return
self.ccTrav = CollisionTraverser('LocalAvatar.ccTrav')
self.ccLine = CollisionSegment(0.0, 0.0, 0.0, 1.0, 0.0, 0.0)
self.ccLineNode = CollisionNode('ccLineNode')
self.ccLineNode.addSolid(self.ccLine)
self.ccLineNodePath = base.localAvatar.attachNewNode(self.ccLineNode)
self.ccLineBitMask = CIGlobals.CameraBitmask
self.ccLineNode.setFromCollideMask(self.ccLineBitMask)
self.ccLineNode.setIntoCollideMask(BitMask32.allOff())
self.camCollisionQueue = CollisionHandlerQueue()
self.ccTrav.addCollider(self.ccLineNodePath, self.camCollisionQueue)
self.ccSphere = CollisionSphere(0, 0, 0, 1)
self.ccSphereNode = CollisionNode('ccSphereNode')
self.ccSphereNode.addSolid(self.ccSphere)
self.ccSphereNodePath = base.camera.attachNewNode(self.ccSphereNode)
self.ccSphereNode.setFromCollideMask(CIGlobals.CameraBitmask)
self.ccSphereNode.setIntoCollideMask(BitMask32.allOff())
self.camPusher = CollisionHandlerPusher()
self.camPusher.addCollider(self.ccSphereNodePath, base.camera)
self.camPusher.setCenter(base.localAvatar)
self.ccPusherTrav = CollisionTraverser('LocalAvatar.ccPusherTrav')
self.ccSphere2 = self.ccSphere
self.ccSphereNode2 = CollisionNode('ccSphereNode2')
self.ccSphereNode2.addSolid(self.ccSphere2)
self.ccSphereNodePath2 = base.camera.attachNewNode(self.ccSphereNode2)
self.ccSphereNode2.setFromCollideMask(CIGlobals.CameraBitmask)
self.ccSphereNode2.setIntoCollideMask(BitMask32.allOff())
self.camPusher2 = CollisionHandlerPusher()
self.ccPusherTrav.addCollider(self.ccSphereNodePath2, self.camPusher2)
self.camPusher2.addCollider(self.ccSphereNodePath2, base.camera)
self.camPusher2.setCenter(base.localAvatar)
self.camFloorRayNode = base.localAvatar.attachNewNode('camFloorRayNode')
self.ccRay = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0)
self.ccRayNode = CollisionNode('ccRayNode')
self.ccRayNode.addSolid(self.ccRay)
self.ccRayNodePath = self.camFloorRayNode.attachNewNode(self.ccRayNode)
self.ccRayBitMask = CIGlobals.FloorBitmask
self.ccRayNode.setFromCollideMask(self.ccRayBitMask)
self.ccRayNode.setIntoCollideMask(BitMask32.allOff())
self.ccTravFloor = CollisionTraverser('LocalAvatar.ccTravFloor')
self.camFloorCollisionQueue = CollisionHandlerQueue()
self.ccTravFloor.addCollider(self.ccRayNodePath, self.camFloorCollisionQueue)
self.ccTravOnFloor = CollisionTraverser('LocalAvatar.ccTravOnFloor')
self.ccRay2 = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0)
self.ccRay2Node = CollisionNode('ccRay2Node')
self.ccRay2Node.addSolid(self.ccRay2)
self.ccRay2NodePath = self.camFloorRayNode.attachNewNode(self.ccRay2Node)
self.ccRay2BitMask = CIGlobals.FloorBitmask
self.ccRay2Node.setFromCollideMask(self.ccRay2BitMask)
self.ccRay2Node.setIntoCollideMask(BitMask32.allOff())
self.ccRay2MoveNodePath = hidden.attachNewNode('ccRay2MoveNode')
self.camFloorCollisionBroadcaster = CollisionHandlerFloor()
self.camFloorCollisionBroadcaster.setInPattern('on-floor')
self.camFloorCollisionBroadcaster.setOutPattern('off-floor')
self.camFloorCollisionBroadcaster.addCollider(self.ccRay2NodePath, self.ccRay2MoveNodePath)
self.cTrav.addCollider(self.ccRay2NodePath, self.camFloorCollisionBroadcaster)
self.initialized = True
def levelInit(self, levelname):
# Load a backdrop model and attach it to the Scene Graph
self.environment = loader.loadModel(levelname)
self.environment.reparentTo(render)
# Set up level collision
self.cTrav = CollisionTraverser()
self.pusher = CollisionHandlerPusher()
def __init__(self):
self.rayCTrav = CollisionTraverser("collision traverser for ray tests")
#self.pusher = PhysicsCollisionHandler()
self.pusher = CollisionHandlerPusher()
self.pusher.addInPattern('%fn-in-%in')
self.pusher.addOutPattern('%fn-out-%in')
self.pusher.addInPattern('%fn-in')
self.pusher.addOutPattern('%fn-out')
def addPlayer(self, name):
self.players[name] = PlayerLogic(name)
self.players[name].nodePath = self.nodePath.attachNewNode(PandaNode(name))
collisionNodePath = self.players[name].nodePath.attachNewNode(CollisionNode("pusherCollision"))
collisionNodePath.node().addSolid(CollisionSphere(0, 0, 0, 1))
pusher = CollisionHandlerPusher()
pusher.addCollider(collisionNodePath, self.players[name].nodePath)
self.traverser.addCollider(collisionNodePath, pusher)
def wallCollisions(self):
# Pusher so that the player cannot move past the walls
self.playerPusher = CollisionHandlerPusher()
base.cTrav.addCollider(self.flyBot.playerCollider, self.playerPusher)
self.playerPusher.addCollider(self.flyBot.playerCollider,
self.flyBot.flyBot)
self.enemyPusher = CollisionHandlerPusher()
for enemy in self.enemies:
base.cTrav.addCollider(enemy.collider, self.enemyPusher)
self.enemyPusher.addCollider(enemy.collider, enemy.enemyModel)
def setupWallSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius)
cSphereNode = CollisionNode('Flyer.cWallSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
if config.GetBool('want-fluid-pusher', 0):
self.pusher = CollisionHandlerFluidPusher()
else:
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(cSphereNodePath, self.avatarNodePath)
self.cWallSphereNodePath = cSphereNodePath
def setupCollision(self):
cs = CollisionSphere(0, 0, 0, 10)
cnodePath = self.player.attachNewNode(CollisionNode('cnode'))
cnodePath.node().addSolid(cs)
cnodePath.show()
for o in self.OBS:
ct = CollisionBox(0, 1, 1, 0.5)
cn = o.attachNewNode(CollisionNode('ocnode'))
cn.node().addSolid(ct)
cn.show()
pusher = CollisionHandlerPusher()
pusher.addCollider(cnodePath, self.player)
self.cTrav = CollisionTraverser()
self.cTrav.addCollider(cnodePath, pusher)
self.cTrav.showCollisions(render)
def 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 postInit(self):
#
# initialize game content
#
base.cTrav = CollisionTraverser("base collision traverser")
base.pusher = CollisionHandlerPusher()
self.menu = Menu()
self.credits = Credits()
self.charSelection = CharacterSelection()
self.levelSelection = LevelSelection()
self.koScreen = KoScreen()
self.hud = Hud()
self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
self.menuMusic.setLoop(True)
self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
self.fightMusic.setLoop(True)
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
#
# Event handling
#
self.accept("escape", self.__escape)
#
# Start with the menu
#
self.request("Menu")
def postInit(self):
"""Post initialization necessary for running from p3d files"""
#
# initialize game content
base.cTrav = CollisionTraverser("base collision traverser")
base.pusher = CollisionHandlerPusher()
#
#TODO: put game content initialization stuff here
self.player = Player(0, 1, "p1")
self.player2 = Player(1, 2, "p2")
self.player.setEnemy(self.player2.collisionNodeName)
self.player2.setEnemy(self.player.collisionNodeName)
#
# Event handling
#
self.accept("escape", self.__escape)
#
# Start with the menu
#
#TODO: Change this to any state you want the game to start with
self.request("Game")
def __init__(self):
"""initialise the engine"""
ShowBase.__init__(self)
base.camLens.setNearFar(1.0, 10000)
base.camLens.setFov(75)
a = 33
base.camera.setPos(0,-a,a+3)#80)
# collision
base.cTrav = CollisionTraverser("base collision traverser")
base.cHandler = CollisionHandlerEvent()
base.cPusher = CollisionHandlerPusher()
base.cQueue = CollisionHandlerQueue()
base.globalClock=ClockObject.getGlobalClock()
base.cHandler.addInPattern('%fn-into-%in')
base.cHandler.addOutPattern('%fn-out-%in')
base.cHandler.addAgainPattern('%fn-again-%in')
# ai init
base.AIworld = AIWorld(render)
# 3d manager
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
self.monsters = []
self.accept('c',self._create)
base.enableParticles()
def __init__(self, engine, environment):
self.engine = engine
self.players = {}
self.environment = environment
self.inputQueue = deque()
self.collisionDummy = CollisionDummy()
self.inputPollWait = 0
self.playerCollisionHandler = CollisionHandlerPusher()
self.playerCollisionHandler.addCollider(self.collisionDummy.GetCollisionNode(), self.collisionDummy.GetNode())
self.playerCollisionTraverser = CollisionTraverser('playerCollisionTraverser')
self.playerCollisionTraverser.addCollider(self.collisionDummy.GetCollisionNode(), self.playerCollisionHandler)
#self.playerCollisionTraverser.showCollisions(render)
self.LoadServerPosDebug()
self.LoadMyself()
self.accept(ViewModeChangeEvent.EventName, self.OnViewModeChange)
self.accept(SelectedItemChangeEvent.EventName, self.OnSelectedItemChangeEvent)
self.accept(PlayerAttackEvent.EventName, self.OnPlayerAttackEvent)
self.accept(PlayerRespawnEvent.EventName, self.OnPlayerRespawnEvent)
self.accept(PlayerDeathEvent.EventName, self.OnPlayerDeathEvent)
self.accept(TeamSelectEvent.EventName, self.OnTeamSelectEvent)
if(not Settings.IS_SERVER):
self.sounds = {}
self.sounds['blockBreak'] = loader.loadSfx('Assets/Sounds/blockBreak.mp3')
self.sounds['blockPlace'] = loader.loadSfx('Assets/Sounds/blockPlace.mp3')
def postInit(self):
#
# initialize game content
#
# camera
base.camLens.setNearFar(1.0, 10000)
base.camLens.setFov(75)
a = 33
base.camera.setPos(0, -a, a + 3) #80)
# collision
base.cTrav = CollisionTraverser("base collision traverser")
base.cHandler = CollisionHandlerEvent()
base.cPusher = CollisionHandlerPusher()
base.cQueue = CollisionHandlerQueue()
base.globalClock = ClockObject.getGlobalClock()
base.cHandler.addInPattern('%fn-into-%in')
base.cHandler.addOutPattern('%fn-out-%in')
base.cHandler.addAgainPattern('%fn-again-%in')
# ai init
base.AIworld = AIWorld(render)
# 3d manager
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
# manager
self.archiveManager = ArchiveManager()
self.mapManager = MapManager()
self.initHeroInfo = None
# Lock
self.lock = threading.Lock()
self.gameThread = None
self.filters = CommonFilters(base.win, base.cam)
# UI
self.menu = Menu()
self.option = Option()
self.archive = Archive()
self.death = Death()
# self.oobe()
#self.Archive_status = 0
# self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
# self.menuMusic.setLoop(True)
# self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
# self.fightMusic.setLoop(True)
# base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
self.titleVideo, self.titleCard = loadVideo('title.mp4')
self.isInited = False
self.isSkip = False
self.isRenew = False
#
# Event handling
#
self.accept("escape", self.__escape)
#
# Start with the menu
#
self.request("Menu")
def __init__(self):
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 __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
self.orbCollisionHandler = CollisionHandlerQueue()
self.cTrav = CollisionTraverser()
#hbPath = NodePath()
utilsKristina.HealthBar()
utilsKristina.setUpKeys(self)
utilsKristina.loadModels(self)
utilsKristina.setUpLighting(self)
utilsKristina.setUpFloatingSpheres(self)
utilsKristina.setUpRalphsShot(self)
utilsKristina.setUpCamera(self)
utilsKristina.setUpCollisionSpheres(self)
self.healthTxt = utilsKristina.addInstructions(.06,"Health: 100")
self.orbTxt = utilsKristina.addInstructions(.18,"Orbs: 0")
self.vec = LVector3(0,1,0)#vector for pawns shot
# Create a frame
#frame = DirectFrame(text = "main", scale = 0.001)
# Add button
#bar = DirectWaitBar(text = "", value = 50, pos = (0,.4,.4))
#bar.reparent(render)
# Game state variables
self.isMoving = False
self.jumping = False
self.vz = 0
self.numOrbs = 0
self.healthCount = 100
#self.shotList = []
taskMgr.add(self.move, "moveTask")
#taskMgr.add(utils2.moveChris,"moveChrisTask")
self.sphere = CollisionSphere(0,0,4,2)
self.sphere2 = CollisionSphere(0,0,2,2)
self.cnodePath = self.ralph.attachNewNode((CollisionNode('ralphColNode')))
self.cnodePath.node().addSolid(self.sphere)
self.cnodePath.node().addSolid(self.sphere2)
#self.cnodePath.show()
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(self.cnodePath, self.ralph)
#self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler)
self.cTrav.addCollider(self.cnodePath, self.pusher)
# Uncomment this line to show a visual representation of the
# collisions occuring
self.cTrav.showCollisions(render)
self.chrisLastShotTime = globalClock.getFrameTime()
self.chrisTimer = globalClock.getDt()
def __init__(self, showBase):
self.showBase = showBase
Common.initialise()
Common.framework = self
showBase.render.setShaderAuto()
self.keyMap = {
"up" : False,
"down" : False,
"left" : False,
"right" : False,
"shoot" : False,
"shootSecondary" : False
}
showBase.accept("w", self.updateKeyMap, ["up", True])
showBase.accept("w-up", self.updateKeyMap, ["up", False])
showBase.accept("s", self.updateKeyMap, ["down", True])
showBase.accept("s-up", self.updateKeyMap, ["down", False])
showBase.accept("mouse1", self.updateKeyMap, ["shoot", True])
showBase.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
showBase.accept("mouse3", self.updateKeyMap, ["shootSecondary", True])
showBase.accept("mouse3-up", self.updateKeyMap, ["shootSecondary", False])
showBase.accept("\\", self.toggleFriction)
self.pusher = CollisionHandlerPusher()
self.traverser = CollisionTraverser()
self.traverser.setRespectPrevTransform(True)
self.pusher.add_in_pattern("%fn-into-%in")
self.pusher.add_in_pattern("%fn-into")
self.pusher.add_again_pattern("%fn-again-into")
showBase.accept("projectile-into", self.projectileImpact)
showBase.accept("projectile-again-into", self.projectileImpact)
showBase.accept("player-into", self.gameObjectPhysicalImpact)
showBase.accept("enemy-into", self.gameObjectPhysicalImpact)
self.updateTask = showBase.taskMgr.add(self.update, "update")
self.player = None
self.currentLevel = None
def __init__(self):
base.cTrav = CollisionTraverser()
base.pusher = CollisionHandlerPusher()
ConfigRender.__init__(self)
self.elapsedSeconds = 0
self.mapData = MapsModel()
self.gameData = GameModel('./saves/')
self.load_fonts()
# this needs to be called only when game starts
taskMgr.add(self.updateTime, 'updateTime')
def __init__(self):
ShowBase.__init__(self)
properties = WindowProperties()
properties.setSize(SCREEN_WIDTH, SCREEN_HEIGHT)
self.win.requestProperties(properties)
self.disableMouse()
self.cTrav = CollisionTraverser()
self.pusher = CollisionHandlerPusher()
self.pusher.setHorizontal(True)
self.scene = Scene(self.render, self.loader, self, 5)
self.player = Player("models/panda", {"walk": "models/panda-walk"}, 2, 15, "player",
self, Vec3(0, 0, 0), Vec3(180, 0, 0))
self.camera_init()
self.control_service()
self.updateTask = taskMgr.add(self.update, "update")
self.mouse_check_value = 0.7
self.pusher.add_in_pattern("%fn-into-%in")
def initCollisions(self):
self.collNodePath.setCollideMask(BitMask32(0))
self.collNodePath.node().setFromCollideMask(CIGlobals.WallBitmask)
pusher = CollisionHandlerPusher()
pusher.setInPattern('%in')
pusher.addCollider(self.collNodePath, self)
base.cTrav.addCollider(self.collNodePath, pusher)
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
# Create player node and attach camera and collision node/solid
self.Player = render.attachNewNode('Player')
self.camera.reparentTo(self.Player)
self.PlayerCN = CollisionNode('Player')
self.PlayerCNP = self.Player.attachNewNode(self.PlayerCN)
self.PlayerCSph = CollisionSphere(0, 0, 0, 1)
self.PlayerCN.addSolid(self.PlayerCSph)
# Player collision sphere
playerCS = CollisionSphere(0, 0, 0, 2)
playerCNP = self.Player.attachNewNode(CollisionNode('cnode'))
playerCNP.node().addSolid(playerCS)
#PlayerCNP.reparentTo(self.camera)
playerCNP.show() # This won't show since we are inside
# Create generic sphere in the world in front of us to see
self.Sphere = self.loader.loadModel("models/misc/sphere")
self.Sphere.reparentTo(self.render)
self.Sphere.setPos(0, 20, -0.2)
# Collision sphere for visible sphere, slightly larger
cs = CollisionSphere(0, 0, 0, 1)
cnodePath = self.Sphere.attachNewNode(CollisionNode('cSpherenode'))
cnodePath.node().addSolid(cs)
cnodePath.show()
# Create global collision traverser
self.cTrav = CollisionTraverser()
# Collision handler pusher - visible sphere will push back
self.pusher = CollisionHandlerPusher()
# Tell player sphere to act as pusher - or world object?
self.cTrav.addCollider(cnodePath, self.pusher)
self.pusher.addCollider(cnodePath, self.Sphere, base.drive.node())
seq = self.Player.posInterval(5, Point3(0, 40, 0),
startPos=Point3(0, 0, 0), fluid=1).loop()
def __init__(self, _main):
self.main = _main
self.name = ""
self.points = 0
self.health = 100.0
self.runSpeed = 1.8
self.keyMap = {
"left":False,
"right":False,
"up":False,
"down":False
}
base.camera.setPos(0,0,0)
self.model = loader.loadModel("Player")
self.model.find('**/+SequenceNode').node().stop()
self.model.find('**/+SequenceNode').node().pose(0)
base.camera.setP(-90)
self.playerHud = Hud()
self.playerHud.hide()
self.model.hide()
# Weapons: size=2, 0=main, 1=offhand
self.mountSlot = []
self.activeWeapon = None
self.isAutoActive = False
self.trigger = False
self.lastShot = 0.0
self.fireRate = 0.0
self.playerTraverser = CollisionTraverser()
self.playerEH = CollisionHandlerEvent()
## INTO PATTERNS
self.playerEH.addInPattern('intoPlayer-%in')
#self.playerEH.addInPattern('colIn-%fn')
self.playerEH.addInPattern('intoHeal-%in')
self.playerEH.addInPattern('intoWeapon-%in')
## OUT PATTERNS
self.playerEH.addOutPattern('outOfPlayer-%in')
playerCNode = CollisionNode('playerSphere')
playerCNode.setFromCollideMask(BitMask32.bit(1))
playerCNode.setIntoCollideMask(BitMask32.bit(1))
self.playerSphere = CollisionSphere(0, 0, 0, 0.6)
playerCNode.addSolid(self.playerSphere)
self.playerNP = self.model.attachNewNode(playerCNode)
self.playerTraverser.addCollider(self.playerNP, self.playerEH)
#self.playerNP.show()
self.playerPusher = CollisionHandlerPusher()
self.playerPusher.addCollider(self.playerNP, self.model)
self.playerPushTraverser = CollisionTraverser()
self.playerPushTraverser.addCollider(self.playerNP, self.playerPusher)
def __init__(self):
ShowBase.__init__(self)
self.keyMap = {
"up": False,
"down": False,
"left": False,
"right": False,
"shoot": False
}
self.base = base
self.boule_time = 0
base.setFrameRateMeter(True) # mesure le FPS
# Création du plateau de jeu
self.environment = loader.loadModel("./Environment/environment")
self.environment.reparentTo(render)
# Positionnement de la caméra
self.Cam_init()
# Réglages des éclairages
self.ambientLight = AmbientLight("ambient light")
self.Init_eclairage()
# Gestions des collisions avec les autres objets (MUR pour l'instant)
self.pusher = CollisionHandlerPusher()
# Pour la gestion de l'arbre de collisions
base.cTrav = CollisionTraverser()
# gestion des déplacements
self.Init_mvt()
# création du heros selon le modele ./fox/Fox
self.heros = Heros(self, Vec3(0, 0, 0), "./fox/Fox", {
"stand": "./fox/Fox-Idle_fp",
"walk": "./fox/Fox-Walk_fp"
}, 5, 10, "HEROS", 2)
self.heros.actor.reparentTo(render)
# création des objets de décors
self.tour1 = obj_inactifs(Vec3(12, 9, 1), "tour/tour", 0, "T1", 1)
self.tour1.obj.reparentTo(render)
self.tour2 = obj_inactifs(Vec3(-12, 9, 1), "tour/tour", 0, "T2", 1)
self.tour2.obj.reparentTo(render)
self.sorcier = obj_inactifs(Vec3(12, 9, 6), "sorcier/wizard", 130,
"SORCIER", 0.45)
self.sorcier.obj.reparentTo(render)
#init des armes
self.boule = Boule_feu(self)
# initialisation des déplacements
self.Init_mvt()
# initialisation des zones de collisions du decor
self.Init_coll()
# activation des évènements
self.updateTask = taskMgr.add(self.update, "update")
def setupCollision(self):
cs = CollisionSphere(0,0,2,1)
cnodePath = self.ralph.attachNewNode(CollisionNode('cnode'))
cnodePath.node().addSolid(cs)
cnodePath.show()
#for o in self.OBS:
#ct = CollisionTube(0,0,0, 0,0,1, 0.5)
#cn = o.attachNewNode(CollisionNode('ocnode'))
#cn.node().addSolid(ct)
#cn.show()
eyecs = CollisionSphere(0,0,4,5)
cnodePath = self.gianteye.attachNewNode(CollisionNode('cnode'))
cnodePath.node().addSolid(eyecs)
cnodePath.show()
eyecs = CollisionSphere(0,0,4,2)
cnodePath = self.chik.attachNewNode(CollisionNode('cnode'))
cnodePath.node().addSolid(eyecs)
cnodePath.show()
pusher = CollisionHandlerPusher()
pusher.addCollider(cnodePath, self.player)
self.cTrav = CollisionTraverser()
self.cTrav.add_collider(cnodePath,pusher)
self.cTrav.showCollisions(render)
def loadMainCharacter(self, mainCharModel):
# loads the main character object with specified model
self.tempActor = Actor(
mainCharModel, {
"walk":
"MorgansModels/shape-boi-grab-test-point_level2-ArmatureAction",
"lift":
"MorgansModels/shape-boi-grab-test-point_level2-IcosphereAction"
})
self.tempActor.reparentTo(render)
self.tempActor.setH(0)
self.tempActor.setPos(0, 54, -3)
self.tempActor.setScale(0.5, 0.5, 0.5)
self.tempActor.loop("walk")
#player 1
self.cTrav = CollisionTraverser()
self.pusher = CollisionHandlerPusher()
colliderNode = CollisionNode("player")
colliderNode.addSolid(CollisionSphere(0, 0, 1, 1.7))
collider = self.tempActor.attachNewNode(colliderNode)
#collider.show()
base.pusher.addCollider(collider, self.tempActor)
base.cTrav.addCollider(collider, self.pusher)
self.pusher.setHorizontal(True)
def test_collision_handler_pusher_pickle():
from panda3d.core import CollisionHandlerPusher
collider1 = NodePath(CollisionNode("collider1"))
collider2 = NodePath(CollisionNode("collider2"))
target1 = NodePath("target1")
target2 = NodePath("target2")
handler = CollisionHandlerPusher()
handler.add_again_pattern("again pattern")
handler.add_collider(collider1, target1)
handler.add_collider(collider2, target2)
handler.horizontal = True
handler = loads(dumps(handler, -1))
assert tuple(handler.in_patterns) == ()
assert tuple(handler.again_patterns) == ("again pattern", )
assert tuple(handler.out_patterns) == ()
assert not handler.has_center()
assert handler.horizontal
def __init__(self):
# self.load_assets()
base.cTrav = CollisionTraverser()
base.pusher = CollisionHandlerPusher()
base.groundHandler = CollisionHandlerQueue()
self.AIworld = AIWorld(render)
ConfigRender.__init__(self)
self.elapsedSeconds = 0
self.sound = ConfigSound()
self.rpgField = RPGField()
self.enemyData = EnemyModel()
self.itemData = ItemModel()
self.magicData = MagicModel()
self.cutsceneManager = CutsceneManager()
# print(PandaSystem.getVersionString())
self.load_fonts()
# this needs to be called only when game starts
taskMgr.add(self.updateTime, 'updateTime')
class PlayerController(DirectObject):
#-----------------
# Initialization
#-----------------
def __init__(self, engine, environment):
self.engine = engine
self.players = {}
self.environment = environment
self.inputQueue = deque()
self.collisionDummy = CollisionDummy()
self.inputPollWait = 0
self.playerCollisionHandler = CollisionHandlerPusher()
self.playerCollisionHandler.addCollider(self.collisionDummy.GetCollisionNode(), self.collisionDummy.GetNode())
self.playerCollisionTraverser = CollisionTraverser('playerCollisionTraverser')
self.playerCollisionTraverser.addCollider(self.collisionDummy.GetCollisionNode(), self.playerCollisionHandler)
#self.playerCollisionTraverser.showCollisions(render)
self.LoadServerPosDebug()
self.LoadMyself()
self.accept(ViewModeChangeEvent.EventName, self.OnViewModeChange)
self.accept(SelectedItemChangeEvent.EventName, self.OnSelectedItemChangeEvent)
self.accept(PlayerAttackEvent.EventName, self.OnPlayerAttackEvent)
self.accept(PlayerRespawnEvent.EventName, self.OnPlayerRespawnEvent)
self.accept(PlayerDeathEvent.EventName, self.OnPlayerDeathEvent)
self.accept(TeamSelectEvent.EventName, self.OnTeamSelectEvent)
if(not Settings.IS_SERVER):
self.sounds = {}
self.sounds['blockBreak'] = loader.loadSfx('Assets/Sounds/blockBreak.mp3')
self.sounds['blockPlace'] = loader.loadSfx('Assets/Sounds/blockPlace.mp3')
#-----------------------
# Game Updates / Ticks
#-----------------------
def FixedUpdate(self):
self.UpdatePlayer(self.GetMyself(), self.GetMyself().GetPlayerState(), self.engine.input, Globals.FIXED_UPDATE_DELTA_TIME)
def Update(self):
if(Settings.IS_SERVER):
# Move all of the players that we have input for
for elem in self.inputQueue:
self.ProcessInput(elem[0], elem[1])
self.inputQueue.clear()
# Check to see if anyone fell off the environment
self.CheckForFallingPlayers()
else:
self.GetMyself().UpdateLookingDirection(self.engine.camera.GetDirection())
for player in self.players.values():
player.GetPlayerOverheadName().Update()
if(Globals.OFFLINE):
self.CheckForFallingPlayers()
def CheckForFallingPlayers(self):
for player in self.players.values():
if(player.GetPlayerState().GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING):
if(player.GetPlayerState().GetValue(PlayerState.POSITION).getZ() < -10):
PlayerAttackEvent(player, player, 1000, False).Fire()
#--------------------
# Updating a player
#--------------------
def UpdatePlayer(self, player, playerState, playerInput, deltaTime):
if(playerState.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING_DEAD):
return
playerState = self.MovePlayer(player, playerState, playerInput, deltaTime)
player.SetPos(playerState.GetValue(PlayerState.POSITION))
playerState.UpdateValue(PlayerState.KEYS_PRESSED, playerInput.GetKeys())
self.HandleDeltaStates()
player.Update(deltaTime)
player.UpdateLookingRayDirection(playerInput.GetLookingDir())
playerState.UpdateValue(PlayerState.LOOKING_DIRECTION, playerInput.GetLookingDir())
if(playerState.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING):
self.PlayerInteraction(player, playerInput.click1, playerInput.click3)
def MovePlayer(self, player, playerState, playerInput, deltaTime):
if(playerState.HasValue(PlayerState.TIME_ELAPSED)):
timeElapsed = playerState.GetValue(PlayerState.TIME_ELAPSED)
else:
timeElapsed = 0
if(playerState.HasValue(PlayerState.Z_VELOCITY)):
zVelocity = playerState.GetValue(PlayerState.Z_VELOCITY)
else:
zVelocity = 0
startPos = playerState.GetValue(PlayerState.POSITION)
if(playerState.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING):
newPos = self.ApplyInput(playerState, Vec3(startPos), playerInput, timeElapsed, zVelocity, deltaTime)
elif(playerState.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_SPECTATE):
newPos = self.ApplySpectatorInput(playerState, Vec3(startPos), playerInput, timeElapsed, zVelocity, deltaTime)
playerState = self.EnvironmentCollisionCheck(self.environment, player, newPos, startPos, playerState)
return playerState
def ApplyInput(self, playerState, pos, playerInput, timeElapsed, zVelocity, deltaTime):
fDir = Vec3(0, 0, 0)
movementSpeed = 5
facingDirection = Vec3(playerInput.GetLookingDir())
facingDirection.setZ(0)
facingDirection.normalize()
keysPressed = playerInput.GetKeys()
# Apply input commands
for key in keysPressed:
if(key == Globals.KEY_FWD):
fDir += facingDirection
elif(key == Globals.KEY_BACK):
fDir -= facingDirection
elif(key == Globals.KEY_RIGHT):
strafePoint = facingDirection.cross(Globals.UP_VECTOR)
strafePoint.normalize()
fDir += strafePoint
elif(key == Globals.KEY_LEFT):
strafePoint = facingDirection.cross(Globals.UP_VECTOR)
strafePoint.normalize()
fDir -= strafePoint
elif(key == Globals.KEY_JUMP):
if(not playerState.HasValue(PlayerState.IS_GROUNDED)):
playerState.SetValue(PlayerState.IS_GROUNDED, True)
if(playerState.GetValue(PlayerState.IS_GROUNDED)):
timeElapsed = 0
zVelocity = 6.55
playerState.UpdateValue(PlayerState.Z_VELOCITY, 5)
playerState.UpdateValue(PlayerState.IS_GROUNDED, False)
# Calculate new position
fDir.normalize()
pos = pos + (fDir * movementSpeed * deltaTime)
#if(Settings.IS_SERVER or playerState.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING):
# Update timeElapsed (for gravity)
timeElapsed += deltaTime
playerState.UpdateValue(PlayerState.TIME_ELAPSED, timeElapsed)
# Figure out effect of gravity
dz = (zVelocity * timeElapsed + 0.5 * Settings.GRAVITY * timeElapsed * timeElapsed) - (zVelocity * (timeElapsed - deltaTime) + 0.5 * Settings.GRAVITY * (timeElapsed - deltaTime) * (timeElapsed - deltaTime))
pos.setZ(pos.getZ() + dz)
return pos
def ApplySpectatorInput(self, playerState, pos, playerInput, timeElapsed, zVelocity, deltaTime):
fDir = Vec3(0, 0, 0)
movementSpeed = 8
facingDirection = Vec3(playerInput.GetLookingDir())
facingDirection.normalize()
keysPressed = playerInput.GetKeys()
# Apply input commands
for key in keysPressed:
if(key == Globals.KEY_FWD):
fDir += facingDirection
elif(key == Globals.KEY_BACK):
fDir -= facingDirection
elif(key == Globals.KEY_RIGHT):
strafePoint = facingDirection.cross(Globals.UP_VECTOR)
strafePoint.normalize()
fDir += strafePoint
elif(key == Globals.KEY_LEFT):
strafePoint = facingDirection.cross(Globals.UP_VECTOR)
strafePoint.normalize()
fDir -= strafePoint
# Calculate new position
fDir.normalize()
pos = pos + (fDir * movementSpeed * deltaTime)
return pos
# Draws bullet tracers and bullet impacts with environment
def ShowShootingEffects(self, player):
lookingDir = player.GetPlayerState().GetValue(PlayerState.LOOKING_DIRECTION)
if(player.lookingRayCollisionEntry):
loc = player.lookingRayCollisionEntry.getSurfacePoint(render)
norm = player.lookingRayCollisionEntry.getSurfaceNormal(render)
if(player.lookingRayCollisionEntry.getIntoNodePath().getPythonTag(Globals.TAG_COLLISION) == Globals.COLLISION_BLOCK):
bid = player.lookingRayCollisionEntry.getIntoNodePath().getPythonTag(Globals.TAG_BLOCK).GetId()
BlockBulletMark(loc, norm, bid)
else:
BloodBulletMark(loc, norm, 0)
else:
loc = Point3(player.camNode.getPos(render) + lookingDir * 1000)
start = player.currentItem.GetPos(render) + Vec3(0, 0, -0.1) + lookingDir * 5
if((loc - start).lengthSquared() > 16):
BulletTracer(start, loc)
def OtherPlayerInteraction(self, player, click1, click3):
if(isinstance(player.currentItem, Firearm)):
player.currentItem.Use()
player.PerfromLookingRayCollision(False)
if(not Settings.IS_SERVER):
self.ShowShootingEffects(player)
def PlayerInteraction(self, player, click1, click3):
traversed = False
playerState = player.GetPlayerState()
playerState.SetValue(PlayerState.USED_ITEM, False)
currentItem = player.currentItem
if(isinstance(currentItem, Firearm)):
if(click1):
if(currentItem.CanUse()):
currentItem.Use()
currentItem.Used()
playerState.UpdateValue(PlayerState.USED_ITEM, True)
player.camNode.setP(player.camNode.getP() + currentItem.recoil)
player.camNode.setH(player.camNode.getH() + (0.5 - random.random()) * 2 * currentItem.recoil)
if(Settings.IS_SERVER):
self.MovePlayersToSnapshot(player, playerState.GetValue(PlayerState.CURRENT_SERVER_TIME) - playerState.GetValue(PlayerState.LAST_SERVER_TIME) + 2) # Add 2 to account for 100ms delay caused by lerping
player.PerfromLookingRayCollision()
if(Settings.IS_SERVER):
self.ReturnPlayersToCurrentPosition()
traversed = True
# Check for collision with player, if so, do damage
if(Settings.IS_SERVER):
if(player.lookingRayCollisionEntry):
np = player.lookingRayCollisionEntry.getIntoNodePath()
collisionTag = np.getPythonTag(Globals.TAG_COLLISION)
if(collisionTag != Globals.COLLISION_BLOCK):
victim = np.getPythonTag(Globals.TAG_PLAYER)
damage = currentItem.GetDamage()
hs = False
if(collisionTag == Globals.COLLISION_HEAD):
damage *= 1.25
hs = True
elif(collisionTag == Globals.COLLISION_LEG):
damage *= 0.75
# Either frindly fire is on, or the attacker and victim are on separate teams
if(Settings.FRIENDLY_FIRE or player.GetPlayerState().GetValue(PlayerState.TEAM) != victim.GetPlayerState().GetValue(PlayerState.TEAM)):
PlayerAttackEvent(player, victim, damage, hs).Fire()
if(not Settings.IS_SERVER):
self.ShowShootingEffects(player)
# Auto reload on the client
elif(not Settings.IS_SERVER and Settings.AUTO_RELOAD and currentItem.GetCurrentClipAmmo() == 0 and currentItem.GetTotalRemainingAmmo() > 0):
player.Reload()
if(click3):
if(not Settings.IS_SERVER):
currentItem.ToggleADS()
if(not traversed):
player.PerfromLookingRayCollision()
if(isinstance(currentItem, Builder)):
if(click1):
selectedBlock = player.GetSelectedBlock()
if(selectedBlock and currentItem.CanUse()):
playerState.UpdateValue(PlayerState.USED_ITEM, True)
self.environment.DestroyBlock(int(selectedBlock.getX()), int(selectedBlock.getY()), int(selectedBlock.getZ()))
currentItem.Used()
if(not Settings.IS_SERVER):
self.sounds['blockBreak'].play()
if(click3):
adjacentBlockPoint = player.GetAdjacentBlock()
if(adjacentBlockPoint and currentItem.CanUse()):
self.environment.AddBlock(int(adjacentBlockPoint.getX()), int(adjacentBlockPoint.getY()), int(adjacentBlockPoint.getZ()), currentItem.GetBlockId())
currentItem.Used()
if(not Settings.IS_SERVER):
self.sounds['blockPlace'].play()
def MovePlayersToSnapshot(self, currentPlayer, numFramesBack):
for player in self.players.values():
player.currentPosition = player.pNode.getPos()
if(player != currentPlayer and player.GetPlayerState().GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING):
player.MovePosToPriorSnapshot(numFramesBack)
def ReturnPlayersToCurrentPosition(self):
for player in self.players.values():
player.ReturnToCurrentPosition()
def IsColliding(self, player, x, y, z):
blocks = self.engine.GetEnvironment().GetBlocks()
blockPoss = [[x, y, z], [x+1, y, z], [x, y+1, z], [x-1, y, z], [x, y-1, z],
[x, y, z+1], [x+1, y, z+1], [x, y+1, z+1], [x-1, y, z+1], [x, y-1, z+1],
[x, y, z+2], [x+1, y, z+2], [x, y+1, z+2], [x-1, y, z+2], [x, y-1, z+2],
[x+1, y+1, z], [x-1, y+1, z], [x+1, y-1, z], [x-1, y-1, z],
[x+1, y+1, z+1], [x-1, y+1, z+1], [x+1, y-1, z+1], [x-1, y-1, z+1],
[x+1, y+1, z+2], [x-1, y+1, z+2], [x+1, y-1, z+2], [x-1, y-1, z+2]]
for (x1, y1, z1) in blockPoss:
if(self.engine.GetEnvironment().AreValidIndices(x1, y1, z1)):
if(blocks[x1][y1][z1].IsSolid() and player.boundingBox.IsCollidingWithBlock(x1, y1, z1)):
return True
return False
def EnvironmentCollisionCheck(self, environment, player, newPos, lastGoodPos, playerState):
x = int(lastGoodPos.getX())
y = int(lastGoodPos.getY())
z = int(lastGoodPos.getZ())
# Check Z component
z = int(newPos.getZ())
player.pNode.setZ(newPos.getZ())
if(self.IsColliding(player, x, y, z)):
player.pNode.setZ(player.pNode.getZ() + player.boundingBox.lastAxisCollisions[2])
z = int(player.pNode.getZ())
playerState.UpdateValue(PlayerState.TIME_ELAPSED, 0)
playerState.UpdateValue(PlayerState.Z_VELOCITY, 0)
if(newPos.getZ() < lastGoodPos.getZ()):
playerState.UpdateValue(PlayerState.IS_GROUNDED, True)
else:
playerState.UpdateValue(PlayerState.IS_GROUNDED, False)
# Check X component
x = int(newPos.getX())
player.pNode.setX(newPos.getX())
if(self.IsColliding(player, x, y, z)):
player.pNode.setX(player.pNode.getX() + player.boundingBox.lastAxisCollisions[0])
x = int(player.pNode.getX())
# Check Y component
y = int(newPos.getY())
player.pNode.setY(newPos.getY())
if(self.IsColliding(player, x, y, z)):
player.pNode.setY(player.pNode.getY() + player.boundingBox.lastAxisCollisions[1])
y = int(player.pNode.getY())
playerState.UpdateValue(PlayerState.POSITION, player.GetPos())
return playerState
#------------------------------
# Player Deaths and Respawning
#------------------------------
def OnPlayerRespawnEvent(self, event):
player = event.GetPlayer()
pos = self.engine.game.FindRespawnPoint(None)
playerState = player.GetPlayerState()
if(playerState):
playerState.UpdateValue(PlayerState.PLAYING_STATE, PlayerState.PS_PLAYING)
playerState.UpdateValue(PlayerState.POSITION, pos)
playerState.UpdateValue(PlayerState.HEALTH, 100)
player.ChangeItem(player.currentItem)
player.SetPos(pos)
self.RefillAllAmmo(player)
player.OnRespawn()
if(Settings.IS_SERVER):
self.engine.server.SendPlayerRespawn(playerState)
print 'player respawned', playerState.GetValue(PlayerState.NAME), playerState.GetValue(PlayerState.CURRENT_ITEM)
if(not Settings.IS_SERVER):
self.engine.scoreboard.UpdateIsAlive(playerState.GetValue(PlayerState.PID), True)
else:
del player
def OnPlayerDeathEvent(self, event):
victim = event.GetVictim()
attacker = event.GetAttacker()
wasHS = event.WasHeadshot()
playerState = victim.GetPlayerState()
playerState.UpdateValue(PlayerState.PLAYING_STATE, PlayerState.PS_PLAYING_DEAD)
print 'player Died', playerState.GetValue(PlayerState.NAME)
victim.OnDeath()
if(Settings.IS_SERVER or Globals.OFFLINE):
taskMgr.doMethodLater(Game.RESPAWN_TIME, PlayerRespawnEvent(victim, None).Fire, 'RespawnPlayer_%s' % (playerState.GetValue(PlayerState.PID)))
if(not Settings.IS_SERVER and victim == self.GetMyself()):
self.engine.respawnCountdown.Start()
if(not Settings.IS_SERVER):
self.engine.scoreboard.UpdateIsAlive(playerState.GetValue(PlayerState.PID), False)
#------------------------
# Client only functions
#------------------------
# This event only gets fired when our player selects a team
def OnTeamSelectEvent(self, event):
teamId = event.GetTeam()
self.GetMyself().OnTeamChange(teamId)
self.engine.scoreboard.UpdateTeam(Globals.MY_PID, Globals.MY_TEAM)
def VerifyPrediction(self, serverState, snapshots):
if(not serverState.HasValue(PlayerState.POSITION)):
return
if(Globals.DEBUG_CSP):
print 'SERVER', serverState.GetValue(PlayerState.TIMESTAMP), serverState.GetValue(PlayerState.POSITION)
print 'ME', snapshots[0].GetTimestamp(), snapshots[0].GetPosition()
for x in snapshots:
print 'SS', x.GetTimestamp(), x.GetPosition()
diff = (serverState.GetValue(PlayerState.POSITION) - snapshots[0].GetPosition())
if(diff.length() > 0.001):
print 'DIFF', diff
myself = self.GetMyself()
myState = myself.GetPlayerState()
for snapshot in snapshots:
serverState.SetValue(PlayerState.PLAYING_STATE, PlayerState.PS_PLAYING)
serverState = self.MovePlayer(myself, serverState, snapshot.GetInput(), Globals.FIXED_UPDATE_DELTA_TIME)
snapshot.pos = serverState.GetValue(PlayerState.POSITION)
myState.UpdateValue(PlayerState.POSITION, serverState.GetValue(PlayerState.POSITION))
myself.SetPos(serverState.GetValue(PlayerState.POSITION))
return snapshots
def HandleDeltaStates(self):
if(not Settings.IS_SERVER):
for player in self.players.values():
state = player.GetPlayerState()
deltaState = state.GetDeltaVars()
if(not Settings.IS_SERVER):
state.ClearDeltaVars()
for dVar in deltaState:
# If isWalking changed
if(dVar == PlayerState.IS_WALKING):
if(state.GetValue(dVar)): # If the player is now walking
player.RequestFSMTransition('IdleToWalk')
else: # If the player stopped moving
player.RequestFSMTransition('WalkToIdle')
# Given a dictionary of playerstate updates from the server,
# apply them to the players in the game
def HandleServerPlayerStates(self, playerStates):
for pid, playerState in playerStates.iteritems():
if(pid != self.GetMyId()):
if(not pid in self.players.keys()):
continue
player = self.GetPlayer(pid)
for pVar, value in playerState.vars.iteritems():
if(pVar == PlayerState.POSITION):
self.GetPlayerPlayerState(player).UpdateValue(PlayerState.POSITION, value)
player.LerpTo(value)
elif(pVar == PlayerState.LOOKING_DIRECTION):
self.GetPlayerPlayerState(player).UpdateValue(PlayerState.LOOKING_DIRECTION, value)
player.UpdateLookingDirection(value)
player.UpdateLookingRayDirection(value)
def OtherPlayerWalkingChange(self, player, isWalking):
if(isWalking):
player.RequestFSMTransition('IdleToWalk')
else:
player.RequestFSMTransition('WalkToIdle')
def HealthChange(self, player, health):
player.GetPlayerState().UpdateValue(PlayerState.HEALTH, health)
if(player == self.GetMyself()):
PlayerHealthEvent(player, health).Fire()
#------------------------
# Server only functions
#------------------------
def IsFull(self):
return len(self.players) > Globals.MAX_PLAYERS
def QueueClientInput(self, player, keys, lookingDir, clicks, timestamp):
newInput = Input(keys, lookingDir, clicks, timestamp)
self.inputQueue.append([player, newInput])
playerState = player.GetPlayerState()
playerState.timestamp = timestamp
return newInput
def ProcessInput(self, player, newInput):
if(player in self.players.values()):
playerInputBuffer = player.GetInputBuffer()
playerInputBuffer.UpdateInput(newInput)
if(playerInputBuffer.GoodToGo()):
newestInput = playerInputBuffer.GetNewestInput()
bufferedInput = playerInputBuffer.GetBufferedInput()
playerState = player.GetPlayerState()
playerState.UpdateValue(PlayerState.KEYS_PRESSED, bufferedInput.GetKeys())
if(playerState.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING):
# Run a Fixed MovementUpdate as many times as necessary
while(newestInput.GetTimestamp() - playerState.GetValue(PlayerState.TIMESTAMP) > Globals.FIXED_UPDATE_DELTA_TIME):
self.UpdatePlayer(player, playerState, bufferedInput, Globals.FIXED_UPDATE_DELTA_TIME)
playerState.SetValue(PlayerState.TIMESTAMP, playerState.GetValue(PlayerState.TIMESTAMP) + Globals.FIXED_UPDATE_DELTA_TIME)
#print 'processing input for player ', playerState.GetValue(PlayerState.PID)
else:
print 'spectator', playerState.GetValue(PlayerState.PID)
else:
player.GetPlayerState().SetValue(PlayerState.TIMESTAMP, newInput.GetTimestamp())
#---------------------------------------
# Adding and Removing Players from Game
#---------------------------------------
def AddNewPlayer(self, pid, name, teamId, playingState = PlayerState.PS_SPECTATE):
print 'adding new player', pid
if(pid not in self.players.keys()):
player = Player()
self.players[pid] = player
playerState = player.GetPlayerState()
playerState.SetValue(PlayerState.PID, pid)
playerState.SetValue(PlayerState.NAME, name)
playerState.SetValue(PlayerState.TEAM, teamId)
playerState.SetValue(PlayerState.PLAYING_STATE, playingState)
print 'added player', pid, name
player.CreateNameTextNode(name)
player.OnTeamChange(teamId)
player.ShowPlayerModel()
if(pid != Globals.MY_PID):
player.RemoveSelectionGeom()
if(teamId == Globals.MY_TEAM):
player.ShowNameAboveHead()
else:
player.HidePlayerModel()
def RemovePlayer(self, pid):
player = self.players[pid]
player.Destroy()
del self.players[pid]
taskMgr.remove('RespawnPlayer_%s' %(pid))
def HidePlayerModel(self, playerObject):
playerObject.HidePlayerModel()
def ShowPlayerModel(self, playerObject):
playerObject.ShowPlayerModel()
# THIS IS TEMPORARY
def RefillAllAmmo(self, player):
for item in player.itemModels.values():
if(isinstance(item, Firearm)):
item.RefillAmmo()
if(not Settings.IS_SERVER and player.GetPlayerState().GetValue(PlayerState.PID) == Globals.MY_PID):
inv = player.GetPlayerState().GetValue(PlayerState.MAIN_INVENTORY)
for itemStack in inv.GetItemStacks():
if(isinstance(itemStack.GetItem(), Firearm)):
itemStack.GetItem().RefillAmmo()
#--------------------
# Event Handling
#-----------------
def OnSelectedItemChangeEvent(self, event):
self.GetMyself().OnSelectedItemChangeEvent(event)
# Figure out what item the player now has. If they've had
# it before, use the already loaded model. Otherwise,
# load the model
def OtherPlayerItemChange(self, player, itemId, extraData = None):
itemClass = ItemId.ToItem(itemId)
#player.GetPlayerState().UpdateValue(PlayerState.CURRENT_ITEM, ItemId.NoItem)
#player.GetPlayerState().UpdateValue(PlayerState.CURRENT_ITEM, itemId)
if(itemId not in player.itemModels.keys()):
if(itemClass):
item = itemClass()
item.playerId = player.GetPlayerState().GetValue(PlayerState.PID)
else:
item = None
player.itemModels[itemId] = item
if(extraData):
print 'changing with extra data'
player.GetPlayerState().SetValue(PlayerState.CURRENT_ITEM, ItemId.Unknown)
player.GetPlayerState().UpdateValue(PlayerState.CURRENT_ITEM, itemId)
if(itemId == ItemId.Builder):
player.itemModels[itemId].SetBlockId(extraData[0])
if(not Settings.IS_SERVER):
player.itemModels[itemId].UpdateTexture()
#player.GetPlayerState().UpdateValue(PlayerState.CURRENT_ITEM, itemId)
player.ThirdPersonChangeItem(player.itemModels[itemId])
def OnViewModeChange(self, event):
if(event.GetViewMode() == Camera.FirstPersonMode):
self.GetMyself().HidePlayerModel()
else:
self.GetMyself().ShowPlayerModel()
def OnPlayerAttackEvent(self, event):
victim = event.GetVictim()
# Update the victim's health
health = victim.GetPlayerState().GetValue(PlayerState.HEALTH)
health = max(0, health - event.GetDamage())
victim.GetPlayerState().UpdateValue(PlayerState.HEALTH, health)
player = event.GetPlayer()
player.GetPlayerState().UpdateValue(PlayerState.VICTIM, victim)
if(event.WasHeadshot() and health == 0):
player.GetPlayerState().UpdateValue(PlayerState.VICTIM_ATTACK_TYPE, PlayerState.VAT_BOTH)
elif(event.WasHeadshot()):
player.GetPlayerState().UpdateValue(PlayerState.VICTIM_ATTACK_TYPE, PlayerState.VAT_HEADSHOT)
elif(health == 0):
player.GetPlayerState().UpdateValue(PlayerState.VICTIM_ATTACK_TYPE, PlayerState.VAT_KILLSHOT)
else:
player.GetPlayerState().UpdateValue(PlayerState.VICTIM_ATTACK_TYPE, PlayerState.VAT_NONE)
if(health == 0):
PlayerDeathEvent(victim, player, event.WasHeadshot()).Fire()
print 'PLAYER DIEEED'
def ResetPlayerNames(self):
for player in self.players.values():
if(player != self.GetMyself()):
if(player.GetPlayerState().GetValue(PlayerState.TEAM) != Globals.MY_TEAM):
# THIS IS REALLY BAD
player.nameText.reshowOnInView = False
player.nameText.Hide()
else:
player.nameText.reshowOnInView = True
player.ShowNameAboveHead()
#------------------------------------------------
# Getting Information for All Players
#------------------------------------------------
def GetAllPlayers(self):
return self.players.values()
def GetAllPlayerStates(self):
ps = []
for player in self.players.values():
ps.append(player.GetPlayerState())
return ps
def GetAllPlayingPlayerStates(self):
ps = []
for player in self.players.values():
ps1 = player.GetPlayerState()
if(ps1.GetValue(PlayerState.PLAYING_STATE) == PlayerState.PS_PLAYING):
ps.append(ps1)
return ps
def GetAllPlayerNodes(self):
nodes = []
for p in self.GetPlayers():
nodes.append(p.pNode)
return nodes
#------------------------------------------------
# Getting information for One Player
#------------------------------------------------
def GetPlayer(self, pid):
if(pid in self.players.keys()):
return self.players[pid]
else:
return None
def GetPlayerPlayerState(self, player, pid = None):
if(player is None):
return self.GetPlayerPlayerState(self.GetPlayer(pid))
else:
return player.GetPlayerState()
def GetPlayerPickerRay(self, player):
return player.lookingRay
def GetPlayerCollision(self, player):
return player.collisionGeom
def GetPlayerEyePosition(self, player):
return player.camNode.getPos(render)
def GetPlayerLookingDirection(self, player):
return player.lookingDirection
#------------------------------------------------
# Getting information for Myself
#------------------------------------------------
def GetMyself(self):
return self.players[Globals.MY_PID]
def GetMyId(self):
return Globals.MY_PID
def GetMyCamNode(self):
return self.GetMyself().camNode
def GetMyPlayerState(self):
return self.GetPlayerPlayerState(self.GetMyself())
def GetMyDeltaState(self):
return self.GetMyself().GetPlayerState().GetDeltaVars()
#--------------------------------------------------------
# Helper Functions for Setup of PlayerController Object
#--------------------------------------------------------
def LoadServerPosDebug(self):
self.serverPlayer = loader.loadModel('Assets/Models/Players/ralph')
self.serverPlayer.setScale(0.36)
self.serverPlayer.reparentTo(render)
if(not Globals.DEBUG_CSP):
self.serverPlayer.hide()
def LoadMyself(self):
print 'loading self'
if(not Settings.IS_SERVER):
self.AddNewPlayer(pid = Globals.MY_PID, name = Settings.NAME, teamId = Game.SPECTATE, playingState = PlayerState.PS_SPECTATE)
#-------------------------------------------------------------
# Helper Functions for Destruction of PlayerController Object
#-------------------------------------------------------------
def Destroy(self):
self.ignoreAll()
for player in self.players.values():
player.Destroy()
del self.players
del self.environment
del self.inputQueue
del self.collisionDummy
del self.inputPollWait
del self.playerCollisionHandler
del self.playerCollisionTraverser
class Physics:
def __init__(self):
self.rayCTrav = CollisionTraverser("collision traverser for ray tests")
#self.pusher = PhysicsCollisionHandler()
self.pusher = CollisionHandlerPusher()
self.pusher.addInPattern('%fn-in-%in')
self.pusher.addOutPattern('%fn-out-%in')
self.pusher.addInPattern('%fn-in')
self.pusher.addOutPattern('%fn-out')
def startPhysics(self):
#self.actorNode = ActorNode("playerPhysicsControler")
#base.physicsMgr.attachPhysicalNode(self.actorNode)
#self.actorNode.getPhysicsObject().setMass(self.player_mass)
#self.mainNode = render.attachNewNode(self.actorNode)
self.mainNode = render.attachNewNode("CharacterColliders")
self.reparentTo(self.mainNode)
charCollisions = self.mainNode.attachNewNode(CollisionNode(self.char_collision_name))
#charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/4.0, self.player_height/4.0))
#charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/4.0*3.05, self.player_height/4.0))
charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/2.0, self.player_height/4.0))
charCollisions.node().setIntoCollideMask(BitMask32(0x80)) # 1000 0000
if self.show_collisions:
charCollisions.show()
self.pusher.addCollider(charCollisions, self.mainNode)
base.cTrav.addCollider(charCollisions, self.pusher)
charFFootCollisions = self.attachNewNode(CollisionNode("floor_ray"))
charFFootCollisions.node().addSolid(CollisionRay(0, 0, 0.5, 0, 0, -1))
#charFFootCollisions.node().addSolid(CollisionSegment((0, 0, 0.2), (0, 0, -1)))
charFFootCollisions.node().setIntoCollideMask(BitMask32.allOff())
charFFootCollisions.node().setFromCollideMask(BitMask32(0x7f)) # 0111 1111
if self.show_collisions:
charFFootCollisions.show()
self.floor_handler = CollisionHandlerFloor()
self.floor_handler.addCollider(charFFootCollisions, self.mainNode)
#self.floor_handler.setOffset(0)
self.floor_handler.setMaxVelocity(5)
base.cTrav.addCollider(charFFootCollisions, self.floor_handler)
self.accept("{}-in".format(self.char_collision_name), self.checkCharCollisions)
self.raytest_segment = CollisionSegment(0, 1)
self.raytest_np = render.attachNewNode(CollisionNode("testRay"))
self.raytest_np.node().addSolid(self.raytest_segment)
self.raytest_np.node().setIntoCollideMask(BitMask32.allOff())
self.raytest_np.node().setFromCollideMask(BitMask32(0x7f)) # 0111 1111
if self.show_collisions:
self.raytest_np.show()
self.raytest_queue = CollisionHandlerQueue()
self.rayCTrav.addCollider(self.raytest_np, self.raytest_queue)
def stopPhysics(self):
self.raytest_segment.removeNode()
self.pusher.clearColliders()
self.floor_handler.clearColliders()
self.rayCTrav.clearColliders()
def updatePlayerPos(self, speed, heading, dt):
if heading is not None:
self.mainNode.setH(camera, heading)
self.mainNode.setP(0)
self.mainNode.setR(0)
self.mainNode.setFluidPos(self.mainNode, speed)
self.doStep()
def checkCharCollisions(self, args):
self.doStep()
def doStep(self):
# do the step height check
tmpNP = self.mainNode.attachNewNode("temporary")
tmpNP.setPos(self.mainNode, 0, 0, -self.stepheight)
pointA = self.mainNode.getPos(render)
pointA.setZ(pointA.getZ() + self.player_height/1.8)
pointB = tmpNP.getPos(render)
if pointA == pointB: return
char_step_collision = self.getFirstCollisionInLine(pointA, pointB)
tmpNP.removeNode()
if char_step_collision is not None:
self.mainNode.setFluidZ(char_step_collision.getZ())
return True
return False
def getFirstCollisionInLine(self, pointA, pointB):
"""A simple raycast check which will return the first collision point as
seen from point A towards pointB"""
self.raytest_segment.setPointA(pointA)
self.raytest_segment.setPointB(pointB)
self.rayCTrav.traverse(render)
self.raytest_queue.sortEntries()
pos = None
if self.raytest_queue.getNumEntries() > 0:
pos = self.raytest_queue.getEntry(0).getSurfacePoint(render)
return pos
class RoamingRalphDemo(ShowBase):
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0,
}
# Post the instructions
self.title = addTitle(
"Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.06, "[ESC]: Quit")
self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward")
self.inst5 = addInstructions(0.30, "[Down Arrow]: Walk Ralph Backward")
self.inst6 = addInstructions(0.36, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.42, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
# We do not have a skybox, so we will just use a sky blue background color
self.setBackgroundColor(0.53, 0.80, 0.92, 1)
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph",
{"run": "models/ralph-run",
"walk": "models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos + (0, 0, 1.5))
# Create a floater object, which floats 2 units above ralph. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(2.0)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("arrow_down", self.setKey, ["backward", True])
self.accept("a", self.setKey, ["cam-left", True])
self.accept("s", self.setKey, ["cam-right", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["backward", False])
self.accept("a-up", self.setKey, ["cam-left", False])
self.accept("s-up", self.setKey, ["cam-right", False])
taskMgr.add(self.move, "moveTask")
# Set up the camera
self.disableMouse()
self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
self.cTrav = CollisionTraverser()
# Use a CollisionHandlerPusher to handle collisions between Ralph and
# the environment. Ralph is added as a "from" object which will be
# "pushed" out of the environment if he walks into obstacles.
#
# Ralph is composed of two spheres, one around the torso and one
# around the head. They are slightly oversized since we want Ralph to
# keep some distance from obstacles.
self.ralphCol = CollisionNode('ralph')
self.ralphCol.addSolid(CollisionSphere(center=(0, 0, 2), radius=1.5))
self.ralphCol.addSolid(CollisionSphere(center=(0, -0.25, 4), radius=1.5))
self.ralphCol.setFromCollideMask(CollideMask.bit(0))
self.ralphCol.setIntoCollideMask(CollideMask.allOff())
self.ralphColNp = self.ralph.attachNewNode(self.ralphCol)
self.ralphPusher = CollisionHandlerPusher()
self.ralphPusher.horizontal = True
# Note that we need to add ralph both to the pusher and to the
# traverser; the pusher needs to know which node to push back when a
# collision occurs!
self.ralphPusher.addCollider(self.ralphColNp, self.ralph)
self.cTrav.addCollider(self.ralphColNp, self.ralphPusher)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height.
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 9)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0))
self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 9)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(CollideMask.bit(0))
self.camGroundCol.setIntoCollideMask(CollideMask.allOff())
self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
# Records the state of the arrow keys
def setKey(self, key, value):
self.keyMap[key] = value
# Accepts arrow keys to move either the player or the menu cursor,
# Also deals with grid checking and collision detection
def move(self, task):
# Get the time that elapsed since last frame. We multiply this with
# the desired speed in order to find out with which distance to move
# in order to achieve that desired speed.
dt = globalClock.getDt()
# If the camera-left key is pressed, move camera left.
# If the camera-right key is pressed, move camera right.
if self.keyMap["cam-left"]:
self.camera.setX(self.camera, -20 * dt)
if self.keyMap["cam-right"]:
self.camera.setX(self.camera, +20 * dt)
# If a move-key is pressed, move ralph in the specified direction.
if self.keyMap["left"]:
self.ralph.setH(self.ralph.getH() + 300 * dt)
if self.keyMap["right"]:
self.ralph.setH(self.ralph.getH() - 300 * dt)
if self.keyMap["forward"]:
self.ralph.setY(self.ralph, -20 * dt)
if self.keyMap["backward"]:
self.ralph.setY(self.ralph, +10 * dt)
# If ralph is moving, loop the run animation.
# If he is standing still, stop the animation.
currentAnim = self.ralph.getCurrentAnim()
if self.keyMap["forward"]:
if currentAnim != "run":
self.ralph.loop("run")
elif self.keyMap["backward"]:
# Play the walk animation backwards.
if currentAnim != "walk":
self.ralph.loop("walk")
self.ralph.setPlayRate(-1.0, "walk")
elif self.keyMap["left"] or self.keyMap["right"]:
if currentAnim != "walk":
self.ralph.loop("walk")
self.ralph.setPlayRate(1.0, "walk")
else:
if currentAnim is not None:
self.ralph.stop()
self.ralph.pose("walk", 5)
self.isMoving = False
# If the camera is too far from ralph, move it closer.
# If the camera is too close to ralph, move it farther.
camvec = self.ralph.getPos() - self.camera.getPos()
camvec.setZ(0)
camdist = camvec.length()
camvec.normalize()
if camdist > 10.0:
self.camera.setPos(self.camera.getPos() + camvec * (camdist - 10))
camdist = 10.0
if camdist < 5.0:
self.camera.setPos(self.camera.getPos() - camvec * (5 - camdist))
camdist = 5.0
# Normally, we would have to call traverse() to check for collisions.
# However, the class ShowBase that we inherit from has a task to do
# this for us, if we assign a CollisionTraverser to self.cTrav.
#self.cTrav.traverse(render)
# Adjust ralph's Z coordinate. If ralph's ray hit terrain,
# update his Z
entries = list(self.ralphGroundHandler.entries)
entries.sort(key=lambda x: x.getSurfacePoint(render).getZ())
for entry in entries:
if entry.getIntoNode().getName() == "terrain":
self.ralph.setZ(entry.getSurfacePoint(render).getZ())
# Keep the camera at one unit above the terrain,
# or two units above ralph, whichever is greater.
entries = list(self.camGroundHandler.entries)
entries.sort(key=lambda x: x.getSurfacePoint(render).getZ())
for entry in entries:
if entry.getIntoNode().getName() == "terrain":
self.camera.setZ(entry.getSurfacePoint(render).getZ() + 1.5)
if self.camera.getZ() < self.ralph.getZ() + 2.0:
self.camera.setZ(self.ralph.getZ() + 2.0)
# The camera should look in ralph's direction,
# but it should also try to stay horizontal, so look at
# a floater which hovers above ralph's head.
self.camera.lookAt(self.floater)
return task.cont
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0,
}
# Post the instructions
self.title = addTitle(
"Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.06, "[ESC]: Quit")
self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward")
self.inst5 = addInstructions(0.30, "[Down Arrow]: Walk Ralph Backward")
self.inst6 = addInstructions(0.36, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.42, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
# We do not have a skybox, so we will just use a sky blue background color
self.setBackgroundColor(0.53, 0.80, 0.92, 1)
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph",
{"run": "models/ralph-run",
"walk": "models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos + (0, 0, 1.5))
# Create a floater object, which floats 2 units above ralph. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(2.0)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("arrow_down", self.setKey, ["backward", True])
self.accept("a", self.setKey, ["cam-left", True])
self.accept("s", self.setKey, ["cam-right", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["backward", False])
self.accept("a-up", self.setKey, ["cam-left", False])
self.accept("s-up", self.setKey, ["cam-right", False])
taskMgr.add(self.move, "moveTask")
# Set up the camera
self.disableMouse()
self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
self.cTrav = CollisionTraverser()
# Use a CollisionHandlerPusher to handle collisions between Ralph and
# the environment. Ralph is added as a "from" object which will be
# "pushed" out of the environment if he walks into obstacles.
#
# Ralph is composed of two spheres, one around the torso and one
# around the head. They are slightly oversized since we want Ralph to
# keep some distance from obstacles.
self.ralphCol = CollisionNode('ralph')
self.ralphCol.addSolid(CollisionSphere(center=(0, 0, 2), radius=1.5))
self.ralphCol.addSolid(CollisionSphere(center=(0, -0.25, 4), radius=1.5))
self.ralphCol.setFromCollideMask(CollideMask.bit(0))
self.ralphCol.setIntoCollideMask(CollideMask.allOff())
self.ralphColNp = self.ralph.attachNewNode(self.ralphCol)
self.ralphPusher = CollisionHandlerPusher()
self.ralphPusher.horizontal = True
# Note that we need to add ralph both to the pusher and to the
# traverser; the pusher needs to know which node to push back when a
# collision occurs!
self.ralphPusher.addCollider(self.ralphColNp, self.ralph)
self.cTrav.addCollider(self.ralphColNp, self.ralphPusher)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height.
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 9)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0))
self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 9)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(CollideMask.bit(0))
self.camGroundCol.setIntoCollideMask(CollideMask.allOff())
self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
messenger.toggleVerbose()
ShowBase.__init__(self)
self.environ = self.loader.loadModel("models/falcon")
self.environ.reparentTo(self.render)
self.environ.setScale(0.25, 0.25, 0.25)
self.environ.setPos(-8, 42, 0)
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
self.taskMgr.add(self.moveCameraTask, "MoveCameraTask")
self.taskMgr.add(self.playerGravity, "PlayerGravity")
#self.taskMgr.add(self.collTask, "CollisionTask")
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
self.pandaActor.setPos(0, 0, 10)
self.pandaActor.reparentTo(self.render)
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
self.cTrav.showCollisions(self.render)
# Initialize the Pusher collision handler.
pusher = CollisionHandlerPusher()
# Create a collision node for this object.
cNode = CollisionNode('panda')
# Attach a collision sphere solid to the collision node.
cNode.addSolid(CollisionSphere(0, 0, 0, 600))
# Attach the collision node to the object's model.
pandaC = self.pandaActor.attachNewNode(cNode)
# Set the object's collision node to render as visible.
pandaC.show()
# Create a collsion node for this object.
cNode = CollisionNode('environnement')
# Attach a collision sphere solid to the collision node.
cNode.addSolid(CollisionSphere(-1.3, 19, 0.5, 2.5))
cNode.addSolid(CollisionPlane(Plane(Vec3(0,0,1), Point3(0,0,0.2))))
# Attach the collision node to the object's model.
environC = self.environ.attachNewNode(cNode)
# Set the object's collision node to render as visible.
environC.show()
# Add the Pusher collision handler to the collision traverser.
self.cTrav.addCollider(pandaC, pusher)
# Add the 'frowney' collision node to the Pusher collision handler.
pusher.addCollider(pandaC, self.environ, base.drive.node())
fromObject = self.pandaActor.attachNewNode(CollisionNode('colNode'))
fromObject.node().addSolid(CollisionRay(0, 0, 0, 0, 0, -1))
lifter = CollisionHandlerFloor()
lifter.addCollider(fromObject, self.pandaActor)
self.cTrav.addCollider(pandaC, lifter)
# Have the 'smiley' sphere moving to help show what is happening.
#frowney.posInterval(5, Point3(5, 25, 0), startPos=Point3(-5, 25, 0), fluid=1).loop()
#self.stuff = Actor("models/panda-model")
#self.stuff.setScale(0.005, 0.005, 0.005)
#self.stuff.setPos(-1.3, 19., 0.5)
#self.stuff.reparentTo(self.render)
# cTrav = CollisionTraverser()
# ceh = CollisionHandlerQueue()
# #ceh.addInPattern('%fn-into-%in')
# #ceh.addAgainPattern('%fn-again-%in')
# #ceh.addOutPattern('%fn-outof-%in')
# self.pandaColl = self.pandaActor.attachNewNode(CollisionNode('cnode'))
# self.pandaColl.node().addSolid(CollisionSphere(self.pandaActor.getChild( 0 ).getBounds( ).getCenter(), 400))
# self.pandaColl.show()
# cTrav.addCollider( self.pandaColl, ceh )
# self.cTrav = cTrav
# self.cTrav.showCollisions(self.render)
# self.queue = ceh
# cs = CollisionSphere(-1.3, 19, 0.5, 2.5)
# pl = CollisionPlane(Plane(Vec3(0,0,1), Point3(0,0,0.2)))
# # ray = CollisionRay(self.pandaActor.getPos(), Vec3(0,0,-1))
# cnodePath = self.render.attachNewNode(CollisionNode('cnode'))
# # rayNodePath = self.render.attachNewNode(CollisionNode('raynode'))
# cnodePath.node().addSolid(cs)
# cnodePath.node().addSolid(pl)
# # rayNodePath.node().addSolid(ray)
# cnodePath.show()
# # rayNodePath.show()
# #rayNodePath.reparentTo(self.pandaActor)
#self.accept('car-into-rail', handleRailCollision)
#cTrav.addCollider(cnodePath, ceh)
self.camera.reparentTo(self.pandaActor)
self.camera.setPos(0., 1050., 1000.)
self.camAlpha = 180
self.camBeta = 0
self.moving = []
self.playerAltitude = 0
self.jumping = False
self.inJump = False
self.playerFallingSpeed = 0
self.player = Mass(80)
base.useDrive()
#base.disableMouse( ) # disable the default camera controls that are created for us
self.keyBoardSetup()
class RoamingRalphDemo(ShowBase):
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
self.orbCollisionHandler = CollisionHandlerQueue()
self.cTrav = CollisionTraverser()
self.cTrav.setRespectPrevTransform(True)
self.startgame = False
self.sound=loader.loadSfx("models/0614.ogg")
self.sound2=loader.loadSfx("models/01-main-theme.mp3")
self.sound2.play()
status=self.sound2.status()
#hbPath = NodePath()
utils.setUpKeys(self)
utils.loadModels(self)
utils.setUpLighting(self)
#utils.setUpFloatingSpheres(self)
utils.setUpRalphsShot(self)
utils.setUpCamera(self)
utils.setUpCollisionSpheres(self)
self.healthTxt = utils.addInstructions(.06,"Health: 100")
self.orbTxt = utils.addInstructions(.18,"Orbs: 0")
self.hitsTxt = utils.addInstructions(.28,"Enemy Hits: 0")
self.strHealthStatus = str(self.healthTxt)
# Create a frame
frame = DirectFrame(text = "main", scale = 0.001)
# Add button
self.flagstartbutton = 0
self.imageObject = OnscreenImage(image = 'models/instapage.jpg', pos = (0, 0, 0), scale=1.1)
self.imageObject2 = OnscreenImage(image = 'models/gap.jpg', pos = (-2.15, 0, 0), scale=1.1)
self.imageObject3 = OnscreenImage(image = 'models/gap.jpg', pos = (2.15, 0, 0), scale=1.1)
self.helpOn = DirectButton(text = ("Start", "on/off", "Start", "disabled"), scale=.10, pos=(-1.1,0,-.9), command=utils.buttonClickedOn, extraArgs=[self, self.imageObject,self.imageObject2,self.imageObject3, self.flagstartbutton])
#helpOff = DirectButton(text = ("helpOff", "on/off", "helpOff", "disabled"), scale=.10, pos=(-0.5,0,-1), command=utils.buttonClickedOff, extraArgs=[self, self.imageObject, self.buttonflag])
# mytimer = DirectLabel()
# mytimer.reparentTo(render)
# mytimer.setY(7)
#Create 4 buttons
#print self.strHealthStatus
#incBar(100)
self.vec = LVector3(0,1,0)#vector for pawns shot
# Create a frame
#frame = DirectFrame(text = "main", scale = 0.001)
# Add button
#bar = DirectWaitBar(text = "", value = 50, pos = (0,.4,.4))
#bar.reparent(render)
# Game state variables
self.isMoving = False
self.jumping = False
self.vz = 0
self.numOrbs = 0
self.healthCount = 100
self.enemyhits = 0
#self.shotList = []
#self.sphere = CollisionBox((self.ralph.getX() + -10,self.ralph.getY(),self.ralph.getZ()),10,10,10)
self.ralphBox1 = CollisionBox((0,2.5,3.5),1.5,0.5,1.5)
cnodepath = self.ralph.attachNewNode((CollisionNode("ralphColNode")))
cnodepath.node().addSolid(self.ralphBox1)
cnodepath.node().addSolid(CollisionBox((0,-2.5,3.5),1.5,0.5,1.5))
cnodepath.node().addSolid(CollisionBox((2.5,0,3.5),0.5,1.5,1.5))
cnodepath.node().addSolid(CollisionBox((-2.5,0,3.5),0.5,1.5,1.5))
#cnodepath.show()
#self.cTrav.addCollider(cnodepath, self.orbCollisionHandler)
self.sphere = CollisionSphere(0,-5,4,3)
self.sphere3 = CollisionSphere(0,5,5,3)
self.sphere4 = CollisionSphere(-4,0,5,2)
self.sphere5 = CollisionSphere(4,0,5,2)
self.sphere2 = CollisionSphere(0,0,3,2)
self.cnodePath = self.ralph.attachNewNode((CollisionNode("ralphColNode")))
self.cnodePath2 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck")))
self.cnodePath3 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck2")))
self.cnodePath4 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck3")))
self.cnodePath5 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck4")))
self.cnodePath.node().addSolid(self.sphere2)
self.cnodePath2.node().addSolid(self.sphere)
self.cnodePath3.node().addSolid(self.sphere3)
self.cnodePath4.node().addSolid(self.sphere4)
self.cnodePath5.node().addSolid(self.sphere5)
#self.cnodePath.node().addSolid(self.sphere2)
#self.cnodePath.show()#ralph pusher
#self.cnodePath2.show()
#self.cnodePath3.show()
#self.cnodePath4.show()
#self.cnodePath5.show()
self.cTrav.addCollider(self.cnodePath2, self.orbCollisionHandler)
self.cTrav.addCollider(self.cnodePath3, self.orbCollisionHandler)
self.cTrav.addCollider(self.cnodePath4, self.orbCollisionHandler)
self.cTrav.addCollider(self.cnodePath5, self.orbCollisionHandler)
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(self.cnodePath, self.ralph)
#self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler)
self.cTrav.addCollider(self.cnodePath, self.pusher)
self.chrisLastShotTime = globalClock.getFrameTime()
self.chrisTimer = globalClock.getDt()
#def __init__(self, pos,showbase, colPathName, dir, length):
self.chrisList = [utils.cheken((-249,419,0),self,"chrisColPath0","X",5), #earthroom
utils.chris((-404,343,2),self,"chrisColPath1","X",5), #yellowroom
utils.fetus((-141,-69,1),self,"chrisColPath2","X",5), #lightblueroom
utils.cheken((-277,356,0),self,"chrisColPath3","Y",5), #between earth and y
utils.rose((-102,-5,1),self,"chrisColPath4","Y",5), #between r and lb
utils.cheken((-133,83,0),self,"chrisColPath5","Y",5), #blue hall
utils.fetus((-246,280,1),self,"chrisColPath6","X",5), #earth hall
utils.cheken((-330,241,0),self,"chrisColPath7","X",5), #yellow hall
utils.chris((-60,110,2),self,"chrisColPath8","Y",5), #red hall cheken z 0
utils.fetus((-75,52,1),self, "chrisColPath9", "X", 5),
utils.cheken((-75,141,0),self, "chrisColPath10", "X", 5),
utils.rose((-302,202,1),self,"chrisColPath11","X",5),
utils.chris((-303,304,2),self,"chrisColPath12","Y",5)
]
#rose z = 1
#cheken z = 0
#chris z = 2
#fetus z = 1
#def _init_(self,showbase,pos,color,speed,radius):
self.orbList = [utils.orb(self,( 18, 29,2.5),(1,0,0,1),20,2.5), #first red
utils.orb(self,( -249, 419,2.5),(1,1,1,1),20,2.5),#earthroom
utils.orb(self,( -404, 343,2.5),(1,1,0,1),20,2.5), #yellowroom
utils.orb(self,( -141, -69,2.5),(0,0,1,1),20,2.5),#light blue room
utils.orb(self,( -277, 356,2.5),(1,1,0,1),20,2.5), #between y and earth
utils.orb(self,( -102, -5,2.5),(0,0,1,1),20,2.5), #between red and lb
utils.orb(self,( -135, 22,2.5),(0,0,1,1),20,2.5), #lb hall
utils.orb(self,( -248, 329,2.5),(1,1,1,1),20,2.5), #earthhall
utils.orb(self,( -330, 241,2.5),(1,1,0,1),20,2.5), #yellow hall
utils.orb(self,( -60, 110,2.5),(1,0,0,1),20,2.5) #red hall
]
self.donutList = [utils.donut(self, (0,0,1),20, 2.5),
utils.donut(self,( -330, 250,2.5),20,2.5), #yellow hall
utils.donut(self,( -141, -80,2.5),20,2.5),#light blue room
utils.donut(self,( -249, 430,2.5),20,2.5),#earthroom
utils.donut(self,( -102, -10,2.5),20,2.5), #between red and lb
]
self.cameraCollided = False
self.ralphSpeed = 60
self.ralphHit = False
self.ralphRedTime = 0
self.textTime = -1
self.textTime2 = -1
self.textTime3 = -1
self.mTextPath = utils.addInstructions2(.44,"")
self.mTextPath2 = utils.addInstructions2(.55,"")
self.winText2 = utils.addInstructions2(.55, "")
self.timerText = utils.addInstructions4(.26,"0:00")
self.introText = utils.addInstructions2(.55,"")
self.minutes = 4
self.seconds = 0
self.timerTime = globalClock.getFrameTime()
taskMgr.add(self.move, "moveTask")
taskMgr.add(self.moveChris,"moveChrisTask")
taskMgr.add(self.timerTask,"timerTask")
#taskMgr.add(self.timerTask, "timerTask")
# Records the state of the arrow keys
def setKey(self, key, value):
self.keyMap[key] = value
def clickResponse():
pass
#startgame=1;
def timerTask(self,task):
if self.startgame == False:
return task.cont
dt = globalClock.getFrameTime()
if dt - self.timerTime > 1:
self.seconds -= 1
if self.seconds == -1:
self.seconds = 59
self.minutes -=1
self.timerText.destroy()
if self.seconds < 10:
str1 = "0" + str(self.minutes) + ":0" + str(self.seconds)
else:
str1 = "0" + str(self.minutes) + ":" + str(self.seconds)
self.timerText = utils.addInstructions4(.26,str1)
self.timerTime = globalClock.getFrameTime() - ((dt - self.timerTime) - 1)
if self.minutes == 0 and self.seconds == 0:
self.startgame = False
#utils.addInstructions3(.45,"You Lose")
self.imageObject2 = OnscreenImage(image = 'models/gameover.jpg', pos = (0, 0, 0), scale=1.1)
self.imageObject2 = OnscreenImage(image = 'models/gap.jpg', pos = (-2.15, 0, 0), scale=1.1)
self.imageObject3 = OnscreenImage(image = 'models/gap.jpg', pos = (2.15, 0, 0), scale=1.1)
return task.cont
def moveChris(self,task):
if self.startgame == False:
return task.cont
else:
dt = globalClock.getDt()
self.gianteye.setH(self.gianteye.getH() + 100 * dt)
for chris in self.chrisList:
chris.moveChris(dt,self,self.chrisList)
return task.cont
# Accepts arrow keys to move either the player or the menu cursor,
# Also deals with grid checking and collision detection
def move(self, task):
if self.sound2.status() != self.sound2.PLAYING:
self.sound2.play()
if self.startgame == False:
return task.cont
else:
# Get the time that elapsed since last frame. We multiply this with
# the desired speed in order to find out with which distance to move
# in order to achieve that desired speed.
dt = globalClock.getDt()
dt2 = globalClock.getFrameTime()
#utils.moveChris(self,dt)
#self.chris2.moveChris(dt,self)
#self.startEnemyThread()
if dt2 - self.textTime > 2 and self.textTime != -1:
self.textTime = -1;
self.mTextPath.destroy()
if dt2 - self.textTime2 > 2 and self.textTime2 != -1:
self.textTime2 = -1;
self.mTextPath2.destroy()
if dt2 - self.textTime3 > 5 and self.textTime3 != -1:
self.textTime3 = -1;
self.introText.destroy()
if globalClock.getFrameTime()- self.ralphRedTime > .3 and self.ralphHit == True:
self.ralph.clearColor()
self.ralphHit = False
# If the camera-left key is pressed, move camera left.
# If the camera-right key is pressed, move camera right.
if self.keyMap["cam-left"]:
self.camera.setZ(self.camera, -20 * dt)
if self.keyMap["cam-right"]:
self.camera.setZ(self.camera, +20 * dt)
# save ralph's initial position so that we can restore it,
# in case he falls off the map or runs into something.
startpos = self.ralph.getPos()
# If a move-key is pressed, move ralph in the specified direction.
if self.keyMap["left"]:
self.ralph.setH(self.ralph.getH() + 75 * dt)
#self.camera.setX(self.camera, +15.5 * dt)
if self.keyMap["right"]:
self.ralph.setH(self.ralph.getH() - 75 * dt)
#self.camera.setX(self.camera, -15.5 * dt)
if self.keyMap["forward"]:#-1
self.ralph.setFluidY(self.ralph, -1*self.ralphSpeed * dt)
#self.camera.setY(self.camera, -35 * dt)
if self.keyMap["back"]:
self.ralph.setFluidY(self.ralph, self.ralphSpeed * dt)
#self.camera.setY(self.camera, 35 * dt)
if self.keyMap["space"]:
if self.jumping is False:
#self.ralph.setZ(self.ralph.getZ() + 100 * dt)
self.jumping = True
self.vz = 8
if self.keyMap["enter"]:
self.keyMap["enter"] = False
self.sound.play()
self.shotList[self.shotCount].lpivot.setPos(self.ralph.getPos())
self.shotList[self.shotCount].lpivot.setZ(self.ralph.getZ() + .5)
self.shotList[self.shotCount].lpivot.setX(self.ralph.getX() - .25)
print self.ralph.getPos()
#self.shotList.append(rShot)
#self.lightpivot3.setPos(self.ralph.getPos())
#self.lightpivot3.setZ(self.ralph.getZ() + .5)
#self.lightpivot3.setX(self.ralph.getX() - .25)
#self.myShot.setHpr(self.ralph.getHpr())
#parent to ralph
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(0,-1,0))
#self.myShotVec = vec
node = NodePath("tmp")
node.setHpr(self.ralph.getHpr())
vec = render.getRelativeVector(node,(0,-1,0))
self.shotList[self.shotCount].vec = vec
self.shotCount = (self.shotCount + 1) % 10
else:
self.sound.stop()
for rs in self.shotList:
rs.lpivot.setPos(rs.lpivot.getPos() + rs.vec * dt * 25 )
#if shot is too far stop updating
if self.jumping is True:
self.vz = self.vz - 16* dt
self.ralph.setZ(self.ralph.getZ() + self.vz * dt )
if self.ralph.getZ() < 0:
self.ralph.setZ(0)
self.jumping = False
else:
if self.ralph.getZ() < 0.25:
self.ralph.setZ(0.25)
elif self.ralph.getZ() > 0.25:
self.ralph.setZ(self.ralph.getZ() -7 * dt)
# If ralph is moving, loop the run animation.
# If he is standing still, stop the animation.
if self.keyMap["forward"] or self.keyMap["left"] or self.keyMap["right"] or self.keyMap["space"] or self.keyMap["forward"] or self.keyMap["back"]:
if self.isMoving is False:
self.ralph.loop("run")
self.isMoving = True
else:
if self.isMoving:
self.ralph.stop()
self.ralph.pose("walk", 5)
self.isMoving = False
# update pawns shot or set up new shot after it reaches a certain distance
node = NodePath("tmp")
node.setHpr(self.pawn.getHpr())
vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0))
self.shot.setPos(self.shot.getPos() + self.vec * dt * 10 )
if self.shot.getY() < -15 or self.shot.getY() > 30 or self.shot.getX() < 5 or self.shot.getX() > 15:
self.shot.setPos(self.pawn.getPos() + (0,0,0))
self.vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0))
self.vec = render.getRelativeVector(node,(random.random() * random.randrange(-1,2),random.random() + 1,0))
# If the camera is too far from ralph, move it closer.
# If the camera is too close to ralph, move it farther.
#self.camera.lookAt(self.floater)
camvec = self.ralph.getPos() - self.camera.getPos()
#camvec = Vec3(0,camvec.getY(),0)
camdist = camvec.length()
x = self.camera.getZ()
camvec.normalize()
#if camdist > 6.0:
# self.camera.setPos(self.camera.getPos() + camvec * (camdist - 6))
#if camdist < 6.0:
# self.camera.setPos(self.camera.getPos() - camvec * (6 - camdist))
# Normally, we would have to call traverse() to check for collisions.
# However, the class ShowBase that we inherit from has a task to do
# this for us, if we assign a CollisionTraverser to self.cTrav.
#self.cTrav.traverse(render)
# Adjust camera so it stays at same height
if self.cameraCollided == False:
if self.camera.getZ() < self.ralph.getZ() + 1 or self.camera.getZ() > self.ralph.getZ() + 1:
self.camera.setZ(self.ralph.getZ() + 1)
# The camera should look in ralph's direction,
# but it should also try to stay horizontal, so look at
# a floater which hovers above ralph's head.
self.camera.lookAt(self.floater)
entries = list(self.orbCollisionHandler.getEntries())
if(len(entries) > 0):
#self.lightpivot.reparentTo(NodePath())
orbCollected = False
self.cameraCollided = False
self.ralphSpeed = 85
ralphHit = False
for entry in self.orbCollisionHandler.getEntries():
#print(entry)
fromColNp = entry.getFromNodePath()
toColNp = entry.getIntoNodePath()
if fromColNp.getName() == "orbColPath" and toColNp.getName() == "ralphColNode":
if orbCollected == False:
fromColNp.getParent().reparentTo(NodePath())
self.orbTxt.destroy()
self.numOrbs += 1
str1 = "Orbs: " + str(self.numOrbs)
self.orbTxt = utils.addInstructions(.18, str1)
orbCollected = True
elif toColNp.getName() == "orbColPath" and fromColNp.getName() == "ralphColNode":
if orbCollected == False:
toColNp.getParent().reparentTo(NodePath())
self.orbTxt.destroy()
self.numOrbs += 1
str1 = "Orbs: " + str(self.numOrbs)
self.orbTxt = utils.addInstructions(.18, str1)
orbCollected = True
elif fromColNp.getName() == "donutCollisionNode" and toColNp.getName() == "ralphColNode":
fromColNp.getParent().reparentTo(NodePath())
self.healthCount += 15
if(self.healthCount > 100):
self.healthCount = 100
self.healthTxt.destroy()
str1 = "Health: " + str(self.healthCount)
self.healthTxt = utils.addInstructions(.06, str1)
elif toColNp.getName() == "donutCollisionNode" and fromColNp.getName() == "ralphColNode":
toColNp.getParent().reparentTo(NodePath())
self.healthCount += 15
if(self.healthCount > 100):
self.healthCount = 100
self.healthTxt.destroy()
str1 = "Health: " + str(self.healthCount)
self.healthTxt = utils.addInstructions(.06, str1)
elif toColNp.getName() == "ralphOrbColPath" and (fromColNp.getName()[:-1] == "chrisColPath" or fromColNp.getName()[:-2] == "chrisColPath"):
toColNp.getParent().setZ(20)
for chriss in self.chrisList:
if chriss.chrisColName == fromColNp.getName():
chris = chriss
break
chris.chrisHealth = chris.chrisHealth - 1
chris.chris.setColor(1,0,0,1)
chris.chrisHit = True
chris.chrisRedTime = globalClock.getFrameTime()
#print chris.chrisRedTime
if chris.chrisHealth < 0 and chris.chrisAlive == True:
fromColNp.getParent().removeNode()
chris.chrisAlive = False
self.hitsTxt.destroy()
self.enemyhits += 1
str1 = "Enemy Hits: " + str(self.enemyhits)
self.hitsTxt = utils.addInstructions(.28, str1)
chris.chrisShot.setZ(26)
elif (toColNp.getName()[:-1] == "chrisColPath" or toColNp.getName()[:-2] == "chrisColPath") and fromColNp.getName() == "ralphOrbColPath":
fromColNp.getParent().setZ(20)
for chriss in self.chrisList:
if chriss.chrisColName == toColNp.getName():
chris = chriss
break
chris.chrisHealth = chris.chrisHealth - 1
chris.chris.setColor(1,0,0,1)
chris.chrisHit = True
chris.chrisRedTime = globalClock.getFrameTime()
#print chris.chrisRedTime
if chris.chrisHealth < 0 and chris.chrisAlive == True:
toColNp.getParent().removeNode()
chris.chrisAlive = False
self.hitsTxt.destroy()
self.enemyhits += 1
str1 = "Enemy Hits: " + str(self.enemyhits)
self.hitsTxt = utils.addInstructions(.28, str1)
chris.chrisShot.setZ(26)
elif toColNp.getName() == "enemyOrbColPath" and fromColNp.getName() == "ralphColNode":
if ralphHit == False:
toColNp.getParent().setZ(26)
self.healthTxt.destroy()
self.healthCount -= 5
str1 = "Health: " + str(self.healthCount)
self.healthTxt = utils.addInstructions(.06, str1)
self.ralphHit = True
self.ralph.setColor((1,0,0,1))
self.ralphRedTime = globalClock.getFrameTime()
if self.healthCount <= 0:
self.startgame = False
#utils.addInstructions3(.45,"You Lose")
self.imageObject2 = OnscreenImage(image = 'models/gameover.jpg', pos = (0, 0, 0), scale=1.1)
self.imageObject2 = OnscreenImage(image = 'models/gap.jpg', pos = (-2.15, 0, 0), scale=1.1)
self.imageObject3 = OnscreenImage(image = 'models/gap.jpg', pos = (2.15, 0, 0), scale=1.1)
elif toColNp.getName() == "ralphColNode" and fromColNp.getName() == "enemyOrbColPath":
fromColNp.getParent().setZ(26)
if ralphHit == False:
self.healthTxt.destroy()
self.healthCount -= 5
str1 = "Health: " + str(self.healthCount)
self.healthTxt = utils.addInstructions(.06, str1)
self.ralphHit = True
self.ralph.setColor((1,0,0,1))
self.ralphRedTime = globalClock.getFrameTime()
ralphHit = True
if self.healthCount <= 0:
self.startgame = False
#utils.addInstructions3(.45,"You Lose")
self.imageObject2 = OnscreenImage(image = 'models/gameover.jpg', pos = (0, 0, 0), scale=1.1)
self.imageObject2 = OnscreenImage(image = 'models/gap.jpg', pos = (-2.15, 0, 0), scale=1.1)
self.imageObject3 = OnscreenImage(image = 'models/gap.jpg', pos = (2.15, 0, 0), scale=1.1)
elif toColNp.getName() == "ralphColNode" and fromColNp.getName() == "portalColPath":
if self.numOrbs < 3 and self.enemyhits < 4:
self.mTextPath.destroy()
self.mTextPath = utils.addInstructions2(.30, "Not enough orbs.")
self.textTime = globalClock.getFrameTime()
self.mTextPath2.destroy()
self.mTextPath2 = utils.addInstructions2(.45, "Not enough kills.")
self.textTime2 = globalClock.getFrameTime()
elif self.numOrbs < 3:
self.mTextPath.destroy()
self.mTextPath = utils.addInstructions2(.30, "Not enough orbs.")
self.textTime = globalClock.getFrameTime()
elif self.enemyhits < 4:
self.mTextPath2.destroy()
self.mTextPath2 = utils.addInstructions2(.45, "Not enough kills.")
self.textTime2 = globalClock.getFrameTime()
else:
self.winText = utils.addInstructions3(.45, "You Win")
self.startgame = False
#self.ralph.setPos(-196, 177, 3)
if self.isMoving == True:
self.ralph.stop()
self.ralph.pose("walk", 5)
self.isMoving = False
elif fromColNp.getName() == "ralphOrbColPath" and toColNp.getName() == "allinclusive":
fromColNp.getParent().setZ(50)
elif toColNp.getName() == "ralphOrbColPath" and fromColNp.getName() == "allinclusive":
toColNp.getParent().setZ(50)
elif fromColNp.getName() == "enemyOrbWallCheck" and toColNp.getName() == "allinclusive":
fromColNp.getParent().setZ(50)
#print toColNp.getName()
elif toColNp.getName() == "enemyOrbWallCheck" and fromColNp.getName() == "allinclusive":
toColNp.getParent().setZ(50)
#print fromColNp.getName()
elif fromColNp.getName() == "ralphWallCheck" and toColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(0,-1,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#fromColNp.getParent().setZ(26)
self.ralphSpeed = 60
elif toColNp.getName() == "ralphWallCheck" and fromColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(0,-1,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#print "wtf"
#toColNp.getParent().setZ(26)
self.ralphSpeed = 60
elif fromColNp.getName() == "ralphWallCheck2" and toColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(0,1,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#fromColNp.getParent().setZ(26)
self.ralphSpeed = 60
elif toColNp.getName() == "ralphWallCheck2" and fromColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(0,1,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#self.camera.setPos(self.ralph.getPos())
#self.cameraCollided = True
self.ralphSpeed = 60
elif fromColNp.getName() == "ralphWallCheck3" and toColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(-1,0,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#fromColNp.getParent().setZ(26)
self.ralphSpeed = 60
elif toColNp.getName() == "ralphWallCheck3" and fromColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(-1,0,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#self.camera.setPos(self.ralph.getPos())
#self.cameraCollided = True
self.ralphSpeed = 60
elif fromColNp.getName() == "ralphWallCheck4" and toColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(1,0,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#fromColNp.getParent().setZ(26)
self.ralphSpeed = 60
elif toColNp.getName() == "ralphWallCheck4" and fromColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(1,0,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#self.camera.setPos(self.ralph.getPos())
#self.cameraCollided = True
self.ralphSpeed = 60
utils.updateHealthBar(self.healthCount, self.bar)
#utils.turnofstartbutton(self.flagstartbutton)
#if self.flagstartbutton ==1:
# self.helpOn.destory()
return task.cont
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
self.orbCollisionHandler = CollisionHandlerQueue()
self.cTrav = CollisionTraverser()
self.cTrav.setRespectPrevTransform(True)
#hbPath = NodePath()
utilsKristina2.setUpKeys(self)
utilsKristina2.loadModels(self)
utilsKristina2.setUpLighting(self)
utilsKristina2.setUpFloatingSpheres(self)
utilsKristina2.setUpRalphsShot(self)
utilsKristina2.setUpCamera(self)
utilsKristina2.setUpCollisionSpheres(self)
self.healthTxt = utilsKristina2.addInstructions(.06,"Health: 100")
self.orbTxt = utilsKristina2.addInstructions(.18,"Orbs: 0")
self.vec = LVector3(0,1,0)#vector for pawns shot
# Create a frame
#frame = DirectFrame(text = "main", scale = 0.001)
# Add button
#bar = DirectWaitBar(text = "", value = 50, pos = (0,.4,.4))
#bar.reparent(render)
# Game state variables
self.isMoving = False
self.jumping = False
self.vz = 0
self.numOrbs = 0
self.healthCount = 100
#self.shotList = []
#self.sphere = CollisionBox((self.ralph.getX() + -10,self.ralph.getY(),self.ralph.getZ()),10,10,10)
self.sphere = CollisionSphere(0,-5,4,3)
self.sphere3 = CollisionSphere(0,5,5,3)
self.sphere4 = CollisionSphere(-4,0,5,2)
self.sphere5 = CollisionSphere(4,0,5,2)
self.sphere2 = CollisionSphere(0,0,3,2)
self.cnodePath = self.ralph.attachNewNode((CollisionNode("ralphColNode")))
self.cnodePath2 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck")))
self.cnodePath3 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck2")))
self.cnodePath4 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck3")))
self.cnodePath5 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck4")))
self.cnodePath.node().addSolid(self.sphere2)
self.cnodePath2.node().addSolid(self.sphere)
self.cnodePath3.node().addSolid(self.sphere3)
self.cnodePath4.node().addSolid(self.sphere4)
self.cnodePath5.node().addSolid(self.sphere5)
#self.cnodePath.node().addSolid(self.sphere2)
self.cnodePath.show()
#self.cnodePath2.show()
#self.cnodePath3.show()
#self.cnodePath4.show()
#self.cnodePath5.show()
self.cTrav.addCollider(self.cnodePath2, self.orbCollisionHandler)
self.cTrav.addCollider(self.cnodePath3, self.orbCollisionHandler)
self.cTrav.addCollider(self.cnodePath4, self.orbCollisionHandler)
self.cTrav.addCollider(self.cnodePath5, self.orbCollisionHandler)
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(self.cnodePath, self.ralph)
#self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler)
self.cTrav.addCollider(self.cnodePath, self.pusher)
self.chrisLastShotTime = globalClock.getFrameTime()
self.chrisTimer = globalClock.getDt()
#def __init__(self, pos,showbase, colPathName, dir, length):
self.chrisList = [utilsKristina2.chris((15,0,0.5),self,"chrisColPath0","X",6), utilsKristina2.chris((18,29,0.5),self,"chrisColPath1","X",6),
utilsKristina2.chris((-6,67,0.5),self,"chrisColPath2","X",6), utilsKristina2.chris((-41,72,0.5),self,"chrisColPath7","X",6)]
#,utilsKristina2.chris((-42,106,0.5),self,"chrisColPath3","X",6)]#, utilsKristina2.chris((-62,108,0.5),self,"chrisColPath4","X",6),
#utilsKristina2.chris((-74,70,0.5),self,"chrisColPath5","y",6)]
#def _init_(self,showbase,pos,color,speed,radius):
self.orbList = [utilsKristina2.orb(self,(0,0,2),(0,0,1,1),20,4)]
self.donutList = [utilsKristina2.donut(self,(0,0,2),40,3)]
self.cameraCollided = False
self.ralphSpeed = 60
self.ralphHit = False
self.ralphRedTime = 0
self.ralphLife=True
taskMgr.add(self.move, "moveTask")
taskMgr.add(self.moveChris,"moveChrisTask")
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
#hbPath = NodePath()
utils.setUpKeys(self)
utils.loadModels(self)
utils.setUpLighting(self)
utils.setUpFloatingSpheres(self)
utils.setUpRalphsShot(self)
utils.setUpCamera(self)
utils.addInstructions(.06,"Health: 100")
self.orbTxt = utils.addInstructions(.18,"Orbs: 0")
self.vec = LVector3(0,1,0)#vector for pawns shot
# Create a frame
#frame = DirectFrame(text = "main", scale = 0.001)
# Add button
#bar = DirectWaitBar(text = "", value = 50, pos = (0,.4,.4))
#bar.reparent(render)
# Game state variables
self.isMoving = False
self.jumping = False
self.vz = 0
self.numOrbs = 0
#self.shotList = []
taskMgr.add(self.move, "moveTask")
self.cTrav = CollisionTraverser()
self.wallHandler = CollisionHandlerPusher()
self.sphere = CollisionSphere(0,0,4,2)
self.sphere2 = CollisionSphere(0,0,2,2)
self.cnodePath = self.ralph.attachNewNode((CollisionNode('cnode')))
self.cnodePath.node().addSolid(self.sphere)
self.cnodePath.node().addSolid(self.sphere2)
#self.cnodePath.show()
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(self.cnodePath, self.ralph)
self.ySphereCollisionHandler = CollisionHandlerQueue()
#self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler)
self.cTrav.addCollider(self.cnodePath, self.pusher)
ct = CollisionSphere(0,0,0,1)
cn = self.pawn.attachNewNode(CollisionNode('pawnCollisionNode'))
cn.node().addSolid(ct)
#cn.show()
ca = CollisionSphere(0,0,0,20)
cb = self.chik.attachNewNode(CollisionNode('chikCollisionNode'))
cb.node().addSolid(ca)
#cb.show()
cc = CollisionSphere(3,5,12,25)
cd = self.gianteye.attachNewNode(CollisionNode('gianteyeCollisionNode'))
cd.node().addSolid(cc)
#cd.show()
ci = CollisionSphere(0,0,0,2)
coi = self.catidol.attachNewNode(CollisionNode('catidolCollisionNode'))
coi.node().addSolid(ci)
#coi.show()
chi = CollisionSphere(0,3,0,5)
chco = self.chris.attachNewNode(CollisionNode('catidolCollisionNode'))
chco.node().addSolid(chi)
#chco.show()
donut= CollisionSphere(0,3,0,5)
donutx = self.donut.attachNewNode(CollisionNode('donutCollisionNode'))
donutx.node().addSolid(donut)
#chco.show()
cs2 = CollisionSphere(0,0,0,.2)
cs2path = self.plnp.attachNewNode((CollisionNode('ySphereColPath')))
cs2path.node().addSolid(cs2)
cs2path.show()
self.cTrav.addCollider(cs2path, self.ySphereCollisionHandler)
cs3 = CollisionSphere(0,0,0,1)
cs3path = self.plnp2.attachNewNode((CollisionNode('bSphereColPath')))
cs3path.node().addSolid(cs2)
cs3path.show()
self.cTrav.addCollider(cs3path, self.ySphereCollisionHandler)
# Uncomment this line to show a visual representation of the
# collisions occuring
self.cTrav.showCollisions(render)
def __init__(self, base):
self.base = base
self.keyState = {
"WalkFw": False,
"WalkBw": False,
"Run": False,
"RotateL": False,
"RotateR": False,
"Jump": False,
"Duck": False
}
self.isKeyDown = self.base.mouseWatcherNode.isButtonDown
self.state = Player.STATE_IDLE
self.sub_state = None
self.walkDir = 0
self.rotationDir = 0
self.zVelocity = 0
self.zOffset = None
self.jumpHeight = None
self.terrainZone = Player.TERRAIN_NONE
self.terrainSurfZ = None
self.waterDepth = 0
self.collidedObjects = list()
# actor
anims = {
"idle": "models/player-idle",
"walk": "models/player-walk",
"run": "models/player-run",
"jump": "models/player-jump",
"duck": "models/player-duck",
"float": "models/player-float",
"swim": "models/player-swim",
"grab": "models/player-grab"
}
self.actor = Actor("models/player", anims)
self.actor.reparentTo(self.base.render)
self.actor.setH(200)
log.debug("actor tight bounds is %s" %
str(self.actor.getTightBounds()))
# animation info
Player.DUCK_FRAME_COUNT = self.actor.getNumFrames("duck")
Player.DUCK_FRAME_MID = int(Player.DUCK_FRAME_COUNT / 2)
# camara point
self.camNode = NodePath("camNode")
self.camNode.reparentTo(self.actor)
self.camNode.setPos(0, 0, 1)
# collision
# ray
collRay = CollisionRay(0, 0, 1.5, 0, 0, -1)
collRayN = CollisionNode("playerCollRay")
collRayN.addSolid(collRay)
collRayN.setFromCollideMask(1)
collRayN.setIntoCollideMask(CollideMask.allOff())
collRayNP = self.actor.attachNewNode(collRayN)
self.collQRay = CollisionHandlerQueue()
self.base.cTrav.addCollider(collRayNP, self.collQRay)
# sphere mask 2
collSphere2 = CollisionSphere(0, 0, 0.5, 0.25)
collSphere2N = CollisionNode("playerCollSphere2")
collSphere2N.addSolid(collSphere2)
collSphere2N.setFromCollideMask(2)
collSphere2N.setIntoCollideMask(CollideMask.allOff())
self.collSphere2NP = self.actor.attachNewNode(collSphere2N)
self.collPSphere = CollisionHandlerPusher()
self.collPSphere.addCollider(self.collSphere2NP, self.actor)
self.base.cTrav.addCollider(self.collSphere2NP, self.collPSphere)
# key events
self.base.accept("i", self.dump_info)
# task
self.base.taskMgr.add(self.update, "playerUpdateTask")
class Game(ShowBase):
def __init__(self):
ShowBase.__init__(self)
#Background sound (does not play infinitely)
self.backgroundSound = base.loader.loadSfx("sounds/DireDireDocks.mp3")
taskMgr.add(self.update, "moveTask")
#Disable the mouse so that we may use it for our control scheme.
self.props = WindowProperties()
self.props.setSize(1920, 1080)
self.props.setFullscreen(True)
self.props.setCursorHidden(True)
base.win.requestProperties(self.props)
base.disableMouse()
self.buildKeyMap()
self.inMenu = True
self.menuScreen = OnscreenImage("titlescreen.png", (0, .01, 0))
self.menu()
def initialize(self):
self.timer = 0
base.enableParticles()
#base.setFrameRateMeter(True)
##########
#
# SETUP COLLISION HANDLERS AND FLAMIE'S MODEL
#
##########
#Create the collision handlers in order to build the level.
WALL_MASK = BitMask32.bit(2)
FLOOR_MASK = BitMask32.bit(1)
#Start up the collision system
self.cTrav = CollisionTraverser()
#Determine how collisions with walls will be handled
self.wallHandler = CollisionHandlerPusher()
self.bobbing = False
#Setup flamie's model
self.flamieNP = base.render.attachNewNode(ActorNode('flamieNP'))
self.flamieNP.reparentTo(base.render)
self.flamie = loader.loadModel('models/Flame/body')
self.flamie.setScale(.5)
self.flamie.setTransparency(TransparencyAttrib.MAlpha)
self.flamie.setAlphaScale(0)
self.flamie.reparentTo(self.flamieNP)
self.flamie.setCollideMask(BitMask32.allOff())
flameLight = DirectionalLight("flameLight")
fl = self.flamie.attachNewNode(flameLight)
fl.setColor(255, 255, 255, 1)
flameLight.setDirection((-5, -5, -5))
self.flamie.setLight(fl)
self.flamie2 = loader.loadModel("models/p.obj")
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f7.png"))
self.flamie2.reparentTo(self.flamieNP)
self.flamie2.setScale(4)
self.flamie2OriZ = 2
self.flamie2.setPos(-6.5, 0, self.flamie2OriZ) #(length, depth, height)
self.flamie2.setLight(fl)
self.flamie2.setTransparency(TransparencyAttrib.MAlpha)
self.flamieFire = PointLight('fire')
self.flamieFire.setColor(VBase4(1,1,1,1))
self.flamieFire.setAttenuation((1,0,1))
plnp = render.attachNewNode(self.flamieFire)
plnp.setPos(self.flamieNP.getPos())
self.flamielight = AmbientLight('light')
self.flamielight.setColor(VBase4(1, 0.5, 0.6, 1))
self.flamielight = self.flamie2.attachNewNode(self.flamielight)
self.flamie2.setLight(self.flamielight)
self.flamie2.setLight(plnp)
self.mayFlamieBob = True
#self.flamie2.setAlphaScale(0.5)
'''self.tree = loader.loadModel("models/p2.obj")
self.tree.setTexture(loader.loadTexture("deadTree.png"))
self.tree.reparentTo(render)
self.tree.setScale(4)
self.tree.setPos(25,25,0) #(length, depth, height)
self.tree.setLight(fl)
self.tree.setTransparency(TransparencyAttrib.MAlpha)
self.treelight = AmbientLight('light')
self.treelight.setColor(VBase4(0.9, 0.9, 0.6, 1))
self.treelight = self.tree.attachNewNode(self.treelight)
self.tree.setLight(self.treelight)'''
x = 150
y = 20
offset1 = 0
treeList2 = [loader.loadModel("models/p2.obj") for i in range(7)]
for j in treeList2:
k = random.randint(1, 100)
if k%5 is 1 or k%5 is 2:
j.setTexture(loader.loadTexture("deadTree.png"))
else:
j.setTexture(loader.loadTexture("tree.png"))
j.reparentTo(render)
j.setScale(random.randint(4,7))
j.setTransparency(TransparencyAttrib.MAlpha)
j.setPos(x + 3*offset1, y + 4*offset1, 0)
treelight = AmbientLight('light')
treelight = j.attachNewNode(treelight)
j.setLight(treelight)
offset1 = offset1 + random.randint(4, 10)
x = 4
y = 90
offset1 = 0
treeList2 = [loader.loadModel("models/p2.obj") for i in range(6)]
for j in treeList2:
k = random.randint(1, 100)
if k%5 is 1 or k%5 is 2:
j.setTexture(loader.loadTexture("deadTree.png"))
else:
j.setTexture(loader.loadTexture("tree.png"))
j.reparentTo(render)
j.setScale(random.randint(4,7))
j.setTransparency(TransparencyAttrib.MAlpha)
j.setPos(x + 3*offset1, y + 4*offset1, 0)
treelight = AmbientLight('light')
treelight = j.attachNewNode(treelight)
j.setLight(treelight)
offset1 = offset1 + random.randint(4, 10)
x = 3
y = 120
offset1 = 0
treeList2 = [loader.loadModel("models/p2.obj") for i in range(4)]
for j in treeList2:
k = random.randint(1, 100)
if k%5 is 1 or k%5 is 2:
j.setTexture(loader.loadTexture("deadTree.png"))
else:
j.setTexture(loader.loadTexture("tree.png"))
j.reparentTo(render)
j.setScale(random.randint(4,7))
j.setTransparency(TransparencyAttrib.MAlpha)
j.setPos(x + 3*offset1, y + 4*offset1, 0)
treelight = AmbientLight('light')
treelight = j.attachNewNode(treelight)
j.setLight(treelight)
offset1 = offset1 + random.randint(4, 10)
x = 200
y = 20
offset1 = 0
treeList2 = [loader.loadModel("models/p2.obj") for i in range(4)]
for j in treeList2:
k = random.randint(1, 100)
if k%5 is 1 or k%5 is 2:
j.setTexture(loader.loadTexture("deadTree.png"))
else:
j.setTexture(loader.loadTexture("tree.png"))
j.reparentTo(render)
j.setScale(random.randint(4,7))
j.setTransparency(TransparencyAttrib.MAlpha)
j.setPos(x + 3*offset1, y + 4*offset1, 0)
treelight = AmbientLight('light')
treelight = j.attachNewNode(treelight)
j.setLight(treelight)
offset1 = offset1 + random.randint(4, 10)
### Something that should look like water ###
w = loader.loadModel("models/flatP.obj")
w.setTexture(loader.loadTexture("ice.png"))
w.reparentTo(render)
w.setScale(75)
w.setTransparency(TransparencyAttrib.MAlpha)
w.setAlphaScale(.7)
w.setLight(treelight)
w.setPos(-200, 0, -10)
self.waterOrigiZ = -10
self.waterSecZ = -95
self.waterThirdZ = -120
self.water = w
### Reskying the sky ###
w = loader.loadModel("models/biggerFlatP.obj")
w.setTexture(loader.loadTexture("models/n2.jpg"))
w.reparentTo(self.flamie2)
w.setScale(15)
w.setLight(treelight)
w.setPos(-200, 450, -200) #(length, depth, height)
#Give flamie gravity
self.floorHandler = CollisionHandlerGravity()
self.floorHandler.setGravity(9.81+100)
self.floorHandler.setMaxVelocity(100)
##########
#
# GENERATING LEVEL PARTS
#
##########
self.ice_reset = ()
self.start = PlatformSeg(LVector3(0,0,0))
self.start.generateAllParts(render)
self.checkpointCreator(70, 90, self.start.pos.z, 10)
self.floater = False
for p in self.start.parts:
if isinstance(p, Prism):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, p.dep, 'terraincollision', 'wallcollision')
if isinstance(p, Square):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, 3, 'terraincollision', 'wallcollision')
if isinstance(p, IceCube):
p.model.setCollideMask(BitMask32.allOff())
self.ice_reset += (p,)
iceCubefloor= p.model.find("**/iceFloor")
iceCubewall = p.model.find("**/iceWall")
iceCubefloor.node().setIntoCollideMask(FLOOR_MASK)
iceCubewall.node().setIntoCollideMask(WALL_MASK)
self.lostWood = LostWood(LVector3(self.start.pos.x + 750, self.start.parts[0].pos.y + self.start.parts[0].wid, self.start.pos.z))
self.lostWood.generateAllParts(render)
self.checkpointCreator(self.lostWood.pos.x+120, self.lostWood.pos.y+150, self.lostWood.pos.z,20)
self.checkpointCreator(self.lostWood.parts[6].pos.x + self.lostWood.parts[6].len/2, self.lostWood.parts[6].pos.y + self.lostWood.parts[6].wid/2, self.lostWood.pos.z, 40)
for p in self.lostWood.parts:
if isinstance(p, Prism):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, p.dep, 'terraincollision', 'wallcollision')
if isinstance(p, Square):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, 3, 'terraincollision', 'wallcollision')
if isinstance(p, IceCube):
p.model.setCollideMask(BitMask32.allOff())
self.ice_reset += (p,)
iceCubefloor= p.model.find("**/iceFloor")
iceCubewall = p.model.find("**/iceWall")
iceCubefloor.node().setIntoCollideMask(FLOOR_MASK)
iceCubewall.node().setIntoCollideMask(WALL_MASK)
self.cave = Cave(LVector3(self.lostWood.pos.x + 1100, self.lostWood.pos.y + 2000, self.lostWood.pos.z - 50))
self.cave.generateAllParts(render)
self.checkpointCreator(self.cave.thirdRoomParts[5].pos.x + self.cave.thirdRoomParts[5].len/2,
self.cave.thirdRoomParts[5].pos.y + self.cave.thirdRoomParts[5].wid/2,
self.cave.thirdRoomParts[5].pos.z, 30)
for p in self.cave.parts:
if isinstance(p, Prism):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, p.dep, 'terraincollision', 'wallcollision')
if isinstance(p, Square):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, 3, 'terraincollision', 'wallcollision')
if isinstance(p, IceCube):
p.model.setCollideMask(BitMask32.allOff())
self.ice_reset += (p,)
iceCubefloor= p.model.find("**/iceFloor")
iceCubewall = p.model.find("**/iceWall")
iceCubefloor.node().setIntoCollideMask(FLOOR_MASK)
iceCubewall.node().setIntoCollideMask(WALL_MASK)
self.end = End(LVector3(self.cave.thirdRoomParts[8].pos.x - 200,
self.cave.thirdRoomParts[8].pos.y + self.cave.thirdRoomParts[8].wid,
self.cave.thirdRoomParts[8].pos.z))
self.end.generate(render)
self.collisionBoxCreator(self.end.floor.pos.x, self.end.floor.pos.y, self.end.floor.pos.z,
self.end.floor.len, self.end.floor.wid, self.end.floor.dep,
'terraincollision', 'wallcollision')
#########
# DRAWING THE CABIN AND FINAL CAMPFIRE
#########
self.checkpointCreator(self.end.floor.pos.x + self.end.floor.len/2,
self.end.floor.pos.y + self.end.floor.wid/2,
self.end.floor.pos.z, 30)
self.cabin = loader.loadModel("models/p2.obj")
self.cabin.setTexture(loader.loadTexture("models/cabin.png"))
self.cabin.setScale(50)
self.cabin.reparentTo(render)
self.cabin.setPos(self.end.floor.pos.x + self.end.floor.len/2,
self.end.floor.pos.y + self.end.floor.wid/1.1,
self.end.floor.pos.z)
self.cabin.setTransparency(TransparencyAttrib.MAlpha)
#Manually creating starting position. Copy and paste the first three parameters of the checkpoint you want to start at.
self.startPos = LVector3(70, 90, self.start.pos.z)
self.flamieNP.setPos(self.startPos)
'''#Testing the tree model
self.tree = loader.loadModel('models/Tree/log')
self.tree.reparentTo(render)
self.tree.setPos(-50,0,100)
self.tree.setScale(2)'''
'''#Add sky background
self.sky = loader.loadModel('models/sphere.obj')
self.sky.reparentTo(self.camera)
self.sky.set_two_sided(True)
self.skyTexture = loader.loadTexture("models/n2.jpg")
self.sky.setTexture(self.skyTexture)
self.sky.set_bin('background', 0)
self.sky.set_depth_write(False)
self.sky.set_compass()'''
##########
#
# CREATE FLAMIE'S COLLISION GEOMETRY
#
##########
#Give flamie a collision sphere in order to collide with walls
flamieCollider = self.flamie.attachNewNode(CollisionNode('flamiecnode'))
flamieCollider.node().addSolid(CollisionSphere(0,0,0,5))
flamieCollider.node().setFromCollideMask(WALL_MASK)
flamieCollider.node().setIntoCollideMask(BitMask32.allOff())
self.wallHandler.addCollider(flamieCollider, self.flamieNP)
self.cTrav.addCollider(flamieCollider, self.wallHandler)
#Give flamie a collision ray to collide with the floor
flamieRay = self.flamie.attachNewNode(CollisionNode('flamieRay'))
flamieRay.node().addSolid(CollisionRay(0,0,8,0,0,-1))
flamieRay.node().setFromCollideMask(FLOOR_MASK)
flamieRay.node().setIntoCollideMask(BitMask32.allOff())
self.floorHandler.addCollider(flamieRay, self.flamieNP)
self.cTrav.addCollider(flamieRay, self.floorHandler)
#Add a sensor that lets us melt ice cubes without standing on the cube.
meltSensor = self.flamie.attachNewNode(CollisionNode('meltSensor'))
cs = CollisionSphere(-2,0,10, 50)
meltSensor.node().addSolid(cs)
meltSensor.node().setFromCollideMask(WALL_MASK)
meltSensor.node().setIntoCollideMask(BitMask32.allOff())
cs.setTangible(0)
self.wallHandler.addCollider(meltSensor, self.flamieNP)
self.cTrav.addCollider(meltSensor, self.wallHandler)
self.wallHandler.addInPattern('%fn-into-%in')
self.wallHandler.addAgainPattern('%fn-again-%in')
self.accept('meltSensor-into-iceWall', self.melt)
self.accept('meltSensor-again-iceWall', self.melt)
self.accept('meltSensor-into-checkpointCol', self.newstart)
#Add in an event handle to prevent the jumping glitch found on the bobbing ice cubes.
self.floorHandler.addInPattern('%fn-into-%in')
self.floorHandler.addAgainPattern('%fn-again-%in')
self.floorHandler.addOutPattern('%fn-out-%in')
self.accept('flamieRay-into-iceFloor', self.jittercancel)
self.accept('flamieRay-again-iceFloor', self.jittercancel)
self.accept('flamieRay-out-iceFloor', self.jittercanceloff)
#Uncomment these lines to see flamie's collision geometry
#flamieCollider.show()
#flamieRay.show()
#meltSensor.show()
#Uncomment this line to see the actual collisions.
#self.cTrav.showCollisions(render)
#This plane is found at the very bottom of the level and adds global gravity.
killfloor = CollisionPlane(Plane(Vec3(0,0,1), Point3(0,0,-1000)))
killfloorCol = CollisionNode('kfcollision')
killfloorCol.addSolid(killfloor)
killfloorCol.setIntoCollideMask(BitMask32.bit(1))
killfloorColNp = self.render.attachNewNode(killfloorCol)
####################
#
# Setting light so that we could see the definition in the walls
#
####################
render.setShaderAuto()
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(LVector4(0.3, 0.1, 0.7, 1))
dlnp = render.attachNewNode(self.dlight)
dlnp.setHpr(90, 20, 0)
render.setLight(dlnp)
self.alight = render.attachNewNode(AmbientLight("Ambient"))
self.alight.node().setColor(LVector4(0.5, 0.5, 1, .1))
render.setLight(self.alight)
self.snow = loader.loadTexture("models/ground.jpg")
#Create a floater object and have it float 2 units above fireball.
#And use this as a target for the camera to focus on.
#This idea is taken from the roaming ralph sample that came with the
#Panda3D SDK.
self.camFocus = NodePath(PandaNode("floater"))
self.camFocus.reparentTo(render)
self.camFocusCurrZ = self.flamie.getZ() + 10
#The camera is locked to the avatar so it always follows regardless of movement.
self.camera.reparentTo(render)
self.cameraTargetHeight = 8.0
self.cameraDistance = 100
self.cameraHeightModes = (self.start.parts[0].pos.z + 45, self.start.parts[0].pos.z + 125, self.camFocus.getZ() + 10, self.camFocus.getZ() + 150,
self.end.floor.pos.z + 10)
self.cameraHeight = self.cameraHeightModes[0]
#################
# Changes Camera orientation depending on where the player is in the stage to compensate for the fact that
# the player has no direct control of the camera.
# Checks using the arrays from the level parts.
##################
def cameraModes(self, delta):
#Is the fireball within the platforming section between the starting area and the lost woods?
#Is the fireball near the simple platforming sections of the LostWoods?
#Is the fireball near the drop off point into the cave?
#Is the fireball near the entrance to the second room in the cave?
#If yes to any of these, bring the camera up to give a bird's eye view of the platforming
if ((self.flamieNP.getX() > self.start.parts[1].pos.x and self.flamieNP.getY() > self.start.parts[1].pos.y - self.start.parts[1].wid
and self.flamieNP.getX() < self.lostWood.parts[0].pos.x)
or (self.flamieNP.getX() > self.lostWood.parts[0].pos.x + self.lostWood.parts[0].len/1.1
and self.flamieNP.getX() < self.lostWood.parts[2].pos.x + self.lostWood.parts[0].len/11
and self.flamieNP.getY() < self.lostWood.parts[0].pos.y + self.lostWood.parts[0].wid)
or (self.flamieNP.getY() > self.cave.parts[0].pos.y - 20 and self.flamieNP.getY() <= self.cave.parts[0].pos.y + self.cave.parts[0].wid/2)
or (self.flamieNP.getX() < self.cave.parts[1].pos.x + self.cave.parts[1].wid/10 and self.flamieNP.getY() >= self.cave.parts[1].pos.x)):
camMode = 1
#Is the fireball in the beginning of the cave area?
#If yes, bring the camera closer
elif self.flamieNP.getY() > self.cave.parts[1].pos.y - self.cave.parts[0].wid/2 and self.flamieNP.getY() < self.cave.thirdRoomParts[5].pos.y:
camMode = 2
else:
camMode = 0
if self.flamieNP.getY() >= self.cave.thirdRoomParts[6].pos.y:
self.cave.thirdRoomParts[0].hide()
camMode = 3
if self.flamieNP.getY() >= self.cave.thirdRoomParts[8].pos.y + self.cave.thirdRoomParts[8].wid/1.5:
camMode = 4
self.lerpCam(camMode, delta)
def lerpCam(self, camMode, delta):
CAMLERPSPEED = 25
if camMode == 0:
if not self.cameraHeight == self.cameraHeightModes[camMode]:
if self.cameraHeight - CAMLERPSPEED * delta <= self.cameraHeightModes[camMode]:
self.cameraHeight = self.cameraHeightModes[camMode]
else:
self.cameraHeight = self.cameraHeight - CAMLERPSPEED * delta
elif camMode == 1:
if not self.cameraHeight == self.cameraHeightModes[camMode]:
if self.cameraHeight - CAMLERPSPEED * delta >= self.cameraHeightModes[camMode]:
self.cameraHeight = self.cameraHeightModes[camMode]
else:
if self.cameraHeight < self.cameraHeightModes[camMode]:
self.cameraHeight = self.cameraHeight + CAMLERPSPEED * delta
else:
self.cameraHeight = self.cameraHeight - CAMLERPSPEED * delta
elif camMode == 2:
if not self.cameraHeight == self.cameraHeightModes[camMode]:
if self.cameraHeight - CAMLERPSPEED * delta <= self.cameraHeightModes[camMode]:
self.cameraHeight = self.cameraHeightModes[camMode]
self.camFocusCurrZ = self.flamieNP.getZ() + 10
else:
self.cameraHeight = self.cameraHeight - CAMLERPSPEED * delta
self.camFocusCurrZ = self.flamieNP.getZ() + 10
elif camMode == 3:
if not self.cameraHeight == self.cameraHeightModes[camMode]:
if self.cameraHeight + CAMLERPSPEED * 3 * delta >= self.cameraHeightModes[camMode]:
self.cameraHeight = self.cameraHeightModes[camMode]
else:
self.cameraHeight = self.cameraHeight + CAMLERPSPEED * 3 * delta
elif camMode == 4:
if not self.cameraHeight == self.cameraHeightModes[camMode]:
if self.cameraHeight - CAMLERPSPEED * 3 * delta <= self.cameraHeightModes[camMode]:
self.cameraHeight = self.cameraHeightModes[camMode]
else:
self.cameraHeight = self.cameraHeight - CAMLERPSPEED * 3 * delta
def waterControl(self, delta):
WATERLERPSPEED = .75
if self.flamieNP.getY() <= self.lostWood.parts[6].pos.y + self.lostWood.parts[6].wid/2:
if not self.water.getZ() == self.waterOrigiZ:
if self.water.getZ() - WATERLERPSPEED * delta < self.waterOrigiZ and self.water.getZ() > self.waterOrigiZ:
self.water.setZ(self.waterOrigiZ)
elif self.water.getZ() + WATERLERPSPEED * delta > self.waterOrigiZ and self.water.getZ() < self.waterOrigiZ:
self.water.setZ(self.waterOrigiZ)
else:
if self.water.getZ() > self.waterOrigiZ:
self.water.setZ(self.water, - WATERLERPSPEED * delta)
if self.water.getZ() < self.waterOrigiZ:
self.water.setZ(self.waterOrigiZ)
else:
self.water.setZ(self.water, + WATERLERPSPEED * delta)
if self.water.getZ() > self.waterOrigiZ:
self.water.setZ(self.waterOrigiZ)
elif self.flamieNP.getY() <= self.cave.parts[1].pos.y:
if not self.water.getZ() == self.waterSecZ:
if self.water.getZ() - WATERLERPSPEED * delta < self.waterSecZ:
self.water.setZ(self.waterSecZ)
else:
self.water.setZ(self.water, - WATERLERPSPEED * delta)
else:
if not self.water.getZ() == self.waterThirdZ:
if self.water.getZ() - WATERLERPSPEED * delta < self.waterThirdZ:
self.water.setZ(self.waterThirdZ)
else:
self.water.setZ(self.water, - WATERLERPSPEED * delta)
def reset(self):
self.flamieNP.setPos(self.startPos)
self.camFocusCurrZ = self.flamieNP.getZ() + 10
for p in self.ice_reset:
p.model.setScale(p.original_scale)
def jump(self, dt):
if self.bobbing:
if self.floorHandler.getAirborneHeight() < 0.15:
self.floorHandler.addVelocity(60)
elif self.floorHandler.isOnGround():
self.floorHandler.addVelocity(60)
def jittercancel(self, collEntry):
model = collEntry.getIntoNodePath().getParent()
modelRef = model.getPythonTag("iceRef")
if model.getScale()[0] > 1.2:
model.setScale(model.getScale()- modelRef.meltspeed)
self.bobbing = True
def jittercanceloff(self, collEntry):
self.bobbing = False
def melt(self, collEntry):
model = collEntry.getIntoNodePath().getParent()
modelRef = model.getPythonTag("iceRef")
if model.getScale()[0] > 1.2 and self.bobbing != True:
model.setScale(model.getScale()- modelRef.meltspeed)
def newstart(self, collEntry):
entry = collEntry.getInto().getCenter()
self.startPos = (entry[0]+10, entry[1]+10, entry[2] +10)
cp = loader.loadModel('models/Campfire/fire')
cp.setPos(entry[0],entry[1], entry[2])
cp.reparentTo(render)
def buildKeyMap(self):
self.keyMap = {"left": 0, "right": 0, "forward": 0, "back": 0, "down": 0, "up": 0, "lookUp": 0, "lookDown": 0, "lookLeft": 0, "lookRight": 0}
#I changed the control scheme let me know if you would like me to try something else.
#WASD for movement, space for jump
self.accept("escape", sys.exit)
self.accept("a", self.setKey, ["left", True])
self.accept("a-up", self.setKey, ["left", False])
self.accept("d", self.setKey, ["right", True])
self.accept("d-up", self.setKey, ["right", False])
self.accept("w", self.setKey, ["forward", True])
self.accept("w-up", self.setKey, ["forward", False])
self.accept("s", self.setKey, ["back", True])
self.accept("s-up", self.setKey, ["back", False])
self.accept("space", self.setKey, ["down", True])
self.accept("space-up", self.setKey, ["down", False])
self.accept("shift", self.setKey, ["up", True])
self.accept("shift-up", self.setKey, ["up", False])
def setKey(self, key, value):
self.keyMap[key] = value
def update(self, task):
delta = globalClock.getDt()
if not self.inMenu:
SPEED = 125
#Variable that holds what direction the player is inputting
fblr = 0
self.timer += delta * 25
self.killPlane = self.water.getZ() - 25
if self.flamieNP.getZ() < self.killPlane:
self.reset()
if self.keyMap["left"]:
fblr = 1
old_fblr = fblr
self.flamieNP.setX(self.flamie, - SPEED * delta)
if self.keyMap["right"]:
fblr = 2
old_fblr = fblr
self.flamieNP.setX(self.flamie, + SPEED * delta)
if self.keyMap["forward"]:
fblr = 3
old_fblr = fblr
self.flamieNP.setY(self.flamie, + SPEED * delta)
if self.keyMap["back"]:
fblr = 4
old_fblr = fblr
self.flamieNP.setY(self.flamie, - SPEED * delta)
if self.keyMap["up"]:
#self.flamieNP.setZ(self.flamie, - SPEED * dt)
self.reset()
#self.cameraDistance = 20+self.cameraDistance
if self.keyMap["down"] and self.timer > 1:
#self.flamieNP.setZ(self.flamie, + SPEED * dt)
self.timer = 0
self.jump(delta)
if fblr == 1:
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f8.png"))
elif fblr == 2:
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f6.png"))
elif fblr == 3:
if old_fblr == 1:
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f1.png"))
elif old_fblr == 2:
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f4.png"))
else:
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f3.png"))
else:
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f7.png"))
if self.floorHandler.isOnGround:
self.flamieBob(delta)
#The camera control is borrowed from Kristina's Tech Demo
#This is also a demo found at: http://www.panda3d.org/forums/viewtopic.php?t=8452
'''# mouse-controlled camera begins
# Use mouse input to turn both the Character and the Camera
if base.mouseWatcherNode.hasMouse():
md = base.win.getPointer(0)
x = md.getX()
y = md.getY()
deltaX = md.getX() - 200
deltaY = md.getY() - 200
# reset mouse cursor position
base.win.movePointer(0, 200, 200)
# alter flamie's yaw by an amount proportionate to deltaX
self.flamie.setH(self.flamie.getH() - 0.3* deltaX)
# find the new camera pitch and clamp it to a reasonable range
self.cameraPitch = self.cameraPitch + 0.1 * deltaY
if (self.cameraPitch < -60): self.cameraPitch = -60
if (self.cameraPitch > 80): self.cameraPitch = 80
base.camera.setHpr(0,self.cameraPitch,0)
# set the camera at around ralph's middle
# We should pivot around here instead of the view target which is noticebly higher
base.camera.setPos(0,0,self.cameraTargetHeight/2)
# back the camera out to its proper distance
base.camera.setY(base.camera,self.cameraDistance)
# point the camera at the view target
viewTarget = Point3(0,0,self.cameraTargetHeight)
base.camera.lookAt(viewTarget)
# reposition the end of the camera's obstruction ray trace
#self.cameraRay.setPointB(base.camera.getPos())
# mouse-controlled camera ends'''
self.waterControl(delta)
self.water.setX(self.flamieNP.getX() - 250)
self.water.setY(self.flamieNP.getY() - 250)
self.cameraModes(delta)
base.camera.setPos(self.flamieNP.getX(), self.flamieNP.getY() - self.cameraDistance, self.cameraHeight)
self.camFocus.setPos(self.flamieNP.getX(), self.flamieNP.getY(), self.camFocusCurrZ)
base.camera.lookAt(self.camFocus)
'''
######################
#
# SIMPLE OCCLUSION FOR START AREA
#
######################
for p in self.start.parts:
if p.type == 'IceCube':
if math.fabs((math.sqrt((p.model.getX() * p.model.getX()) + (p.model.getY() * p.model.getY()))
- math.sqrt((self.camFocus.getX() * self.camFocus.getX()) + (self.camFocus.getY() * self.camFocus.getY())))) <= 400:
p.show()
#Ice cube movement
p.bob(delta)
else:
p.hide()
if p.type == 'Prism':
if p.type == 'Prism':
if math.fabs((math.sqrt((p.pos.x * p.pos.x) + (p.pos.y * p.pos.y))
- math.sqrt((self.camFocus.getX() * self.camFocus.getX()) + (self.camFocus.getY() * self.camFocus.getY())))) <= 1000:
p.show()
else:
p.hide()
######################
#
# SIMPLE OCCLUSION FOR CAVE PARTS
#
######################
for p in self.cave.parts:
if p.type == 'Prism':
if math.fabs((math.sqrt((p.pos.x * p.pos.x) + (p.pos.y * p.pos.y))
- math.sqrt((self.flamieNP.getX() * self.flamieNP.getX()) + (self.flamieNP.getY() * self.flamieNP.getY())))) <= 2500:
p.show()
else:
p.hide()
if p.type == 'IceCube':
if math.fabs((math.sqrt((p.model.getX() * p.model.getX()) + (p.model.getY() * p.model.getY()))
- math.sqrt((self.flamieNP.getX() * self.flamieNP.getX()) + (self.flamieNP.getY() * self.flamieNP.getY())))) <= 2000:
p.show()
#Ice cube movement
self.cave.moveIceCubes(delta/25)
for p in self.cave.iceCubesThirdRoom:
p.bob(delta/25)
for p in self.cave.iceCubesSecondRoom:
p.bob(delta/25)
self.cave.bigCube.bob(delta/25)
for p in self.start.iceCubes:
p.bob(delta)
else:
p.hide()
'''
#Ice cube movement
self.cave.moveIceCubes(delta)
for p in self.cave.iceCubesThirdRoom:
p.bob(delta)
for p in self.cave.iceCubesSecondRoom:
p.bob(delta)
self.cave.bigCube.bob(delta)
for p in self.start.iceCubes:
p.bob(delta)
elif self.inMenu:
self.menu()
if self.backgroundSound.status() is not self.backgroundSound.PLAYING:
self.backgroundSound.play()
return task.cont
def menu(self):
if self.keyMap["down"]:
self.inMenu = False
self.menuScreen.destroy()
self.initialize()
def flamieBob(self, delta):
if self.mayFlamieBob:
self.flamie2.setZ(self.flamie2.getZ() + .5*delta)
if self.flamie2.getZ() - self.flamie2OriZ > 1:
self.mayFlamieBob = False
else:
self.flamie2.setZ(self.flamie2.getZ() - .5*delta)
if self.flamie2.getZ() - self.flamie2OriZ < -2:
self.mayFlamieBob = True
#Function to create a box collision using six polygon. The top face is created as terrain and thus provides gravity.
#While the rest of the faces only act as wall pushers.
def collisionBoxCreator(self, posx, posy, posz, length, width, height, floorname, wallname):
ret = ()
#Create top face
terrain = CollisionPolygon(Point3(posx, posy+width, posz), Point3(posx, posy, posz),
Point3(posx+length, posy, posz), Point3(posx+length, posy+width, posz))
terrainCol = CollisionNode(floorname)
terrainCol.addSolid(terrain)
terrainCol.setIntoCollideMask(BitMask32.bit(1))
terrainColNp = self.render.attachNewNode(terrainCol)
self.cTrav.addCollider(terrainColNp, self.floorHandler)
ret += (terrainColNp,)
#Create left face
sideLeft = CollisionPolygon(Point3(posx, posy+width, posz-height), Point3(posx, posy, posz-height),
Point3(posx, posy, posz), Point3(posx, posy+width, posz))
sideLeftCol = CollisionNode(wallname)
sideLeftCol.addSolid(sideLeft)
sideLeftCol.setIntoCollideMask(BitMask32.bit(2))
sideLeftColNp = self.render.attachNewNode(sideLeftCol)
self.cTrav.addCollider(sideLeftColNp, self.wallHandler)
ret += (sideLeftColNp,)
#Create right face
sideRight = CollisionPolygon(Point3(posx+length, posy+width, posz), Point3(posx+length, posy, posz),
Point3(posx+length, posy, posz-height), Point3(posx+length, posy+width, posz-height))
sideRightCol = CollisionNode(wallname)
sideRightCol.addSolid(sideRight)
sideRightCol.setIntoCollideMask(BitMask32.bit(2))
sideRightColNp = self.render.attachNewNode(sideRightCol)
self.cTrav.addCollider(sideRightColNp, self.wallHandler)
ret += (sideRightColNp,)
#Create front face
sideFront = CollisionPolygon(Point3(posx, posy+width, posz-height), Point3(posx, posy+width, posz),
Point3(posx+length, posy+width, posz), Point3(posx+length, posy+width, posz-height))
sideFrontCol = CollisionNode(wallname)
sideFrontCol.addSolid(sideFront)
sideFrontCol.setIntoCollideMask(BitMask32.bit(2))
sideFrontColNp = self.render.attachNewNode(sideFrontCol)
self.cTrav.addCollider(sideFrontColNp, self.wallHandler)
ret += (sideFrontColNp,)
#Create back face
sideBack = CollisionPolygon(Point3(posx, posy, posz), Point3(posx, posy, posz-height),
Point3(posx+length, posy, posz-height), Point3(posx+length, posy, posz))
sideBackCol = CollisionNode(wallname)
sideBackCol.addSolid(sideBack)
sideBackCol.setIntoCollideMask(BitMask32.bit(2))
sideBackColNp = self.render.attachNewNode(sideBackCol)
self.cTrav.addCollider(sideBackColNp, self.wallHandler)
ret += (sideBackColNp,)
#Create bottom face
sideBot = CollisionPolygon(Point3(posx, posy, posz-height), Point3(posx, posy+width, posz-height),
Point3(posx+length, posy+width, posz-height), Point3(posx+length, posy, posz-height))
sideBotCol = CollisionNode(wallname)
sideBotCol.addSolid(sideBot)
sideBotCol.setIntoCollideMask(BitMask32.bit(2))
sideBotColNp = self.render.attachNewNode(sideBotCol)
self.cTrav.addCollider(sideBotColNp, self.wallHandler)
ret += (sideBotColNp,)
#Uncomment these lines to see the collision polygons.
'''terrainColNp.show()
sideLeftColNp.show()
sideRightColNp.show()
sideFrontColNp.show()
sideBackColNp.show()
sideBotColNp.show()'''
return ret
#Old way of creating box collisions (left here for reference)
'''box = CollisionBox((posx+(length/2), posy+(width/2),-(posz+height/2)), length/2, width/2, height/2)
boxCol = CollisionNode('testcollision')
boxCol.addSolid(box)
boxCol.setIntoCollideMask(BitMask32.bit(2))
boxColNp = self.render.attachNewNode(boxCol)
boxHandler = CollisionHandlerQueue()
self.cTrav.addCollider(boxColNp, self.wallHandler)
#Uncomment this line to see the collision solids.
#boxColNp.show()'''
def checkpointCreator(self, posx, posy, posz, radius):
cp = loader.loadModel('models/Campfire/logs')
cp.setPos(posx,posy, posz)
cp.reparentTo(render)
checkpoint = CollisionSphere(cp.getX(),cp.getY(),cp.getZ(),radius)
checkpoint.setTangible(0)
checkpointCol = CollisionNode('checkpointCol')
checkpointCol.addSolid(checkpoint)
checkpointCol.setIntoCollideMask(BitMask32.bit(2))
checkpointColNp = self.render.attachNewNode(checkpointCol)
self.cTrav.addCollider(checkpointColNp, self.wallHandler)
def __init__(self):
self.bspLoader = Py_CL_BSPLoader()
self.bspLoader.setGlobalPtr(self.bspLoader)
if metadata.USE_RENDER_PIPELINE:
from rpcore import RenderPipeline
self.pipeline = RenderPipeline()
self.pipeline.create(self)
else:
ShowBase.__init__(self)
self.loader.destroy()
self.loader = CogInvasionLoader(self)
__builtin__.loader = self.loader
self.graphicsEngine.setDefaultLoader(self.loader.loader)
self.cam.node().getDisplayRegion(0).setClearDepthActive(1)
from panda3d.core import RenderAttribRegistry
from panda3d.core import ShaderAttrib, TransparencyAttrib
from libpandabsp import BSPMaterialAttrib
attribRegistry = RenderAttribRegistry.getGlobalPtr()
attribRegistry.setSlotSort(BSPMaterialAttrib.getClassSlot(), 0)
attribRegistry.setSlotSort(ShaderAttrib.getClassSlot(), 1)
attribRegistry.setSlotSort(TransparencyAttrib.getClassSlot(), 2)
gsg = self.win.getGsg()
# Let's print out the Graphics information.
self.notify.info(
'Graphics Information:\n\tVendor: {0}\n\tRenderer: {1}\n\tVersion: {2}\n\tSupports Cube Maps: {3}\n\tSupports 3D Textures: {4}\n\tSupports Compute Shaders: {5}'
.format(gsg.getDriverVendor(), gsg.getDriverRenderer(),
gsg.getDriverVersion(), str(gsg.getSupportsCubeMap()),
str(gsg.getSupports3dTexture()),
str(gsg.getSupportsComputeShaders())))
# Enable shader generation on all of the main scenes
if gsg.getSupportsBasicShaders() and gsg.getSupportsGlsl():
render.setShaderAuto()
render2d.setShaderAuto()
render2dp.setShaderAuto()
else:
# I don't know how this could be possible
self.notify.error("GLSL shaders unsupported by graphics driver.")
return
# Let's disable fog on Intel graphics
if gsg.getDriverVendor() == "Intel":
metadata.NO_FOG = 1
self.notify.info('Applied Intel-specific graphical fix.')
self.win.disableClears()
self.camNode.setCameraMask(CIGlobals.MainCameraBitmask)
from direct.distributed.ClockDelta import globalClockDelta
__builtin__.globalClockDelta = globalClockDelta
# Any ComputeNodes should be parented to this node, not render.
# We isolate ComputeNodes to avoid traversing the same ComputeNodes
# when doing multi-pass rendering.
self.computeRoot = NodePath('computeRoot')
self.computeCam = self.makeCamera(base.win)
self.computeCam.node().setCullBounds(OmniBoundingVolume())
self.computeCam.node().setFinal(True)
self.computeCam.reparentTo(self.computeRoot)
# Initialized in initStuff()
self.shaderGenerator = None
render.hide()
self.camLens.setNearFar(0.5, 10000)
self.physicsWorld = BulletWorld()
# Panda units are in feet, so the gravity is 32 feet per second,
# not 9.8 meters per second.
self.physicsWorld.setGravity(Vec3(0, 0, -32.1740))
self.physicsWorld.setGroupCollisionFlag(7, 1, True)
self.physicsWorld.setGroupCollisionFlag(7, 2, True)
self.physicsWorld.setGroupCollisionFlag(7, 3, False)
self.physicsWorld.setGroupCollisionFlag(7, 4, False)
self.physicsWorld.setGroupCollisionFlag(7, 8, True)
self.taskMgr.add(self.__physicsUpdate, "physicsUpdate", sort=30)
debugNode = BulletDebugNode('Debug')
self.debugNP = render.attachNewNode(debugNode)
self.physicsWorld.setDebugNode(self.debugNP.node())
self.physicsDbgFlag = False
self.setPhysicsDebug(self.config.GetBool('physics-debug', False))
#self.shadowCaster = ShadowCaster(Vec3(163, -67, 0))
#self.shadowCaster.enable()
self.bspLoader.setGamma(2.2)
self.bspLoader.setWin(self.win)
self.bspLoader.setCamera(self.camera)
self.bspLoader.setRender(self.render)
self.bspLoader.setMaterialsFile("phase_14/etc/materials.txt")
#self.bspLoader.setTextureContentsFile("phase_14/etc/texturecontents.txt")
self.bspLoader.setWantVisibility(True)
self.bspLoader.setVisualizeLeafs(False)
self.bspLoader.setWantLightmaps(True)
#self.bspLoader.setShadowCamPos(Point3(-15, 5, 40))
#self.bspLoader.setShadowResolution(60 * 2, 1024 * 1)
self.bspLoader.setPhysicsWorld(self.physicsWorld)
self.bspLevel = None
self.materialData = {}
self.skyBox = None
self.skyBoxUtil = None
#self.nmMgr = RNNavMeshManager.get_global_ptr()
#self.nmMgr.set_root_node_path(self.render)
#self.nmMgr.get_reference_node_path().reparentTo(self.render)
#self.nmMgr.start_default_update()
#self.nmMgr.get_reference_node_path_debug().reparentTo(self.render)
self.navMeshNp = None
# Setup 3d audio run before igLoop so 3d positioning doesn't lag behind
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera, render)
base.audio3d.setDropOffFactor(0.15)
base.audio3d.setDopplerFactor(0.15)
# Setup collision handlers
base.cTrav = CollisionTraverser()
base.lifter = CollisionHandlerFloor()
base.pusher = CollisionHandlerPusher()
base.queue = CollisionHandlerQueue()
base.lightingCfg = None
self.cl_attackMgr = None
#self.accept('/', self.projectShadows)
# Let's setup the user input storage system
uis = UserInputStorage()
self.inputStore = uis
self.userInputStorage = uis
__builtin__.inputStore = uis
__builtin__.userInputStorage = uis
self.credits2d = self.render2d.attachNewNode(PGTop("credits2d"))
self.credits2d.setScale(1.0 / self.getAspectRatio(), 1.0, 1.0)
self.wakeWaterHeight = -30.0
self.bloomToggle = False
self.hdrToggle = False
self.fxaaToggle = CIGlobals.getSettingsMgr().getSetting(
"aa").getValue() == "FXAA"
self.aoToggle = False
self.music = None
self.currSongName = None
render.show(CIGlobals.ShadowCameraBitmask)
self.avatars = []
wrm = WaterReflectionManager()
self.waterReflectionMgr = wrm
__builtin__.waterReflectionMgr = wrm
# Let's setup our margins
base.marginManager = MarginManager()
base.margins = aspect2d.attachNewNode(
base.marginManager, DirectGuiGlobals.MIDGROUND_SORT_INDEX + 1)
base.leftCells = [
base.marginManager.addCell(0.1, -0.6, base.a2dTopLeft),
base.marginManager.addCell(0.1, -1.0, base.a2dTopLeft),
base.marginManager.addCell(0.1, -1.4, base.a2dTopLeft)
]
base.bottomCells = [
base.marginManager.addCell(0.4, 0.1, base.a2dBottomCenter),
base.marginManager.addCell(-0.4, 0.1, base.a2dBottomCenter),
base.marginManager.addCell(-1.0, 0.1, base.a2dBottomCenter),
base.marginManager.addCell(1.0, 0.1, base.a2dBottomCenter)
]
base.rightCells = [
base.marginManager.addCell(-0.1, -0.6, base.a2dTopRight),
base.marginManager.addCell(-0.1, -1.0, base.a2dTopRight),
base.marginManager.addCell(-0.1, -1.4, base.a2dTopRight)
]
base.mouseWatcherNode.setEnterPattern('mouse-enter-%r')
base.mouseWatcherNode.setLeavePattern('mouse-leave-%r')
base.mouseWatcherNode.setButtonDownPattern('button-down-%r')
base.mouseWatcherNode.setButtonUpPattern('button-up-%r')
cbm = CullBinManager.getGlobalPtr()
cbm.addBin('ground', CullBinManager.BTUnsorted, 18)
# The portal uses the shadow bin by default,
# but we still want to see it with real shadows.
cbm.addBin('portal', CullBinManager.BTBackToFront, 19)
if not metadata.USE_REAL_SHADOWS:
cbm.addBin('shadow', CullBinManager.BTBackToFront, 19)
else:
cbm.addBin('shadow', CullBinManager.BTFixed, -100)
cbm.addBin('gui-popup', CullBinManager.BTUnsorted, 60)
cbm.addBin('gsg-popup', CullBinManager.BTFixed, 70)
self.setBackgroundColor(CIGlobals.DefaultBackgroundColor)
self.disableMouse()
self.enableParticles()
base.camLens.setNearFar(CIGlobals.DefaultCameraNear,
CIGlobals.DefaultCameraFar)
base.transitions = CITransitions(loader)
base.transitions.IrisModelName = "phase_3/models/misc/iris.bam"
base.transitions.FadeModelName = "phase_3/models/misc/fade.bam"
self.accept(self.inputStore.TakeScreenshot,
ScreenshotHandler.takeScreenshot)
#self.accept('u', render.setShaderOff)
#self.accept('i', render.setShaderOff, [1])
#self.accept('o', render.setShaderOff, [2])
# Disabled oobe culling
#self.accept('o', self.oobeCull)
#self.accept('c', self.reportCam)
self.taskMgr.add(self.__updateShadersAndPostProcess,
'CIBase.updateShadersAndPostProcess', 47)
self.taskMgr.add(self.__update3DAudio, 'CIBase.update3DAudio', 59)
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
self.orbCollisionHandler = CollisionHandlerQueue()
self.cTrav = CollisionTraverser()
self.cTrav.setRespectPrevTransform(True)
self.startgame = False
self.sound=loader.loadSfx("models/0614.ogg")
self.sound2=loader.loadSfx("models/01-main-theme.mp3")
self.sound2.play()
status=self.sound2.status()
#hbPath = NodePath()
utils.setUpKeys(self)
utils.loadModels(self)
utils.setUpLighting(self)
#utils.setUpFloatingSpheres(self)
utils.setUpRalphsShot(self)
utils.setUpCamera(self)
utils.setUpCollisionSpheres(self)
self.healthTxt = utils.addInstructions(.06,"Health: 100")
self.orbTxt = utils.addInstructions(.18,"Orbs: 0")
self.hitsTxt = utils.addInstructions(.28,"Enemy Hits: 0")
self.strHealthStatus = str(self.healthTxt)
# Create a frame
frame = DirectFrame(text = "main", scale = 0.001)
# Add button
self.flagstartbutton = 0
self.imageObject = OnscreenImage(image = 'models/instapage.jpg', pos = (0, 0, 0), scale=1.1)
self.imageObject2 = OnscreenImage(image = 'models/gap.jpg', pos = (-2.15, 0, 0), scale=1.1)
self.imageObject3 = OnscreenImage(image = 'models/gap.jpg', pos = (2.15, 0, 0), scale=1.1)
self.helpOn = DirectButton(text = ("Start", "on/off", "Start", "disabled"), scale=.10, pos=(-1.1,0,-.9), command=utils.buttonClickedOn, extraArgs=[self, self.imageObject,self.imageObject2,self.imageObject3, self.flagstartbutton])
#helpOff = DirectButton(text = ("helpOff", "on/off", "helpOff", "disabled"), scale=.10, pos=(-0.5,0,-1), command=utils.buttonClickedOff, extraArgs=[self, self.imageObject, self.buttonflag])
# mytimer = DirectLabel()
# mytimer.reparentTo(render)
# mytimer.setY(7)
#Create 4 buttons
#print self.strHealthStatus
#incBar(100)
self.vec = LVector3(0,1,0)#vector for pawns shot
# Create a frame
#frame = DirectFrame(text = "main", scale = 0.001)
# Add button
#bar = DirectWaitBar(text = "", value = 50, pos = (0,.4,.4))
#bar.reparent(render)
# Game state variables
self.isMoving = False
self.jumping = False
self.vz = 0
self.numOrbs = 0
self.healthCount = 100
self.enemyhits = 0
#self.shotList = []
#self.sphere = CollisionBox((self.ralph.getX() + -10,self.ralph.getY(),self.ralph.getZ()),10,10,10)
self.ralphBox1 = CollisionBox((0,2.5,3.5),1.5,0.5,1.5)
cnodepath = self.ralph.attachNewNode((CollisionNode("ralphColNode")))
cnodepath.node().addSolid(self.ralphBox1)
cnodepath.node().addSolid(CollisionBox((0,-2.5,3.5),1.5,0.5,1.5))
cnodepath.node().addSolid(CollisionBox((2.5,0,3.5),0.5,1.5,1.5))
cnodepath.node().addSolid(CollisionBox((-2.5,0,3.5),0.5,1.5,1.5))
#cnodepath.show()
#self.cTrav.addCollider(cnodepath, self.orbCollisionHandler)
self.sphere = CollisionSphere(0,-5,4,3)
self.sphere3 = CollisionSphere(0,5,5,3)
self.sphere4 = CollisionSphere(-4,0,5,2)
self.sphere5 = CollisionSphere(4,0,5,2)
self.sphere2 = CollisionSphere(0,0,3,2)
self.cnodePath = self.ralph.attachNewNode((CollisionNode("ralphColNode")))
self.cnodePath2 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck")))
self.cnodePath3 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck2")))
self.cnodePath4 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck3")))
self.cnodePath5 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck4")))
self.cnodePath.node().addSolid(self.sphere2)
self.cnodePath2.node().addSolid(self.sphere)
self.cnodePath3.node().addSolid(self.sphere3)
self.cnodePath4.node().addSolid(self.sphere4)
self.cnodePath5.node().addSolid(self.sphere5)
#self.cnodePath.node().addSolid(self.sphere2)
#self.cnodePath.show()#ralph pusher
#self.cnodePath2.show()
#self.cnodePath3.show()
#self.cnodePath4.show()
#self.cnodePath5.show()
self.cTrav.addCollider(self.cnodePath2, self.orbCollisionHandler)
self.cTrav.addCollider(self.cnodePath3, self.orbCollisionHandler)
self.cTrav.addCollider(self.cnodePath4, self.orbCollisionHandler)
self.cTrav.addCollider(self.cnodePath5, self.orbCollisionHandler)
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(self.cnodePath, self.ralph)
#self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler)
self.cTrav.addCollider(self.cnodePath, self.pusher)
self.chrisLastShotTime = globalClock.getFrameTime()
self.chrisTimer = globalClock.getDt()
#def __init__(self, pos,showbase, colPathName, dir, length):
self.chrisList = [utils.cheken((-249,419,0),self,"chrisColPath0","X",5), #earthroom
utils.chris((-404,343,2),self,"chrisColPath1","X",5), #yellowroom
utils.fetus((-141,-69,1),self,"chrisColPath2","X",5), #lightblueroom
utils.cheken((-277,356,0),self,"chrisColPath3","Y",5), #between earth and y
utils.rose((-102,-5,1),self,"chrisColPath4","Y",5), #between r and lb
utils.cheken((-133,83,0),self,"chrisColPath5","Y",5), #blue hall
utils.fetus((-246,280,1),self,"chrisColPath6","X",5), #earth hall
utils.cheken((-330,241,0),self,"chrisColPath7","X",5), #yellow hall
utils.chris((-60,110,2),self,"chrisColPath8","Y",5), #red hall cheken z 0
utils.fetus((-75,52,1),self, "chrisColPath9", "X", 5),
utils.cheken((-75,141,0),self, "chrisColPath10", "X", 5),
utils.rose((-302,202,1),self,"chrisColPath11","X",5),
utils.chris((-303,304,2),self,"chrisColPath12","Y",5)
]
#rose z = 1
#cheken z = 0
#chris z = 2
#fetus z = 1
#def _init_(self,showbase,pos,color,speed,radius):
self.orbList = [utils.orb(self,( 18, 29,2.5),(1,0,0,1),20,2.5), #first red
utils.orb(self,( -249, 419,2.5),(1,1,1,1),20,2.5),#earthroom
utils.orb(self,( -404, 343,2.5),(1,1,0,1),20,2.5), #yellowroom
utils.orb(self,( -141, -69,2.5),(0,0,1,1),20,2.5),#light blue room
utils.orb(self,( -277, 356,2.5),(1,1,0,1),20,2.5), #between y and earth
utils.orb(self,( -102, -5,2.5),(0,0,1,1),20,2.5), #between red and lb
utils.orb(self,( -135, 22,2.5),(0,0,1,1),20,2.5), #lb hall
utils.orb(self,( -248, 329,2.5),(1,1,1,1),20,2.5), #earthhall
utils.orb(self,( -330, 241,2.5),(1,1,0,1),20,2.5), #yellow hall
utils.orb(self,( -60, 110,2.5),(1,0,0,1),20,2.5) #red hall
]
self.donutList = [utils.donut(self, (0,0,1),20, 2.5),
utils.donut(self,( -330, 250,2.5),20,2.5), #yellow hall
utils.donut(self,( -141, -80,2.5),20,2.5),#light blue room
utils.donut(self,( -249, 430,2.5),20,2.5),#earthroom
utils.donut(self,( -102, -10,2.5),20,2.5), #between red and lb
]
self.cameraCollided = False
self.ralphSpeed = 60
self.ralphHit = False
self.ralphRedTime = 0
self.textTime = -1
self.textTime2 = -1
self.textTime3 = -1
self.mTextPath = utils.addInstructions2(.44,"")
self.mTextPath2 = utils.addInstructions2(.55,"")
self.winText2 = utils.addInstructions2(.55, "")
self.timerText = utils.addInstructions4(.26,"0:00")
self.introText = utils.addInstructions2(.55,"")
self.minutes = 4
self.seconds = 0
self.timerTime = globalClock.getFrameTime()
taskMgr.add(self.move, "moveTask")
taskMgr.add(self.moveChris,"moveChrisTask")
taskMgr.add(self.timerTask,"timerTask")
class RoamingRalphDemo(ShowBase):
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
#self.setupCD()
# Set the background color to black
# self.win.setClearColor((0.6, 0.6, 1.0, 1.0))
# self.fog = Fog('myFog')
# self.fog.setColor(0, 0, 0)
# self.fog.setExpDensity(.05)
# render.setFog(self.fog)
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0, "right": 0, "forward": 0, "cam-left": 0, "cam-right": 0, "c":0, "back":0, "space":0}
# Post the instructions
#self.title = addTitle(
# "Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.06, "[ESC]: Quit")
self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward")
#self.inst6 = addInstructions(0.30, "[A]: Rotate Camera Left")
#self.inst7 = addInstructions(0.36, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
#self.environ.reparentTo(render)
self.room = loader.loadModel("models/room2.egg")
self.room.reparentTo(render)
#self.room.setScale(.1)
self.room.setPos(0,0,-5)
self.room.setShaderAuto()
#self.room.writeBamFile("myRoom1.bam")
#self.room.setColor(1,.3,.3,1)
self.room2 = loader.loadModel("models/abstractroom2")
self.room2.reparentTo(render)
self.room2.setScale(.1)
self.room2.setPos(-12,0,0)
# Create the main character, Ralph
#ralphStartPos = LVecBase3F(0,0,0) #self.room.find("**/start_point").getPos()
self.ralph = Actor("models/ralph",
{"run": "models/ralph-run",
"walk": "models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(0,0,0)
#cs = CollisionSphere(0, 0, 0, 1)
#cnodePath = self.ralph.attachNewNode(CollisionNode('cnode'))
#cnodePath.node().addSolid(cs)
#cnodePath.node().setPos(0,0,0)
#cnodePath.show()
self.gianteye = loader.loadModel("models/gianteye")
self.gianteye.reparentTo(render)
self.gianteye.setScale(.1)
self.gianteye.setPos(10,10,0)
#self.bluefinal = loader.loadModel("models/chrysalis")
#self.bluefinal.reparentTo(render)
#self.bluefinal.setScale(.1)
#self.bluefinal.setPos(7,7,0)
#self.blue = loader.loadModel("models/blue1")
#self.blue.reparentTo(render)
#self.blue.setScale(.1)
#self.blue.setPos(10,5,0)
self.chik = loader.loadModel("models/chik")
self.chik.reparentTo(render)
self.chik.setScale(.1)
self.chik.setPos(3,13,0)
self.pawn = loader.loadModel("pawn")
self.pawn.reparentTo(render)
self.pawn.setPos(0,0,0)
self.shot = loader.loadModel("models/icosphere.egg")
self.shot.reparentTo(render)
self.shot.setScale(.5)
self.shot.setPos(0,0,1)
self.shot.setColor(1,.3,.3,1)
self.myShot = loader.loadModel("models/icosphere.egg")
#self.myShot.reparentTo(render)
self.myShot.setScale(.1)
self.myShot.setPos(0,0,1)
self.myShotVec = LVector3(0,0,0)
self.lightpivot3 = render.attachNewNode("lightpivot3")
self.lightpivot3.setPos(0, 0, 0)
self.lightpivot3.hprInterval(10, LPoint3(0, 0, 0)).loop()
plight3 = PointLight('plight2')
plight3.setColor((0, .3,0, 1))
plight3.setAttenuation(LVector3(0.7, 0.05, 0))
plnp3 = self.lightpivot3.attachNewNode(plight3)
plnp3.setPos(0, 0, 0)
self.room2.setLight(plnp3)
self.room.setLight(plnp3)
sphere3 = loader.loadModel("models/icosphere")
sphere3.reparentTo(plnp3)
sphere3.setScale(0.1)
sphere3.setColor((0,1,0,1))
# Create a floater object, which floats 2 units above ralph. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(8.0)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("arrow_down", self.setKey, ["back", True])
self.accept("a", self.setKey, ["cam-left", True])
self.accept("s", self.setKey, ["cam-right", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["back", False])
self.accept("a-up", self.setKey, ["cam-left", False])
self.accept("s-up", self.setKey, ["cam-right", False])
self.accept("space", self.setKey, ["space", True])
self.accept("space-up", self.setKey, ["space", False])
self.accept("c",self.setKey,["c",True])
self.accept("c-up",self.setKey,["c",False])
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
self.jumping = False
self.vz = 0
# Set up the camera
self.disableMouse()
self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 7, 3)
self.camLens.setFov(60)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
def setupCollision(self):
cs = CollisionSphere(0,0,2,1)
cnodePath = self.ralph.attachNewNode(CollisionNode('cnode'))
cnodePath.node().addSolid(cs)
cnodePath.show()
#for o in self.OBS:
#ct = CollisionTube(0,0,0, 0,0,1, 0.5)
#cn = o.attachNewNode(CollisionNode('ocnode'))
#cn.node().addSolid(ct)
#cn.show()
eyecs = CollisionSphere(0,0,4,5)
cnodePath = self.gianteye.attachNewNode(CollisionNode('cnode'))
cnodePath.node().addSolid(eyecs)
cnodePath.show()
eyecs = CollisionSphere(0,0,4,2)
cnodePath = self.chik.attachNewNode(CollisionNode('cnode'))
cnodePath.node().addSolid(eyecs)
cnodePath.show()
pusher = CollisionHandlerPusher()
pusher.addCollider(cnodePath, self.player)
self.cTrav = CollisionTraverser()
self.cTrav.add_collider(cnodePath,pusher)
self.cTrav.showCollisions(render)
self.walls = self.room2.find("**/wall_collide")
#self.walls.node().setIntoCollideMask(BitMask32.bit(0))
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 9)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0))
self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 9)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(CollideMask.bit(0))
self.camGroundCol.setIntoCollideMask(CollideMask.allOff())
self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
self.sphere = CollisionSphere(0,0,4,2)
self.sphere2 = CollisionSphere(0,0,2,2)
self.cnodePath = self.ralph.attachNewNode((CollisionNode('cnode')))
self.cnodePath.node().addSolid(self.sphere)
self.cnodePath.node().addSolid(self.sphere2)
self.cnodePath.show()
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(self.cnodePath, self.ralph)
self.cTrav.add_collider(self.cnodePath, self.pusher)
self.eyecs = CollisionSphere(0,0,22,25)
self.cnodePath1 = self.gianteye.attachNewNode(CollisionNode('cnode'))
self.cnodePath1.node().addSolid(self.eyecs)
self.cnodePath1.show()
self.pusher1 = CollisionHandlerPusher()
self.pusher1.addCollider(self.cnodePath1, self.gianteye)
self.cTrav.add_collider(self.cnodePath1, self.pusher1)
self.cTrav.showCollisions(render)
self.eyeGroundRay = CollisionRay()
self.eyeGroundRay.setOrigin(0, 0, 9)
self.eyeGroundRay.setDirection(0, 0, -1)
self.eyeGroundCol = CollisionNode('eyeRay')
self.eyeGroundCol.addSolid(self.eyeGroundRay)
self.eyeGroundCol.setFromCollideMask(CollideMask.bit(0))
self.eyeGroundCol.setIntoCollideMask(CollideMask.allOff())
self.eyeGroundColNp = self.gianteye.attachNewNode(self.eyeGroundCol)
self.eyeGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.eyeGroundColNp, self.eyeGroundHandler)
self.chikcs = CollisionSphere(0,0,11,20)
self.cnodePath2 = self.chik.attachNewNode(CollisionNode('cnode'))
self.cnodePath2.node().addSolid(self.chikcs)
self.cnodePath2.show()
self.pusher2 = CollisionHandlerPusher()
self.pusher2.addCollider(self.cnodePath, self.chik)
self.cTrav.add_collider(self.cnodePath, self.pusher2)
self.cTrav.showCollisions(render)
self.chikGroundRay = CollisionRay()
self.chikGroundRay.setOrigin(0, 0, 9)
self.chikGroundRay.setDirection(0, 0, -1)
self.chikGroundCol = CollisionNode('chikRay')
self.chikGroundCol.addSolid(self.chikGroundRay)
self.chikGroundCol.setFromCollideMask(CollideMask.bit(0))
self.chikGroundCol.setIntoCollideMask(CollideMask.allOff())
self.chikGroundColNp = self.chik.attachNewNode(self.chikGroundCol)
self.chikGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.chikGroundColNp, self.chikGroundHandler)
# Uncomment this line to see the collision rays
self.ralphGroundColNp.show()
self.camGroundColNp.show()
#self.ralphroom1ColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, .4))
ambientLight2 = AmbientLight("ambientLight2")
ambientLight2.setColor((1, 1, 1, 10))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((0, 0, -2))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
#self.environ.setLight(self.environ.attachNewNode(ambientLight2))
render.setLight(render.attachNewNode(directionalLight))
# Add a light to the scene.
self.lightpivot = render.attachNewNode("lightpivot")
self.lightpivot.setPos(0, 0, 1.6)
self.lightpivot.hprInterval(20, LPoint3(360, 0, 0)).loop()
plight = PointLight('plight')
plight.setColor((.7, .3, 0, 1))
plight.setAttenuation(LVector3(0.7, 0.05, 0))
plnp = self.lightpivot.attachNewNode(plight)
plnp.setPos(5, 0, 0)
self.room.setLight(plnp)
sphere = loader.loadModel("models/icosphere")
sphere.reparentTo(plnp)
sphere.setScale(0.1)
sphere.setColor((1,1,0,1))
self.lightpivot2 = render.attachNewNode("lightpivot")
self.lightpivot2.setPos(-16, 0, 1.6)
self.lightpivot2.hprInterval(20, LPoint3(360, 0, 0)).loop()
plight2 = PointLight('plight2')
plight2.setColor((0, .4,.8, 1))
plight2.setAttenuation(LVector3(0.7, 0.05, 0))
plnp2 = self.lightpivot2.attachNewNode(plight2)
plnp2.setPos(5, 0, 0)
self.room2.setLight(plnp2)
sphere2 = loader.loadModel("models/icosphere")
sphere2.reparentTo(plnp2)
sphere2.setScale(0.2)
sphere2.setColor((0,0,1,1))
self.vec = LVector3(0,1,0)
# Records the state of the arrow keys
def setKey(self, key, value):
self.keyMap[key] = value
# Accepts arrow keys to move either the player or the menu cursor,
# Also deals with grid checking and collision detection
def move(self, task):
# Get the time that elapsed since last frame. We multiply this with
# the desired speed in order to find out with which distance to move
# in order to achieve that desired speed.
dt = globalClock.getDt()
# If the camera-left key is pressed, move camera left.
# If the camera-right key is pressed, move camera right.
if self.keyMap["cam-left"]:
self.camera.setZ(self.camera, -20 * dt)
if self.keyMap["cam-right"]:
self.camera.setZ(self.camera, +20 * dt)
# save ralph's initial position so that we can restore it,
# in case he falls off the map or runs into something.
startpos = self.ralph.getPos()
# If a move-key is pressed, move ralph in the specified direction.
if self.keyMap["left"]:
self.ralph.setH(self.ralph.getH() + 150 * dt)
#self.floater.setH(self.floater.getH() + 300 * dt)
self.camera.setX(self.camera, +15.5 * dt)
if self.keyMap["right"]:
self.ralph.setH(self.ralph.getH() - 150 * dt)
self.camera.setX(self.camera, -15.5 * dt)
if self.keyMap["forward"]:
self.ralph.setY(self.ralph, -35 * dt)
if self.keyMap["back"]:
self.ralph.setY(self.ralph, +35 * dt)
if self.keyMap["c"]:
if self.jumping is False:
#self.ralph.setH(self.ralph.getH() + 300 * dt)
#self.ralph.setZ(self.ralph.getZ() + 100 * dt)
self.jumping = True
self.vz = 7
if self.keyMap["space"]:
self.lightpivot3.setPos(self.ralph.getPos())
self.lightpivot3.setZ(self.ralph.getZ() + .5)
self.lightpivot3.setX(self.ralph.getX() - .25)
#self.myShot.setHpr(self.ralph.getHpr())
#parent
node = NodePath("tmp")
node.setHpr(self.ralph.getHpr())
vec = render.getRelativeVector(node,(0,-1,0))
self.myShotVec = vec
self.lightpivot3.setPos(self.lightpivot3.getPos() + self.myShotVec * dt * 15 )
if self.jumping is True:
self.vz = self.vz - 16* dt
self.ralph.setZ(self.ralph.getZ() + self.vz * dt )
entries = list(self.ralphGroundHandler.getEntries())
entries.sort(key=lambda x: x.getSurfacePoint(render).getZ())
if len(entries) > 0 :
if self.ralph.getZ() < 0:#entries[0].getSurfacePoint(render).getZ():
#self.ralph.setZ(entries[0].getSurfacePoint(render).getZ())
self.ralph.setZ(0)
self.jumping = False
# If ralph is moving, loop the run animation.
# If he is standing still, stop the animation.
if self.keyMap["forward"] or self.keyMap["left"] or self.keyMap["right"] or self.keyMap["c"] or self.keyMap["forward"] or self.keyMap["back"]:
if self.isMoving is False:
self.ralph.loop("run")
self.isMoving = True
else:
if self.isMoving:
self.ralph.stop()
self.ralph.pose("walk", 5)
self.isMoving = False
node = NodePath("tmp")
node.setHpr(self.ralph.getHpr())
vec = render.getRelativeVector(node,(1,0,0))
#self.ralph.setPos(self.ralph.getPos() + vec * dt * 20)
node = NodePath("tmp")
#self.pawn.getH()
node.setHpr(self.pawn.getHpr())
vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0))
self.shot.setPos(self.shot.getPos() + self.vec * dt * 10 )
if self.shot.getY() < -15 or self.shot.getY() > 15 or self.shot.getX() < -15 or self.shot.getX() > 15:
self.shot.setPos(self.pawn.getPos() + (0,0,0))
self.vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0))
self.vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0))
# If the camera is too far from ralph, move it closer.
# If the camera is too close to ralph, move it farther.
camvec = self.ralph.getPos() - self.camera.getPos()
#camvec.setZ(self.camera.getZ())
camdist = camvec.length()
x = self.camera.getZ()
camvec.normalize()
if camdist > 6.0:
self.camera.setPos(self.camera.getPos() + camvec * (camdist - 6))
camdist = 10.0
#self.camera.setZ(self.camera, x)
if camdist < 6.0:
self.camera.setPos(self.camera.getPos() - camvec * (6 - camdist))
camdist = 5.0
#self.camera.setZ(self.camera, x)
# Normally, we would have to call traverse() to check for collisions.
# However, the class ShowBase that we inherit from has a task to do
# this for us, if we assign a CollisionTraverser to self.cTrav.
#self.cTrav.traverse(render)
# Adjust ralph's Z coordinate. If ralph's ray hit terrain,
# update his Z. If it hit anything else, or didn't hit anything, put
# him back where he was last frame.
entries = list(self.ralphGroundHandler.getEntries())
entries.sort(key=lambda x: x.getSurfacePoint(render).getZ())
if self.jumping == False:
if len(entries) > 0:# and entries[0].getIntoNode().getName() == "terrain":
#self.ralph.setZ(entries[0].getSurfacePoint(render).getZ())
pass
else:
self.ralph.setPos(startpos)
# Keep the camera at one foot above the terrain,
# or two feet above ralph, whichever is greater.
entries = list(self.camGroundHandler.getEntries())
entries.sort(key=lambda x: x.getSurfacePoint(render).getZ())
#if len(entries) > 0 and entries[0].getIntoNode().getName() == "ground":
#self.camera.setZ(entries[0].getSurfacePoint(render).getZ() + 1.5)
if self.camera.getZ() < self.ralph.getZ() + 1 or self.camera.getZ() > self.ralph.getZ() + 1:
self.camera.setZ(self.ralph.getZ() + 1)
#self.camera.setZ(self.ralph.getZ() + 1.5)
#self.camera.setP(self.camera, 130)
# The camera should look in ralph's direction,
# but it should also try to stay horizontal, so look at
# a floater which hovers above ralph's head.
self.camera.lookAt(self.floater)
return task.cont
def startGame(self):
# remove menu main elements
if hasattr(game, "startBtn"):
self.startBtn.destroy()
if hasattr(game, "gameNameText"):
self.gameNameText.destroy()
if hasattr(game, "controlsText"):
self.controlsText.destroy()
if self.startAudio.status() == self.startAudio.PLAYING:
self.startAudio.stop()
self.gameAudio.play()
# HUD information (time, health)
self.time_text = addInstruction((-1.2, 0.9), "Time Reamining :: %i" % TIME)
self.health_text = addInstruction((0.9, 0.9), "Health :: %i" % HEALTH)
# the environment
self.env = loader.loadModel("../assets/models/world")
self.env.reparentTo(render)
self.env.setPos(0, 0, 0)
# the flag(destination)
self.flag = loader.loadModel("../assets/models/flag/flag")
self.flag.reparentTo(render)
self.flag.setScale(0.1)
self.flag.setPos(0, 0, 5)
self.DESTINATION = self.flag.getPos()
# main character(sonic)
self.START = self.env.find("**/start_point").getPos()
self.sonic = Actor(
"../assets/models/sonic/sonic",
{
"run": "../assets/models/sonic/sonic-run",
"win": "../assets/models/sonic/sonic-win",
"board": "../assets/models/sonic/sonic-board",
"fwboard": "../assets/models/sonic/sonic-fallingwboard",
"fwoboard": "../assets/models/sonic/sonic-fallingwoboard",
},
)
self.sonic.reparentTo(render)
self.sonic.setScale(0.05)
self.sonic.setPos(self.START)
# create a floater object to be used as a temporary
# variable in a variety of calculations
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
taskMgr.add(self.move, "moveTask")
# varible to keep track of moving state
self.isMoving = False
# variable to keep track of speed boost
self.speedBoost = False
# variable to keep track of invulnerability
self.invul = False
# setup the camera
base.disableMouse()
base.camera.setPos(self.sonic.getX(), self.sonic.getY() + 10, 2)
self.cTrav = CollisionTraverser()
# self.pusher = CollisionHandlerPusher()
self.sonicGroundRay = CollisionRay()
self.sonicGroundRay.setOrigin(0, 0, 1000)
self.sonicGroundRay.setDirection(0, 0, -1)
self.sonicGroundCol = CollisionNode("sonicRay")
self.sonicGroundCol.addSolid(self.sonicGroundRay)
# self.sonicGroundCol.addSolid(CollisionSphere(0, 0, 1.5, 1.5))
self.sonicGroundCol.setFromCollideMask(BitMask32.bit(0))
self.sonicGroundCol.setIntoCollideMask(BitMask32.allOff())
self.sonicGroundColNp = self.sonic.attachNewNode(self.sonicGroundCol)
self.sonicGroundHandler = CollisionHandlerQueue()
self.sonicPusher = CollisionHandlerPusher()
self.sonicPusher.addInPattern("%fn-into-%in")
self.cTrav.addCollider(self.sonicGroundColNp, self.sonicGroundHandler)
# self.cTrav.addCollider(self.sonicGroundColNp, self.sonicPusher)
# self.sonicPusher.addCollider(self.sonicGroundColNp, self.sonic)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 1000)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode("camRay")
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# see the collision rays
# self.sonicGroundColNp.show()
# self.camGroundColNp.show()
# visual representation of the collisions occuring
# self.cTrav.showCollisions(render)
# create AI characters
self.createTrexAI()
self.createMilesAI()
# place the presents
self.createPresents()
# check winning condition
taskMgr.add(self.checkWin, "checkWin")
# check time conditions
taskMgr.add(self.checkTime, "checkTime")
# check health conditions
taskMgr.add(self.checkGameOver, "checkGameOver")
# check other conditions
taskMgr.add(self.checkConditions, "checkConditions")
taskMgr.add(self.checkSpeed, "checkSpeed")
taskMgr.add(self.checkSpeed2, "checkSpeed2")
taskMgr.add(self.checkHealthBoost, "checkHealthBoost")
taskMgr.add(self.checkTimeAdd, "checkTimeAdd")
class Game(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
self.exitFunc = self.cleanup
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
render.setShaderAuto()
self.environment = loader.loadModel("Models/Misc/environment")
self.environment.reparentTo(render)
self.camera.setPos(0, 0, 32)
self.camera.setP(-90)
self.keyMap = {
"up" : False,
"down" : False,
"left" : False,
"right" : False,
"shoot" : False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.pusher = CollisionHandlerPusher()
self.cTrav = CollisionTraverser()
self.pusher.setHorizontal(True)
self.pusher.add_in_pattern("%fn-into-%in")
self.accept("trapEnemy-into-wall", self.stopTrap)
self.accept("trapEnemy-into-trapEnemy", self.stopTrap)
self.accept("trapEnemy-into-player", self.trapHitsSomething)
self.accept("trapEnemy-into-walkingEnemy", self.trapHitsSomething)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
self.updateTask = taskMgr.add(self.update, "update")
self.player = None
self.enemies = []
self.trapEnemies = []
self.deadEnemies = []
self.spawnPoints = []
numPointsPerWall = 5
for i in range(numPointsPerWall):
coord = 7.0/numPointsPerWall + 0.5
self.spawnPoints.append(Vec3(-7.0, coord, 0))
self.spawnPoints.append(Vec3(7.0, coord, 0))
self.spawnPoints.append(Vec3(coord, -7.0, 0))
self.spawnPoints.append(Vec3(coord, 7.0, 0))
self.initialSpawnInterval = 1.0
self.minimumSpawnInterval = 0.2
self.spawnInterval = self.initialSpawnInterval
self.spawnTimer = self.spawnInterval
self.maxEnemies = 2
self.maximumMaxEnemies = 20
self.numTrapsPerSide = 2
self.difficultyInterval = 5.0
self.difficultyTimer = self.difficultyInterval
self.enemySpawnSound = loader.loadSfx("Sounds/enemySpawn.ogg")
self.gameOverScreen = DirectDialog(frameSize = (-0.7, 0.7, -0.7, 0.7),
fadeScreen = 0.4,
relief = DGG.FLAT,
frameTexture = "UI/stoneFrame.png")
self.gameOverScreen.hide()
self.font = loader.loadFont("Fonts/Wbxkomik.ttf")
buttonImages = (
loader.loadTexture("UI/UIButton.png"),
loader.loadTexture("UI/UIButtonPressed.png"),
loader.loadTexture("UI/UIButtonHighlighted.png"),
loader.loadTexture("UI/UIButtonDisabled.png")
)
label = DirectLabel(text = "Game Over!",
parent = self.gameOverScreen,
scale = 0.1,
pos = (0, 0, 0.2),
text_font = self.font,
relief = None)
self.finalScoreLabel = DirectLabel(text = "",
parent = self.gameOverScreen,
scale = 0.07,
pos = (0, 0, 0),
text_font = self.font,
relief = None)
btn = DirectButton(text = "Restart",
command = self.startGame,
pos = (-0.3, 0, -0.2),
parent = self.gameOverScreen,
scale = 0.07,
text_font = self.font,
clickSound = loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture = buttonImages,
frameSize = (-4, 4, -1, 1),
text_scale = 0.75,
relief = DGG.FLAT,
text_pos = (0, -0.2))
btn.setTransparency(True)
btn = DirectButton(text = "Quit",
command = self.quit,
pos = (0.3, 0, -0.2),
parent = self.gameOverScreen,
scale = 0.07,
text_font = self.font,
clickSound = loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture = buttonImages,
frameSize = (-4, 4, -1, 1),
text_scale = 0.75,
relief = DGG.FLAT,
text_pos = (0, -0.2))
btn.setTransparency(True)
self.titleMenuBackdrop = DirectFrame(frameColor = (0, 0, 0, 1),
frameSize = (-1, 1, -1, 1),
parent = render2d)
self.titleMenu = DirectFrame(frameColor = (1, 1, 1, 0))
title = DirectLabel(text = "Panda-chan",
scale = 0.1,
pos = (0, 0, 0.9),
parent = self.titleMenu,
relief = None,
text_font = self.font,
text_fg = (1, 1, 1, 1))
title2 = DirectLabel(text = "and the",
scale = 0.07,
pos = (0, 0, 0.79),
parent = self.titleMenu,
text_font = self.font,
frameColor = (0.5, 0.5, 0.5, 1))
title3 = DirectLabel(text = "Endless Horde",
scale = 0.125,
pos = (0, 0, 0.65),
parent = self.titleMenu,
relief = None,
text_font = self.font,
text_fg = (1, 1, 1, 1))
btn = DirectButton(text = "Start Game",
command = self.startGame,
pos = (0, 0, 0.2),
parent = self.titleMenu,
scale = 0.1,
text_font = self.font,
clickSound = loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture = buttonImages,
frameSize = (-4, 4, -1, 1),
text_scale = 0.75,
relief = DGG.FLAT,
text_pos = (0, -0.2))
btn.setTransparency(True)
btn = DirectButton(text = "Quit",
command = self.quit,
pos = (0, 0, -0.2),
parent = self.titleMenu,
scale = 0.1,
text_font = self.font,
clickSound = loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture = buttonImages,
frameSize = (-4, 4, -1, 1),
text_scale = 0.75,
relief = DGG.FLAT,
text_pos = (0, -0.2))
btn.setTransparency(True)
music = loader.loadMusic("Music/Defending-the-Princess-Haunted.ogg")
music.setLoop(True)
music.setVolume(0.075)
music.play()
def startGame(self):
self.titleMenu.hide()
self.titleMenuBackdrop.hide()
self.gameOverScreen.hide()
self.cleanup()
self.player = Player()
self.maxEnemies = 2
self.spawnInterval = self.initialSpawnInterval
self.difficultyTimer = self.difficultyInterval
sideTrapSlots = [
[],
[],
[],
[]
]
trapSlotDistance = 0.4
slotPos = -8 + trapSlotDistance
while slotPos < 8:
if abs(slotPos) > 1.0:
sideTrapSlots[0].append(slotPos)
sideTrapSlots[1].append(slotPos)
sideTrapSlots[2].append(slotPos)
sideTrapSlots[3].append(slotPos)
slotPos += trapSlotDistance
for i in range(self.numTrapsPerSide):
slot = sideTrapSlots[0].pop(random.randint(0, len(sideTrapSlots[0])-1))
trap = TrapEnemy(Vec3(slot, 7.0, 0))
self.trapEnemies.append(trap)
slot = sideTrapSlots[1].pop(random.randint(0, len(sideTrapSlots[1])-1))
trap = TrapEnemy(Vec3(slot, -7.0, 0))
self.trapEnemies.append(trap)
slot = sideTrapSlots[2].pop(random.randint(0, len(sideTrapSlots[2])-1))
trap = TrapEnemy(Vec3(7.0, slot, 0))
trap.moveInX = True
self.trapEnemies.append(trap)
slot = sideTrapSlots[3].pop(random.randint(0, len(sideTrapSlots[3])-1))
trap = TrapEnemy(Vec3(-7.0, slot, 0))
trap.moveInX = True
self.trapEnemies.append(trap)
def updateKeyMap(self, controlName, controlState):
self.keyMap[controlName] = controlState
def spawnEnemy(self):
if len(self.enemies) < self.maxEnemies:
spawnPoint = random.choice(self.spawnPoints)
newEnemy = WalkingEnemy(spawnPoint)
self.enemies.append(newEnemy)
self.enemySpawnSound.play()
def stopTrap(self, entry):
collider = entry.getFromNodePath()
if collider.hasPythonTag("owner"):
trap = collider.getPythonTag("owner")
trap.moveDirection = 0
trap.ignorePlayer = False
trap.movementSound.stop()
trap.stopSound.play()
def trapHitsSomething(self, entry):
collider = entry.getFromNodePath()
if collider.hasPythonTag("owner"):
trap = collider.getPythonTag("owner")
if trap.moveDirection == 0:
return
collider = entry.getIntoNodePath()
if collider.hasPythonTag("owner"):
obj = collider.getPythonTag("owner")
if isinstance(obj, Player):
if not trap.ignorePlayer:
obj.alterHealth(-1)
trap.ignorePlayer = True
else:
obj.alterHealth(-10)
trap.impactSound.play()
def update(self, task):
dt = globalClock.getDt()
if self.player is not None:
if self.player.health > 0:
self.player.update(self.keyMap, dt)
self.spawnTimer -= dt
if self.spawnTimer <= 0:
self.spawnTimer = self.spawnInterval
self.spawnEnemy()
[enemy.update(self.player, dt) for enemy in self.enemies]
[trap.update(self.player, dt) for trap in self.trapEnemies]
newlyDeadEnemies = [enemy for enemy in self.enemies if enemy.health <= 0]
self.enemies = [enemy for enemy in self.enemies if enemy.health > 0]
for enemy in newlyDeadEnemies:
enemy.collider.removeNode()
enemy.actor.play("die")
self.player.score += enemy.scoreValue
if len(newlyDeadEnemies) > 0:
self.player.updateScore()
self.deadEnemies += newlyDeadEnemies
enemiesAnimatingDeaths = []
for enemy in self.deadEnemies:
deathAnimControl = enemy.actor.getAnimControl("die")
if deathAnimControl is None or not deathAnimControl.isPlaying():
enemy.cleanup()
else:
enemiesAnimatingDeaths.append(enemy)
self.deadEnemies = enemiesAnimatingDeaths
self.difficultyTimer -= dt
if self.difficultyTimer <= 0:
self.difficultyTimer = self.difficultyInterval
if self.maxEnemies < self.maximumMaxEnemies:
self.maxEnemies += 1
if self.spawnInterval > self.minimumSpawnInterval:
self.spawnInterval -= 0.1
else:
if self.gameOverScreen.isHidden():
self.gameOverScreen.show()
self.finalScoreLabel["text"] = "Final score: " + str(self.player.score)
self.finalScoreLabel.setText()
return task.cont
def cleanup(self):
for enemy in self.enemies:
enemy.cleanup()
self.enemies = []
for enemy in self.deadEnemies:
enemy.cleanup()
self.deadEnemies = []
for trap in self.trapEnemies:
trap.cleanup()
self.trapEnemies = []
if self.player is not None:
self.player.cleanup()
self.player = None
def quit(self):
self.cleanup()
base.userExit()
class RoamingRalphDemo(ShowBase):
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
self.orbCollisionHandler = CollisionHandlerQueue()
self.cTrav = CollisionTraverser()
self.cTrav.setRespectPrevTransform(True)
#hbPath = NodePath()
utilsKristina2.setUpKeys(self)
utilsKristina2.loadModels(self)
utilsKristina2.setUpLighting(self)
utilsKristina2.setUpFloatingSpheres(self)
utilsKristina2.setUpRalphsShot(self)
utilsKristina2.setUpCamera(self)
utilsKristina2.setUpCollisionSpheres(self)
self.healthTxt = utilsKristina2.addInstructions(.06,"Health: 100")
self.orbTxt = utilsKristina2.addInstructions(.18,"Orbs: 0")
self.vec = LVector3(0,1,0)#vector for pawns shot
# Create a frame
#frame = DirectFrame(text = "main", scale = 0.001)
# Add button
#bar = DirectWaitBar(text = "", value = 50, pos = (0,.4,.4))
#bar.reparent(render)
# Game state variables
self.isMoving = False
self.jumping = False
self.vz = 0
self.numOrbs = 0
self.healthCount = 100
#self.shotList = []
#self.sphere = CollisionBox((self.ralph.getX() + -10,self.ralph.getY(),self.ralph.getZ()),10,10,10)
self.sphere = CollisionSphere(0,-5,4,3)
self.sphere3 = CollisionSphere(0,5,5,3)
self.sphere4 = CollisionSphere(-4,0,5,2)
self.sphere5 = CollisionSphere(4,0,5,2)
self.sphere2 = CollisionSphere(0,0,3,2)
self.cnodePath = self.ralph.attachNewNode((CollisionNode("ralphColNode")))
self.cnodePath2 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck")))
self.cnodePath3 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck2")))
self.cnodePath4 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck3")))
self.cnodePath5 = self.ralph.attachNewNode((CollisionNode("ralphWallCheck4")))
self.cnodePath.node().addSolid(self.sphere2)
self.cnodePath2.node().addSolid(self.sphere)
self.cnodePath3.node().addSolid(self.sphere3)
self.cnodePath4.node().addSolid(self.sphere4)
self.cnodePath5.node().addSolid(self.sphere5)
#self.cnodePath.node().addSolid(self.sphere2)
self.cnodePath.show()
#self.cnodePath2.show()
#self.cnodePath3.show()
#self.cnodePath4.show()
#self.cnodePath5.show()
self.cTrav.addCollider(self.cnodePath2, self.orbCollisionHandler)
self.cTrav.addCollider(self.cnodePath3, self.orbCollisionHandler)
self.cTrav.addCollider(self.cnodePath4, self.orbCollisionHandler)
self.cTrav.addCollider(self.cnodePath5, self.orbCollisionHandler)
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(self.cnodePath, self.ralph)
#self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler)
self.cTrav.addCollider(self.cnodePath, self.pusher)
self.chrisLastShotTime = globalClock.getFrameTime()
self.chrisTimer = globalClock.getDt()
#def __init__(self, pos,showbase, colPathName, dir, length):
self.chrisList = [utilsKristina2.chris((15,0,0.5),self,"chrisColPath0","X",6), utilsKristina2.chris((18,29,0.5),self,"chrisColPath1","X",6),
utilsKristina2.chris((-6,67,0.5),self,"chrisColPath2","X",6), utilsKristina2.chris((-41,72,0.5),self,"chrisColPath7","X",6)]
#,utilsKristina2.chris((-42,106,0.5),self,"chrisColPath3","X",6)]#, utilsKristina2.chris((-62,108,0.5),self,"chrisColPath4","X",6),
#utilsKristina2.chris((-74,70,0.5),self,"chrisColPath5","y",6)]
#def _init_(self,showbase,pos,color,speed,radius):
self.orbList = [utilsKristina2.orb(self,(0,0,2),(0,0,1,1),20,4)]
self.donutList = [utilsKristina2.donut(self,(0,0,2),40,3)]
self.cameraCollided = False
self.ralphSpeed = 60
self.ralphHit = False
self.ralphRedTime = 0
self.ralphLife=True
taskMgr.add(self.move, "moveTask")
taskMgr.add(self.moveChris,"moveChrisTask")
# Records the state of the arrow keys
def setKey(self, key, value):
self.keyMap[key] = value
def startEnemyThread(self):
showbase = self
class enemyThread(threading.Thread):
def run(self):
dt = globalClock.getDt()
for chris in showbase.chrisList:
chris.moveChris(dt,showbase,showbase.chrisList)
def moveChris(self,task):
dt = globalClock.getDt()
for chris in self.chrisList:
chris.moveChris(dt,self,self.chrisList)
return task.cont
# Accepts arrow keys to move either the player or the menu cursor,
# Also deals with grid checking and collision detection
def move(self, task):
# Get the time that elapsed since last frame. We multiply this with
# the desired speed in order to find out with which distance to move
# in order to achieve that desired speed.
dt = globalClock.getDt()
#utilsKristina2.moveChris(self,dt)
#self.chris2.moveChris(dt,self)
#self.startEnemyThread()
if globalClock.getFrameTime()- self.ralphRedTime > .3 and self.ralphHit == True:
self.ralph.clearColor()
self.ralphHit = False
# If the camera-left key is pressed, move camera left.
# If the camera-right key is pressed, move camera right.
if self.keyMap["cam-left"]:
self.camera.setZ(self.camera, -20 * dt)
if self.keyMap["cam-right"]:
self.camera.setZ(self.camera, +20 * dt)
# save ralph's initial position so that we can restore it,
# in case he falls off the map or runs into something.
startpos = self.ralph.getPos()
# If a move-key is pressed, move ralph in the specified direction.
if self.keyMap["left"]:
self.ralph.setH(self.ralph.getH() + 75 * dt)
#self.camera.setX(self.camera, +15.5 * dt)
if self.keyMap["right"]:
self.ralph.setH(self.ralph.getH() - 75 * dt)
#self.camera.setX(self.camera, -15.5 * dt)
if self.keyMap["forward"]:
self.ralph.setFluidY(self.ralph, -1*self.ralphSpeed * dt)
#self.camera.setY(self.camera, -35 * dt)
if self.keyMap["back"]:
self.ralph.setFluidY(self.ralph, self.ralphSpeed * dt)
#self.camera.setY(self.camera, 35 * dt)
if self.keyMap["space"]:
if self.jumping is False:
#self.ralph.setZ(self.ralph.getZ() + 100 * dt)
self.jumping = True
self.vz = 8
if self.keyMap["c"] or self.keyMap["enter"]:
if self.keyMap["c"]:
self.keyMap["c"]=False
if self.keyMap["enter"]:
self.keyMap["enter"] = False
self.shotList[self.shotCount].lpivot.setPos(self.ralph.getPos())
self.shotList[self.shotCount].lpivot.setZ(self.ralph.getZ() + .5)
self.shotList[self.shotCount].lpivot.setX(self.ralph.getX() - .25)
print self.ralph.getPos()
#self.shotList.append(rShot)
#self.lightpivot3.setPos(self.ralph.getPos())
#self.lightpivot3.setZ(self.ralph.getZ() + .5)
#self.lightpivot3.setX(self.ralph.getX() - .25)
#self.myShot.setHpr(self.ralph.getHpr())
#parent to ralph
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(0,-1,0))
#self.myShotVec = vec
node = NodePath("tmp")
node.setHpr(self.ralph.getHpr())
vec = render.getRelativeVector(node,(0,-1,0))
self.shotList[self.shotCount].vec = vec
self.shotCount = (self.shotCount + 1) % 10
for rs in self.shotList:
rs.lpivot.setPos(rs.lpivot.getPos() + rs.vec * dt * 25 )
#if shot is too far stop updating
if self.jumping is True:
self.vz = self.vz - 16* dt
self.ralph.setZ(self.ralph.getZ() + self.vz * dt )
if self.ralph.getZ() < 0:
self.ralph.setZ(0)
self.jumping = False
else:
if self.ralph.getZ() < 0.25:
self.ralph.setZ(0.25)
elif self.ralph.getZ() > 0.25:
self.ralph.setZ(self.ralph.getZ() -7 * dt)
# If ralph is moving, loop the run animation.
# If he is standing still, stop the animation.
if self.keyMap["forward"] or self.keyMap["left"] or self.keyMap["right"] or self.keyMap["space"] or self.keyMap["forward"] or self.keyMap["back"]:
if self.isMoving is False:
self.ralph.loop("run")
self.isMoving = True
else:
if self.isMoving:
self.ralph.stop()
self.ralph.pose("walk", 5)
self.isMoving = False
# update pawns shot or set up new shot after it reaches a certain distance
node = NodePath("tmp")
node.setHpr(self.pawn.getHpr())
vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0))
self.shot.setPos(self.shot.getPos() + self.vec * dt * 10 )
if self.shot.getY() < -15 or self.shot.getY() > 30 or self.shot.getX() < 5 or self.shot.getX() > 15:
self.shot.setPos(self.pawn.getPos() + (0,0,0))
self.vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0))
self.vec = render.getRelativeVector(node,(random.random() * random.randrange(-1,2),random.random() + 1,0))
# If the camera is too far from ralph, move it closer.
# If the camera is too close to ralph, move it farther.
#self.camera.lookAt(self.floater)
camvec = self.ralph.getPos() - self.camera.getPos()
#camvec = Vec3(0,camvec.getY(),0)
camdist = camvec.length()
x = self.camera.getZ()
camvec.normalize()
#if camdist > 6.0:
# self.camera.setPos(self.camera.getPos() + camvec * (camdist - 6))
#if camdist < 6.0:
# self.camera.setPos(self.camera.getPos() - camvec * (6 - camdist))
# Normally, we would have to call traverse() to check for collisions.
# However, the class ShowBase that we inherit from has a task to do
# this for us, if we assign a CollisionTraverser to self.cTrav.
#self.cTrav.traverse(render)
# Adjust camera so it stays at same height
if self.cameraCollided == False:
if self.camera.getZ() < self.ralph.getZ() + 1 or self.camera.getZ() > self.ralph.getZ() + 1:
self.camera.setZ(self.ralph.getZ() + 1)
# The camera should look in ralph's direction,
# but it should also try to stay horizontal, so look at
# a floater which hovers above ralph's head.
self.camera.lookAt(self.floater)
entries = list(self.orbCollisionHandler.getEntries())
if(len(entries) > 0):
#self.lightpivot.reparentTo(NodePath())
orbCollected = False
self.cameraCollided = False
self.ralphSpeed = 65
for entry in self.orbCollisionHandler.getEntries():
#print(entry)
fromColNp = entry.getFromNodePath()
toColNp = entry.getIntoNodePath()
if fromColNp.getName() == "orbColPath" and toColNp.getName() == "ralphColNode":
if orbCollected == False:
fromColNp.getParent().reparentTo(NodePath())
self.orbTxt.destroy()
self.numOrbs += 1
str1 = "Orbs: " + str(self.numOrbs)
self.orbTxt = utilsKristina2.addInstructions(.18, str1)
orbCollected = True
elif toColNp.getName() == "orbColPath" and fromColNp.getName() == "ralphColNode":
if orbCollected == False:
toColNp.getParent().reparentTo(NodePath())
self.orbTxt.destroy()
self.numOrbs += 1
str1 = "Orbs: " + str(self.numOrbs)
self.orbTxt = utilsKristina2.addInstructions(.18, str1)
orbCollected = True
elif toColNp.getName() == "ralphOrbColPath" and (fromColNp.getName()[:-1] == "chrisColPath" or fromColNp.getName()[:-2] == "chrisColPath"):
toColNp.getParent().setZ(20)
for chriss in self.chrisList:
if chriss.chrisColName == fromColNp.getName():
chris = chriss
break
chris.chrisHealth = chris.chrisHealth - 1
chris.chris.setColor(1,0,0,1)
chris.chrisHit = True
chris.chrisRedTime = globalClock.getFrameTime()
#print chris.chrisRedTime
if chris.chrisHealth < 0:
fromColNp.getParent().removeNode()
chris.chrisAlive = False
chris.chrisShot.setZ(26)
elif (toColNp.getName()[:-1] == "chrisColPath" or toColNp.getName()[:-2] == "chrisColPath") and fromColNp.getName() == "ralphOrbColPath":
fromColNp.getParent().setZ(20)
for chriss in self.chrisList:
if chriss.chrisColName == toColNp.getName():
chris = chriss
break
chris.chrisHealth = chris.chrisHealth - 1
chris.chris.setColor(1,0,0,1)
chris.chrisHit = True
chris.chrisRedTime = globalClock.getFrameTime()
#print chris.chrisRedTime
if chris.chrisHealth < 0:
toColNp.getParent().removeNode()
chris.chrisAlive = False
chris.chrisShot.setZ(26)
elif toColNp.getName() == "enemyOrbColPath" and fromColNp.getName() == "ralphColNode":
toColNp.getParent().setZ(26)
self.healthTxt.destroy()
self.healthCount -= 3
str1 = "Health: " + str(self.healthCount)
self.healthTxt = utilsKristina2.addInstructions(.06, str1)
self.ralphHit = True
self.ralph.setColor((1,0,0,1))
self.ralphRedTime = globalClock.getFrameTime()
if self.healthCount <=0:
sys.exit()
elif toColNp.getName() == "ralphColNode" and fromColNp.getName() == "enemyOrbColPath":
fromColNp.getParent().setZ(26)
self.healthTxt.destroy()
self.healthCount -= 3
str1 = "Health: " + str(self.healthCount)
self.healthTxt = utilsKristina2.addInstructions(.06, str1)
self.ralphHit = True
self.ralph.setColor((1,0,0,1))
self.ralphRedTime = globalClock.getFrameTime()
if self.healthCount <=0:
sys.exit()
elif fromColNp.getName() == "ralphOrbColPath" and toColNp.getName() == "allinclusive":
fromColNp.getParent().setZ(50)
elif toColNp.getName() == "ralphOrbColPath" and fromColNp.getName() == "allinclusive":
toColNp.getParent().setZ(50)
elif fromColNp.getName() == "enemyOrbWallCheck" and toColNp.getName() == "allinclusive":
fromColNp.getParent().setZ(50)
#print toColNp.getName()
elif toColNp.getName() == "enemyOrbWallCheck" and fromColNp.getName() == "allinclusive":
toColNp.getParent().setZ(50)
#print fromColNp.getName()
elif fromColNp.getName() == "ralphWallCheck" and toColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(0,-1,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#fromColNp.getParent().setZ(26)
self.ralphSpeed = 25
elif toColNp.getName() == "ralphWallCheck" and fromColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(0,-1,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#print "wtf"
#toColNp.getParent().setZ(26)
self.ralphSpeed = 25
elif fromColNp.getName() == "ralphWallCheck2" and toColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(0,1,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#fromColNp.getParent().setZ(26)
self.ralphSpeed = 25
elif toColNp.getName() == "ralphWallCheck2" and fromColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(0,1,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#self.camera.setPos(self.ralph.getPos())
#self.cameraCollided = True
self.ralphSpeed = 25
elif fromColNp.getName() == "ralphWallCheck3" and toColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(-1,0,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#fromColNp.getParent().setZ(26)
self.ralphSpeed = 25
print "3"
elif toColNp.getName() == "ralphWallCheck3" and fromColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(-1,0,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#self.camera.setPos(self.ralph.getPos())
#self.cameraCollided = True
self.ralphSpeed = 25
print "3"
elif fromColNp.getName() == "ralphWallCheck4" and toColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(1,0,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#fromColNp.getParent().setZ(26)
self.ralphSpeed = 25
print "4"
elif toColNp.getName() == "ralphWallCheck4" and fromColNp.getName() == "allinclusive":
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(1,0,0))
#self.ralph.setPos(self.ralph.getPos()-vec)
#self.camera.setPos(self.ralph.getPos())
#self.cameraCollided = True
self.ralphSpeed = 25
print "4"
return task.cont
class Game(DirectObject):
def __init__(self):
self.setAI()
self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0}
base.win.setClearColor(Vec4(0, 0, 0, 1))
# the menu
self.loadAudio()
self.showMenu()
# keyboard and mouse events
self.accept("escape", sys.exit)
self.accept("w", self.setKey, ["forward", 1])
self.accept("a", self.setKey, ["left", 1])
self.accept("s", self.setKey, ["backward", 1])
self.accept("d", self.setKey, ["right", 1])
self.accept("w-up", self.setKey, ["forward", 0])
self.accept("a-up", self.setKey, ["left", 0])
self.accept("s-up", self.setKey, ["backward", 0])
self.accept("d-up", self.setKey, ["right", 0])
self.accept("arrow_left", self.setKey, ["cam-left", 1])
self.accept("arrow_left-up", self.setKey, ["cam-left", 0])
self.accept("arrow_right", self.setKey, ["cam-right", 1])
self.accept("arrow_right-up", self.setKey, ["cam-right", 0])
# create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(0.3, 0.3, 0.3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def loadAudio(self):
self.startAudio = base.loader.loadSfx("../assets/audio/start.mp3")
self.gameAudio = base.loader.loadSfx("../assets/audio/game.mp3")
self.winAudio = base.loader.loadSfx("../assets/audio/win.mp3")
self.loseAudio = base.loader.loadSfx("../assets/audio/lose.mp3")
def createPresents(self):
self.speedPill = loader.loadModel("../assets/models/capsule/capsule")
self.speedPill.reparentTo(render)
self.speedPill.setScale(0.025)
self.speedPill.setPos(-43.9744, 32.031, 0.6)
self.speedPillb = loader.loadModel("../assets/models/capsule/capsule")
self.speedPillb.reparentTo(render)
self.speedPillb.setScale(0.025)
self.speedPillb.setPos(-57.7858, -61.5068, 3.80818)
self.banana = loader.loadModel("../assets/models/banana/banana")
self.banana.reparentTo(render)
self.banana.setScale(3)
self.banana.setPos(-72.484, -7.14435, 5.05246)
self.sphinx = loader.loadModel("../assets/models/sphinx/sphinx")
self.sphinx.reparentTo(render)
self.sphinx.setScale(0.0025)
self.sphinx.setPos(-48.0702, -39.4669, 0.5)
def createMilesAI(self):
startPos = self.env.find("**/start_point").getPos()
# load miles actor
self.miles1 = Actor(
"../assets/models/miles/tails",
{
"board": "../assets/models/miles/tails-board",
"win": "../assets/models/miles/tails-win",
"fwboard": "../assets/models/miles/tails-fallingwboard",
"fwoboard": "../assets/models/miles/tails-fallingwoboard",
},
)
self.miles2 = Actor(
"../assets/models/miles/tails",
{
"board": "../assets/models/miles/tails-board",
"win": "../assets/models/miles/tails-win",
"fwboard": "../assets/models/miles/tails-fallingwboard",
"fwoboard": "../assets/models/miles/tails-fallingwoboard",
},
)
self.miles = [self.miles1, self.miles2]
self.miles1.reparentTo(render)
self.miles1.setScale(0.05)
self.miles1.setPlayRate(3, "run")
self.miles1.loop("board")
self.miles1.setPos(startPos[0] + 5, startPos[1] - 20, startPos[2])
self.miles1GroundRay = CollisionRay()
self.miles1GroundRay.setOrigin(0, 0, 1000)
self.miles1GroundRay.setDirection(0, 0, -1)
self.miles1GroundCol = CollisionNode("miles1Ray")
self.miles1GroundCol.addSolid(self.miles1GroundRay)
self.miles1GroundCol.setFromCollideMask(BitMask32.bit(0))
self.miles1GroundCol.setIntoCollideMask(BitMask32.allOff())
self.miles1GroundColNp = self.miles1.attachNewNode(self.miles1GroundCol)
self.miles1GroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.miles1GroundColNp, self.miles1GroundHandler)
# AI code for miles1
self.miles1AI = AICharacter("miles1", self.miles1, 100, 1, 7)
self.AIworld.addAiChar(self.miles1AI)
self.miles1AIbehaviors = self.miles1AI.getAiBehaviors()
# pursue behavior
self.miles1AIbehaviors.pursue(self.sonic)
taskMgr.add(self.moveMiles1AI, "moveMiles1AI")
self.miles2.reparentTo(render)
self.miles2.setScale(0.05)
self.miles2.setPlayRate(3, "run")
self.miles2.loop("win")
self.miles2.setPos(startPos[0] - 5, startPos[1] - 20, startPos[2])
self.miles2GroundRay = CollisionRay()
self.miles2GroundRay.setOrigin(0, 0, 1000)
self.miles2GroundRay.setDirection(0, 0, -1)
self.miles2GroundCol = CollisionNode("miles2Ray")
self.miles2GroundCol.addSolid(self.miles2GroundRay)
self.miles2GroundCol.setFromCollideMask(BitMask32.bit(0))
self.miles2GroundCol.setIntoCollideMask(BitMask32.allOff())
self.miles2GroundColNp = self.miles2.attachNewNode(self.miles2GroundCol)
self.miles2GroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.miles2GroundColNp, self.miles2GroundHandler)
self.miles2AI = AICharacter("miles2", self.miles2, 100, 1, 7)
self.AIworld.addAiChar(self.miles2AI)
self.miles2AIbehaviors = self.miles2AI.getAiBehaviors()
# puruse behavior
self.miles2AIbehaviors.pursue(self.sonic)
taskMgr.add(self.moveMiles2AI, "moveMiles2AI")
def createTrexAI(self):
startPos = self.env.find("**/start_point").getPos()
# Load the trex actor and loop its animation
self.trex = Actor(
"../assets/models/trex/trex",
{"run": "../assets/models/trex/trex-run", "eat": "../assets/models/trex/trex-eat"},
)
self.trex.reparentTo(render)
self.trex.setScale(0.25)
self.trex.setPlayRate(3, "run")
self.trex.loop("run")
self.trex.setPos(startPos[0], startPos[-1] - 20, startPos[2])
self.trexGroundRay = CollisionRay()
self.trexGroundRay.setOrigin(0, 0, 1000)
self.trexGroundRay.setDirection(0, 0, -1)
self.trexGroundCol = CollisionNode("trexRay")
self.trexGroundCol.addSolid(self.trexGroundRay)
self.trexGroundCol.setFromCollideMask(BitMask32.bit(0))
self.trexGroundCol.setIntoCollideMask(BitMask32.allOff())
self.trexGroundColNp = self.trex.attachNewNode(self.trexGroundCol)
self.trexGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.trexGroundColNp, self.trexGroundHandler)
# self.pusher.addCollider(self.trexGroundColNp, self.sonic)
# AI code for trex
self.trexAI = AICharacter("trex", self.trex, 100, 1, 7)
self.AIworld.addAiChar(self.trexAI)
self.trexAIbehaviors = self.trexAI.getAiBehaviors()
# pursue behavior
# self.trexAIbehaviors.pursue(self.sonic)
self.trexAIbehaviors.pursue(self.sonic)
taskMgr.add(self.moveTrexAI, "moveTrexAI")
# to create the AI world
def setAI(self):
self.AIworld = AIWorld(render)
taskMgr.add(self.AIUpdate, "AIUpdate")
def AIUpdate(self, task):
self.AIworld.update()
return task.cont
def moveMiles1AI(self, task):
startpos = self.miles1.getPos()
entries = []
for i in range(self.miles1GroundHandler.getNumEntries()):
entry = self.miles1GroundHandler.getEntry(i)
entries.append(entry)
entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ()))
if (len(entries) > 0) and (entries[0].getIntoNode().getName() == "terrain"):
miles1Z = entries[0].getSurfacePoint(render).getZ()
miles1Y = entries[0].getSurfacePoint(render).getY()
miles1X = entries[0].getSurfacePoint(render).getX()
self.miles1.setZ(entries[0].getSurfacePoint(render).getZ())
else:
self.miles1.setPos(startpos)
return task.cont
def moveMiles2AI(self, task):
startpos = self.miles2.getPos()
entries = []
for i in range(self.miles2GroundHandler.getNumEntries()):
entry = self.miles2GroundHandler.getEntry(i)
entries.append(entry)
entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ()))
if (len(entries) > 0) and (entries[0].getIntoNode().getName() == "terrain"):
miles2Z = entries[0].getSurfacePoint(render).getZ()
miles2Y = entries[0].getSurfacePoint(render).getY()
miles2X = entries[0].getSurfacePoint(render).getX()
self.miles2.setZ(entries[0].getSurfacePoint(render).getZ())
else:
self.miles2.setPos(startpos)
return task.cont
def moveTrexAI(self, task):
startpos = self.trex.getPos()
entries = []
for i in range(self.trexGroundHandler.getNumEntries()):
entry = self.trexGroundHandler.getEntry(i)
entries.append(entry)
entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ()))
if (len(entries) > 0) and (entries[0].getIntoNode().getName() == "terrain"):
trexZ = entries[0].getSurfacePoint(render).getZ()
trexY = entries[0].getSurfacePoint(render).getY()
trexX = entries[0].getSurfacePoint(render).getX()
self.trex.setZ(entries[0].getSurfacePoint(render).getZ())
else:
self.trex.setPos(startpos)
return task.cont
def setKey(self, action, value):
self.keyMap[action] = value
def move(self, task):
base.camera.lookAt(self.sonic)
if self.keyMap["cam-left"] != 0:
base.camera.setX(base.camera, -30 * globalClock.getDt())
if self.keyMap["cam-right"] != 0:
base.camera.setX(base.camera, +30 * globalClock.getDt())
startpos = self.sonic.getPos()
if self.keyMap["left"] != 0:
self.sonic.setH(self.sonic.getH() + 300 * globalClock.getDt())
if self.keyMap["right"] != 0:
self.sonic.setH(self.sonic.getH() - 300 * globalClock.getDt())
if self.keyMap["forward"] != 0:
self.sonic.setY(self.sonic, -100 * globalClock.getDt() * SPEED)
if self.keyMap["backward"] != 0:
self.sonic.setY(self.sonic, 100 * globalClock.getDt() * SPEED)
# If sonic is moving, loop the run animation
# If he is standing still, stop the animation
if (
(self.keyMap["forward"] != 0)
or (self.keyMap["left"] != 0)
or (self.keyMap["right"] != 0)
or (self.keyMap["backward"] != 0)
):
if self.isMoving is False:
self.sonic.loop("board")
self.isMoving = True
else:
if self.isMoving:
self.sonic.stop()
self.sonic.pose("fwboard", 5)
self.isMoving = False
# If the camera is too far from sonic, move it closer
# If the camera is too close to sonic, move it farther
camvec = self.sonic.getPos() - base.camera.getPos()
camvec.setZ(0)
camdist = camvec.length()
camvec.normalize()
if camdist > 10.0:
base.camera.setPos(base.camera.getPos() + (camvec * (camdist - 10)))
camdist = 10.0
if camdist < 5.0:
base.camera.setPos(base.camera.getPos() - (camvec * (5 - camdist)))
camdist = 5.0
# now check for collisions
self.cTrav.traverse(render)
entries = []
for i in range(self.sonicGroundHandler.getNumEntries()):
entry = self.sonicGroundHandler.getEntry(i)
entries.append(entry)
entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ()))
if (len(entries) > 0) and (entries[0].getIntoNode().getName() == "terrain"):
self.sonic.setZ(entries[0].getSurfacePoint(render).getZ())
else:
self.sonic.setPos(startpos)
# keep the camera at one foot avoce the terrian
# or two feet above sonic, whichever is greater
entries = []
for i in range(self.camGroundHandler.getNumEntries()):
entry = self.camGroundHandler.getEntry(i)
entries.append(entry)
entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ()))
if (len(entries) > 0) and (entries[0].getIntoNode().getName() == "terrain"):
base.camera.setZ(entries[0].getSurfacePoint(render).getZ() + 1.0)
if base.camera.getZ() < self.sonic.getZ() + 2.0:
base.camera.setZ(self.sonic.getZ() + 2.0)
# The camera should look in sonic's direction,
# but it should also try to stay horizontal, so look at
# a floater which hovers above sonic's head
self.floater.setPos(self.sonic.getPos())
self.floater.setZ(self.sonic.getZ() + 2.0)
base.camera.lookAt(self.floater)
# Update the camera based on mouse movement
md = base.win.getPointer(0)
x = md.getX()
y = md.getY()
if base.win.movePointer(0, base.win.getXSize() / 2, base.win.getYSize() / 2):
base.camera.setX(base.camera, (x - base.win.getXSize() / 2) * globalClock.getDt() * 0.1)
# timer countdown
global TIME
TIME = TOTAL_TIME - int(task.time)
self.time_text.setText("Time Remaining :: %i" % TIME)
return task.cont
def checkWin(self, task):
delta = self.sonic.getDistance(self.flag)
if delta < 25:
self.winText = OnscreenText(
text="You Win!", style=1, fg=(1, 1, 1, 1), pos=(0, 0), align=TextNode.ACenter, scale=0.4
)
self.resetBtn = DirectButton(
text=("Restart", "Restart", "Restart"), scale=0.1, command=self.resetGame, pos=(0, 0, -0.7)
)
taskMgr.remove("moveTask")
if self.gameAudio.status() == self.gameAudio.PLAYING:
self.gameAudio.stop()
self.winAudio.play()
return task.done
return task.cont
def checkTime(self, task):
time_left = TIME
if time_left == 0:
taskMgr.remove("moveTask")
self.gameOverText = OnscreenText(
text="Game Over!", style=1, fg=(1, 1, 1, 1), pos=(0, 0), align=TextNode.ACenter, scale=0.4
)
self.resetBtn = DirectButton(
text=("Restart", "Restart", "Restart"), scale=0.1, command=self.resetGame, pos=(0, 0, -0.7)
)
return task.done
return task.cont
def checkGameOver(self, task):
health_left = HEALTH
if 1 <= health_left <= 10:
global SPEED
SPEED = 0.5
if health_left <= 0:
taskMgr.remove("moveTask")
self.gameOverText = OnscreenText(
text="Game Over!", style=1, fg=(1, 1, 1, 1), pos=(0, 0), align=TextNode.ACenter, scale=0.4
)
self.resetBtn = DirectButton(
text=("Restart", "Restart", "Restart"), scale=0.1, command=self.resetGame, pos=(0, 0, -0.7)
)
if self.gameAudio.status() == self.gameAudio.PLAYING:
self.gameAudio.stop()
self.loseAudio.play()
return task.done
return task.cont
def resetGame(self):
# re-add the move task
taskMgr.add(self.move, "moveTask")
# remove GUI elements
if hasattr(game, "gameOverText"):
self.gameOverText.destroy()
if hasattr(game, "resetBtn"):
self.resetBtn.destroy()
if hasattr(game, "winText"):
self.winText.destroy()
if (self.winAudio.status() == self.winAudio.PLAYING) or (self.loseAudio.status() == self.loseAudio.PLAYING):
self.winAudio.stop()
self.loseAudio.stop()
self.gameAudio.play()
# reset position
self.sonic.setPos(self.START)
# reset time count
global TIME, TOTAL_TIME
TIME = 120
TOTAL_TIME = 120
def showMenu(self):
# TODO: add more controls text
self.startAudio.play()
self.gameNameText = OnscreenText(
text="Run, Baby, Run", style=1, fg=(1, 1, 1, 1), pos=(0, 0.5), align=TextNode.ACenter, scale=0.3
)
text = """
Controls
===============
[W] - Move Forward
[A] - Move Left
[S] - Move Backwards
[D] - Move Right
[<-] - Rotate Camera (Left)
[->] - Rotate Camera (Right)
Camera Movements are also controlled by mouse
"""
self.controlsText = OnscreenText(
text=text, style=1, fg=(1, 1, 1, 1), pos=(0, 0), align=TextNode.ACenter, scale=0.05
)
self.startBtn = DirectButton(
text=("Start", "Start", "Start"), scale=0.1, command=self.startGame, pos=(0, 0, -0.7)
)
def checkConditions(self, task):
trexDelta = self.sonic.getDistance(self.trex)
miles1Delta = self.sonic.getDistance(self.miles1)
miles2Delta = self.sonic.getDistance(self.miles2)
if trexDelta <= 5 or miles1Delta <= 15 or miles2Delta <= 15:
global HEALTH
HEALTH = HEALTH - 1
if HEALTH < 0:
HEALTH = 0
self.health_text.setText("Health :: %i" % HEALTH)
return task.cont
def checkSpeed(self, task):
speedDelta = self.sonic.getDistance(self.speedPill)
if speedDelta <= 30:
global SPEED
SPEED = SPEED + 1
self.speedPill.removeNode()
return task.done
return task.cont
def checkSpeed2(self, task):
speedDelta2 = self.sonic.getDistance(self.speedPillb)
if speedDelta2 <= 3720:
global SPEED
SPEED = SPEED + 1
self.speedPillb.removeNode()
return task.done
return task.cont
def checkHealthBoost(self, task):
healthDelta = self.sonic.getDistance(self.banana)
if healthDelta <= 3:
global HEALTH
HEALTH = HEALTH + 10
if HEALTH > 100:
HEALTH = 100
self.banana.removeNode()
self.health_text.setText("Health :: %i" % HEALTH)
return task.done
return task.cont
def checkTimeAdd(self, task):
timeAddDelta = self.sonic.getDistance(self.sphinx)
if timeAddDelta <= 507:
global TOTAL_TIME
TOTAL_TIME = TOTAL_TIME + 10
self.time_text.setText("Time Remaining :: %i" % TOTAL_TIME)
self.sphinx.removeNode()
return task.done
return task.cont
def startGame(self):
# remove menu main elements
if hasattr(game, "startBtn"):
self.startBtn.destroy()
if hasattr(game, "gameNameText"):
self.gameNameText.destroy()
if hasattr(game, "controlsText"):
self.controlsText.destroy()
if self.startAudio.status() == self.startAudio.PLAYING:
self.startAudio.stop()
self.gameAudio.play()
# HUD information (time, health)
self.time_text = addInstruction((-1.2, 0.9), "Time Reamining :: %i" % TIME)
self.health_text = addInstruction((0.9, 0.9), "Health :: %i" % HEALTH)
# the environment
self.env = loader.loadModel("../assets/models/world")
self.env.reparentTo(render)
self.env.setPos(0, 0, 0)
# the flag(destination)
self.flag = loader.loadModel("../assets/models/flag/flag")
self.flag.reparentTo(render)
self.flag.setScale(0.1)
self.flag.setPos(0, 0, 5)
self.DESTINATION = self.flag.getPos()
# main character(sonic)
self.START = self.env.find("**/start_point").getPos()
self.sonic = Actor(
"../assets/models/sonic/sonic",
{
"run": "../assets/models/sonic/sonic-run",
"win": "../assets/models/sonic/sonic-win",
"board": "../assets/models/sonic/sonic-board",
"fwboard": "../assets/models/sonic/sonic-fallingwboard",
"fwoboard": "../assets/models/sonic/sonic-fallingwoboard",
},
)
self.sonic.reparentTo(render)
self.sonic.setScale(0.05)
self.sonic.setPos(self.START)
# create a floater object to be used as a temporary
# variable in a variety of calculations
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
taskMgr.add(self.move, "moveTask")
# varible to keep track of moving state
self.isMoving = False
# variable to keep track of speed boost
self.speedBoost = False
# variable to keep track of invulnerability
self.invul = False
# setup the camera
base.disableMouse()
base.camera.setPos(self.sonic.getX(), self.sonic.getY() + 10, 2)
self.cTrav = CollisionTraverser()
# self.pusher = CollisionHandlerPusher()
self.sonicGroundRay = CollisionRay()
self.sonicGroundRay.setOrigin(0, 0, 1000)
self.sonicGroundRay.setDirection(0, 0, -1)
self.sonicGroundCol = CollisionNode("sonicRay")
self.sonicGroundCol.addSolid(self.sonicGroundRay)
# self.sonicGroundCol.addSolid(CollisionSphere(0, 0, 1.5, 1.5))
self.sonicGroundCol.setFromCollideMask(BitMask32.bit(0))
self.sonicGroundCol.setIntoCollideMask(BitMask32.allOff())
self.sonicGroundColNp = self.sonic.attachNewNode(self.sonicGroundCol)
self.sonicGroundHandler = CollisionHandlerQueue()
self.sonicPusher = CollisionHandlerPusher()
self.sonicPusher.addInPattern("%fn-into-%in")
self.cTrav.addCollider(self.sonicGroundColNp, self.sonicGroundHandler)
# self.cTrav.addCollider(self.sonicGroundColNp, self.sonicPusher)
# self.sonicPusher.addCollider(self.sonicGroundColNp, self.sonic)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 1000)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode("camRay")
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# see the collision rays
# self.sonicGroundColNp.show()
# self.camGroundColNp.show()
# visual representation of the collisions occuring
# self.cTrav.showCollisions(render)
# create AI characters
self.createTrexAI()
self.createMilesAI()
# place the presents
self.createPresents()
# check winning condition
taskMgr.add(self.checkWin, "checkWin")
# check time conditions
taskMgr.add(self.checkTime, "checkTime")
# check health conditions
taskMgr.add(self.checkGameOver, "checkGameOver")
# check other conditions
taskMgr.add(self.checkConditions, "checkConditions")
taskMgr.add(self.checkSpeed, "checkSpeed")
taskMgr.add(self.checkSpeed2, "checkSpeed2")
taskMgr.add(self.checkHealthBoost, "checkHealthBoost")
taskMgr.add(self.checkTimeAdd, "checkTimeAdd")
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0,
}
###########################################################################
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
# We do not have a skybox, so we will just use a sky blue background color
#self.setBackgroundColor(0.53, 0.80, 0.92, 1)
self.setBackgroundColor(.1, .1, .1, 1)
# Create the main character, person
#personStartPos = self.environ.find("**/start_point").getPos()
#self.person = Actor("models/panda",
# {"run": "models/panda-walk",
# "walk": "models/panda-walk"})
person2StartPos = self.environ.find("**/start_point").getPos()
self.person2 = Actor("models/passenger_penguin",
{"run": "models/passenger_penguin",
"walk": "models/passenger_penguin"})
self.person2.reparentTo(render)
self.person2.setScale(.1)
self.person2.setPos(person2StartPos + (px, py, 1))
person3StartPos = self.environ.find("**/start_point").getPos()
self.person3 = Actor("models/MagicBunny",
{"run": "models/MagicBunny",
"walk": "models/MagicBunny"})
#px = random.randint(-1,1)
#py = random.randint(-1,1)
self.person3.reparentTo(render)
self.person3.setScale(.04)
#self.person.setPos(personStartPos + (0, 0, 2))
self.person3.setPos(person3StartPos + (px/1.5+3, py/2, 0))
personStartPos = self.environ.find("**/start_point").getPos()
self.person = Actor("models/panda",
{"run": "models/panda-walk",
"walk": "models/panda-walk"})
self.person.reparentTo(render)
self.person.setScale(.1)
self.person.setPos(personStartPos + (0, 0, 1.5))
self.person.loop("run")
arenaStartPos = self.environ.find("**/start_point").getPos()
self.arena = Actor("models/FarmHouse")
self.arena.reparentTo(render)
self.arena.setScale(.1)
self.arena.setPos(arenaStartPos + (-1, 0, 0))
arena2StartPos = self.environ.find("**/start_point").getPos()
self.arena2 = Actor("models/fence")
self.arena2.reparentTo(render)
self.arena2.setScale(5.9)
self.arena.setPos(arenaStartPos + (px, py-12, 1))
self.arena2.setPos(arenaStartPos + (8, 5, -1))
arena2StartPos = self.environ.find("**/start_point").getPos()
self.arena3 = Actor("models/gate")
self.arena3.reparentTo(render)
self.arena3.setScale(.01)
self.arena3.setPos(arenaStartPos + (px/2+random.randint(12,15), py/2, -1))
self.arena4 = Actor("models/FarmHouse")
self.arena4.reparentTo(render)
self.arena4.setScale(.1)
self.arena4.setPos(arenaStartPos + (px/3-random.randint(18,22), py/3, -1))
self.arena5 = Actor("models/gate")
self.arena5.reparentTo(render)
self.arena5.setScale(.008)
self.arena5.setPos(arenaStartPos + (px/1.2-9, py/1.2, -1))
#####################################################################################################################################
base.enableParticles()
self.t = loader.loadModel("teapot") # for the particle enhancer
self.t.setScale(10)
self.t.setPos(-10, -20, -1)
self.t.reparentTo(render)
#self.setupLights()
self.p = ParticleEffect()
self.p.setScale(1000)
self.loadParticleConfig('smoke.ptf') # looks like a storm at night
self.p.setScale(20)
#################################################3
# Create a floater object, which floats 2 units above person. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.person)
self.floater.setZ(2.0)
# Accept the control keys for movement and rotation
taskMgr.add(self.move, "moveTask")
# Set up the camera
self.disableMouse()
self.camera.setPos(self.person.getX(), self.person.getY() + 10, 2)
self.cTrav = CollisionTraverser()
self.personCol = CollisionNode('person')
self.personCol.addSolid(CollisionSphere(center=(0, 0, 2), radius=1.5))
self.personCol.addSolid(CollisionSphere(center=(0, -0.25, 4), radius=1.5))
self.personCol.setFromCollideMask(CollideMask.bit(0))
self.personCol.setIntoCollideMask(CollideMask.allOff())
self.personColNp = self.person.attachNewNode(self.personCol)
self.personPusher = CollisionHandlerPusher()
self.personPusher.horizontal = True
self.personPusher.addCollider(self.personColNp, self.person)
self.cTrav.addCollider(self.personColNp, self.personPusher)
self.personGroundRay = CollisionRay()
self.personGroundRay.setOrigin(0, 0, 9)
self.personGroundRay.setDirection(0, 0, -1)
self.personGroundCol = CollisionNode('personRay')
self.personGroundCol.addSolid(self.personGroundRay)
self.personGroundCol.setFromCollideMask(CollideMask.bit(0))
self.personGroundCol.setIntoCollideMask(CollideMask.allOff())
self.personGroundColNp = self.person.attachNewNode(self.personGroundCol)
self.personGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.personGroundColNp, self.personGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 9)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(CollideMask.bit(0))
self.camGroundCol.setIntoCollideMask(CollideMask.allOff())
self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, .2))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((.2, .2, .2, 1))
directionalLight.setSpecularColor((.1, .1, .1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
#self.setupCD()
# Set the background color to black
# self.win.setClearColor((0.6, 0.6, 1.0, 1.0))
# self.fog = Fog('myFog')
# self.fog.setColor(0, 0, 0)
# self.fog.setExpDensity(.05)
# render.setFog(self.fog)
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0, "right": 0, "forward": 0, "cam-left": 0, "cam-right": 0, "c":0, "back":0, "space":0}
# Post the instructions
#self.title = addTitle(
# "Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.06, "[ESC]: Quit")
self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward")
#self.inst6 = addInstructions(0.30, "[A]: Rotate Camera Left")
#self.inst7 = addInstructions(0.36, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
#self.environ.reparentTo(render)
self.room = loader.loadModel("models/room2.egg")
self.room.reparentTo(render)
#self.room.setScale(.1)
self.room.setPos(0,0,-5)
self.room.setShaderAuto()
#self.room.writeBamFile("myRoom1.bam")
#self.room.setColor(1,.3,.3,1)
self.room2 = loader.loadModel("models/abstractroom2")
self.room2.reparentTo(render)
self.room2.setScale(.1)
self.room2.setPos(-12,0,0)
# Create the main character, Ralph
#ralphStartPos = LVecBase3F(0,0,0) #self.room.find("**/start_point").getPos()
self.ralph = Actor("models/ralph",
{"run": "models/ralph-run",
"walk": "models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(0,0,0)
#cs = CollisionSphere(0, 0, 0, 1)
#cnodePath = self.ralph.attachNewNode(CollisionNode('cnode'))
#cnodePath.node().addSolid(cs)
#cnodePath.node().setPos(0,0,0)
#cnodePath.show()
self.gianteye = loader.loadModel("models/gianteye")
self.gianteye.reparentTo(render)
self.gianteye.setScale(.1)
self.gianteye.setPos(10,10,0)
#self.bluefinal = loader.loadModel("models/chrysalis")
#self.bluefinal.reparentTo(render)
#self.bluefinal.setScale(.1)
#self.bluefinal.setPos(7,7,0)
#self.blue = loader.loadModel("models/blue1")
#self.blue.reparentTo(render)
#self.blue.setScale(.1)
#self.blue.setPos(10,5,0)
self.chik = loader.loadModel("models/chik")
self.chik.reparentTo(render)
self.chik.setScale(.1)
self.chik.setPos(3,13,0)
self.pawn = loader.loadModel("pawn")
self.pawn.reparentTo(render)
self.pawn.setPos(0,0,0)
self.shot = loader.loadModel("models/icosphere.egg")
self.shot.reparentTo(render)
self.shot.setScale(.5)
self.shot.setPos(0,0,1)
self.shot.setColor(1,.3,.3,1)
self.myShot = loader.loadModel("models/icosphere.egg")
#self.myShot.reparentTo(render)
self.myShot.setScale(.1)
self.myShot.setPos(0,0,1)
self.myShotVec = LVector3(0,0,0)
self.lightpivot3 = render.attachNewNode("lightpivot3")
self.lightpivot3.setPos(0, 0, 0)
self.lightpivot3.hprInterval(10, LPoint3(0, 0, 0)).loop()
plight3 = PointLight('plight2')
plight3.setColor((0, .3,0, 1))
plight3.setAttenuation(LVector3(0.7, 0.05, 0))
plnp3 = self.lightpivot3.attachNewNode(plight3)
plnp3.setPos(0, 0, 0)
self.room2.setLight(plnp3)
self.room.setLight(plnp3)
sphere3 = loader.loadModel("models/icosphere")
sphere3.reparentTo(plnp3)
sphere3.setScale(0.1)
sphere3.setColor((0,1,0,1))
# Create a floater object, which floats 2 units above ralph. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(8.0)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("arrow_down", self.setKey, ["back", True])
self.accept("a", self.setKey, ["cam-left", True])
self.accept("s", self.setKey, ["cam-right", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["back", False])
self.accept("a-up", self.setKey, ["cam-left", False])
self.accept("s-up", self.setKey, ["cam-right", False])
self.accept("space", self.setKey, ["space", True])
self.accept("space-up", self.setKey, ["space", False])
self.accept("c",self.setKey,["c",True])
self.accept("c-up",self.setKey,["c",False])
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
self.jumping = False
self.vz = 0
# Set up the camera
self.disableMouse()
self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 7, 3)
self.camLens.setFov(60)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
def setupCollision(self):
cs = CollisionSphere(0,0,2,1)
cnodePath = self.ralph.attachNewNode(CollisionNode('cnode'))
cnodePath.node().addSolid(cs)
cnodePath.show()
#for o in self.OBS:
#ct = CollisionTube(0,0,0, 0,0,1, 0.5)
#cn = o.attachNewNode(CollisionNode('ocnode'))
#cn.node().addSolid(ct)
#cn.show()
eyecs = CollisionSphere(0,0,4,5)
cnodePath = self.gianteye.attachNewNode(CollisionNode('cnode'))
cnodePath.node().addSolid(eyecs)
cnodePath.show()
eyecs = CollisionSphere(0,0,4,2)
cnodePath = self.chik.attachNewNode(CollisionNode('cnode'))
cnodePath.node().addSolid(eyecs)
cnodePath.show()
pusher = CollisionHandlerPusher()
pusher.addCollider(cnodePath, self.player)
self.cTrav = CollisionTraverser()
self.cTrav.add_collider(cnodePath,pusher)
self.cTrav.showCollisions(render)
self.walls = self.room2.find("**/wall_collide")
#self.walls.node().setIntoCollideMask(BitMask32.bit(0))
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 9)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0))
self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 9)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(CollideMask.bit(0))
self.camGroundCol.setIntoCollideMask(CollideMask.allOff())
self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
self.sphere = CollisionSphere(0,0,4,2)
self.sphere2 = CollisionSphere(0,0,2,2)
self.cnodePath = self.ralph.attachNewNode((CollisionNode('cnode')))
self.cnodePath.node().addSolid(self.sphere)
self.cnodePath.node().addSolid(self.sphere2)
self.cnodePath.show()
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(self.cnodePath, self.ralph)
self.cTrav.add_collider(self.cnodePath, self.pusher)
self.eyecs = CollisionSphere(0,0,22,25)
self.cnodePath1 = self.gianteye.attachNewNode(CollisionNode('cnode'))
self.cnodePath1.node().addSolid(self.eyecs)
self.cnodePath1.show()
self.pusher1 = CollisionHandlerPusher()
self.pusher1.addCollider(self.cnodePath1, self.gianteye)
self.cTrav.add_collider(self.cnodePath1, self.pusher1)
self.cTrav.showCollisions(render)
self.eyeGroundRay = CollisionRay()
self.eyeGroundRay.setOrigin(0, 0, 9)
self.eyeGroundRay.setDirection(0, 0, -1)
self.eyeGroundCol = CollisionNode('eyeRay')
self.eyeGroundCol.addSolid(self.eyeGroundRay)
self.eyeGroundCol.setFromCollideMask(CollideMask.bit(0))
self.eyeGroundCol.setIntoCollideMask(CollideMask.allOff())
self.eyeGroundColNp = self.gianteye.attachNewNode(self.eyeGroundCol)
self.eyeGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.eyeGroundColNp, self.eyeGroundHandler)
self.chikcs = CollisionSphere(0,0,11,20)
self.cnodePath2 = self.chik.attachNewNode(CollisionNode('cnode'))
self.cnodePath2.node().addSolid(self.chikcs)
self.cnodePath2.show()
self.pusher2 = CollisionHandlerPusher()
self.pusher2.addCollider(self.cnodePath, self.chik)
self.cTrav.add_collider(self.cnodePath, self.pusher2)
self.cTrav.showCollisions(render)
self.chikGroundRay = CollisionRay()
self.chikGroundRay.setOrigin(0, 0, 9)
self.chikGroundRay.setDirection(0, 0, -1)
self.chikGroundCol = CollisionNode('chikRay')
self.chikGroundCol.addSolid(self.chikGroundRay)
self.chikGroundCol.setFromCollideMask(CollideMask.bit(0))
self.chikGroundCol.setIntoCollideMask(CollideMask.allOff())
self.chikGroundColNp = self.chik.attachNewNode(self.chikGroundCol)
self.chikGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.chikGroundColNp, self.chikGroundHandler)
# Uncomment this line to see the collision rays
self.ralphGroundColNp.show()
self.camGroundColNp.show()
#self.ralphroom1ColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, .4))
ambientLight2 = AmbientLight("ambientLight2")
ambientLight2.setColor((1, 1, 1, 10))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((0, 0, -2))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
#self.environ.setLight(self.environ.attachNewNode(ambientLight2))
render.setLight(render.attachNewNode(directionalLight))
# Add a light to the scene.
self.lightpivot = render.attachNewNode("lightpivot")
self.lightpivot.setPos(0, 0, 1.6)
self.lightpivot.hprInterval(20, LPoint3(360, 0, 0)).loop()
plight = PointLight('plight')
plight.setColor((.7, .3, 0, 1))
plight.setAttenuation(LVector3(0.7, 0.05, 0))
plnp = self.lightpivot.attachNewNode(plight)
plnp.setPos(5, 0, 0)
self.room.setLight(plnp)
sphere = loader.loadModel("models/icosphere")
sphere.reparentTo(plnp)
sphere.setScale(0.1)
sphere.setColor((1,1,0,1))
self.lightpivot2 = render.attachNewNode("lightpivot")
self.lightpivot2.setPos(-16, 0, 1.6)
self.lightpivot2.hprInterval(20, LPoint3(360, 0, 0)).loop()
plight2 = PointLight('plight2')
plight2.setColor((0, .4,.8, 1))
plight2.setAttenuation(LVector3(0.7, 0.05, 0))
plnp2 = self.lightpivot2.attachNewNode(plight2)
plnp2.setPos(5, 0, 0)
self.room2.setLight(plnp2)
sphere2 = loader.loadModel("models/icosphere")
sphere2.reparentTo(plnp2)
sphere2.setScale(0.2)
sphere2.setColor((0,0,1,1))
self.vec = LVector3(0,1,0)
def __init__(self):
'''
class constructor
Creates environment, player objects
'''
# initialize
#ShowBase.__init__(self)
# set keybinds
setKeybinds()
mission = self
self.nextValidSpawn = 0
# handle collisions
# collision traversal 'traverses' instances of collides
base.cTrav = CollisionTraverser() #switched to base
base.pusher = CollisionHandlerPusher() #switched to base
base.pusher.addInPattern('entityCollision')
base.groundHandler = CollisionHandlerQueue()
# add catch-all handler
#base.entityCollisionHandler.addInPattern('entityCollision')
# handle entity collisions
# pass to entityCollided
base.accept('entityCollision', entityCollided)
# handle bullet collisions
# accept this event and pass it to method bulletCollided
base.accept('bulletCollision', bulletCollided)
# self.render references base.render
self.render = base.render
mission.CAPTURE_TIME = 15 #time to capture single flag
mission.CAPTURE_RADIUS = 300 #radius that needs to be controlled to cap flag
#cleanup is list that saves items to destroy on mission end
base.cleanup = []
# entities is list of all entities in gamespace. Used for applying gravity etc
base.entities = []
# also keep a running list of all structures
base.structures = []
#setup for AI
base.AIworld = AIWorld(base.render)
# load environment
self.makeEnviron("example")
# sfx handler for 3D audio
#base.audio3d = Audio3DManager(base.sfxManagerList[0], base.camera)
#background music
self.music = base.loader.loadSfx("sounds/dramatic.ogg")
self.music.setLoop(True)
self.music.setVolume(0.15)
self.music.play()
# load GUI
self.makeGUI()
#set up player and camera
#set mouse mode to relative
base.disableMouse()
setMouseMode(1)
#find nodes in environment and store on game object
self.team0Node = self.environment.find("**/team0")
self.team0BaseNode = self.environment.find("**/team0base")
self.team1Node = self.environment.find("**/team1")
self.team1BaseNode = self.environment.find("**/team1base")
#load occlusion nodes from environment
#format in blender:
#occlusion planes all parented to base level 'occluders' empty
#occlusion planes named 'occluder#'
occluder_nodes = self.environment.findAllMatches(
'**/occluders/+OccluderNode')
for occluder_nodepath in occluder_nodes:
base.render.setOccluder(occluder_nodepath)
occluder_nodepath.node().setDoubleSided(True)
#for now will attempt to load up to 12 flags, and reject entries that don't work
#TODO: dynamically load based on amount of flag nodes found
#also may change capture time depending on flag
self.flags = []
self.outposts = []
for i in range(12):
thisFlag = self.environment.find("**/flag" + str(i))
#only append if found successfully
if thisFlag.error_type == 0:
self.flags.append(thisFlag)
thisFlag.setPythonTag('lastCapture',
None) #last capture attempt
thisFlag.setPythonTag('lastCaptureTeam',
None) #last team that tried to cap
self.spawnPlayer()
#standing=rifleman(base,self.team0Node.getPos(),0)
#running = rifleman(base, self.team0Node.getPos(), 0)
#soldat = rifleman(base, self.team0Node.getPos(), 0)
#instancee=base.render.attachNewNode('blast')
#instancee.setX(instancee.getX()+200)
#instance=soldat.instanceTo(instancee)
#instancee.setX(instancee.getX()-180)
#enemy = rifleman(base, (20, 300, 0),1)
#friendly = rifleman(base, self.team0Node.getPos(), 0)
#friendly.setGoal(self.flags[1])
#load gameplay logic
# update all entities
taskMgr.add(self.updateEntities, "updateEntitiesTask")
self.playerScore = 0
self.spawnBases()
self.spawnEnemies()
class Player(DirectObject):
def __init__(self, _main):
self.main = _main
self.name = ""
self.points = 0
self.health = 100.0
self.runSpeed = 1.8
self.keyMap = {
"left":False,
"right":False,
"up":False,
"down":False
}
base.camera.setPos(0,0,0)
self.model = loader.loadModel("Player")
self.model.find('**/+SequenceNode').node().stop()
self.model.find('**/+SequenceNode').node().pose(0)
base.camera.setP(-90)
self.playerHud = Hud()
self.playerHud.hide()
self.model.hide()
# Weapons: size=2, 0=main, 1=offhand
self.mountSlot = []
self.activeWeapon = None
self.isAutoActive = False
self.trigger = False
self.lastShot = 0.0
self.fireRate = 0.0
self.playerTraverser = CollisionTraverser()
self.playerEH = CollisionHandlerEvent()
## INTO PATTERNS
self.playerEH.addInPattern('intoPlayer-%in')
#self.playerEH.addInPattern('colIn-%fn')
self.playerEH.addInPattern('intoHeal-%in')
self.playerEH.addInPattern('intoWeapon-%in')
## OUT PATTERNS
self.playerEH.addOutPattern('outOfPlayer-%in')
playerCNode = CollisionNode('playerSphere')
playerCNode.setFromCollideMask(BitMask32.bit(1))
playerCNode.setIntoCollideMask(BitMask32.bit(1))
self.playerSphere = CollisionSphere(0, 0, 0, 0.6)
playerCNode.addSolid(self.playerSphere)
self.playerNP = self.model.attachNewNode(playerCNode)
self.playerTraverser.addCollider(self.playerNP, self.playerEH)
#self.playerNP.show()
self.playerPusher = CollisionHandlerPusher()
self.playerPusher.addCollider(self.playerNP, self.model)
self.playerPushTraverser = CollisionTraverser()
self.playerPushTraverser.addCollider(self.playerNP, self.playerPusher)
def acceptKeys(self):
self.accept("w", self.setKey, ["up", True])
self.accept("w-up", self.setKey, ["up", False])
self.accept("a", self.setKey, ["left", True])
self.accept("a-up", self.setKey, ["left", False])
self.accept("s", self.setKey, ["down", True])
self.accept("s-up", self.setKey, ["down", False])
self.accept("d", self.setKey, ["right", True])
self.accept("d-up", self.setKey, ["right", False])
# Add mouse btn for fire()
self.accept("mouse1", self.setWeaponTrigger, [True])
self.accept("mouse1-up", self.setWeaponTrigger, [False])
# Killed enemies
self.accept("killEnemy", self.addPoints)
# Game states
self.accept("doDamageToPlayer", self.doDamage)
def ignoreKeys(self):
self.ignore("w")
self.ignore("a")
self.ignore("s")
self.ignore("d")
self.ignore("killEnemy")
self.ignore("mouse1")
self.ignore("mouse1-up")
for item in self.main.itemList:
if item.type == "heal":
self.ignore("intoHeal-" + "itemHeal" + str(item.id))
elif item.type == "gun":
self. ignore("intoWeapon-" + "itemWeapon" + str(item.id))
for enemy in self.main.enemyList:
self.ignore("intoPlayer-" + "colEnemy" + str(enemy.id))
# Add mouse btn for fire to ignore
def setKey(self, action, pressed):
self.keyMap[action] = pressed
def start(self, startPos, playerName):
self.name = playerName
self.points = 0
self.health = 100
self.model.reparentTo(render)
self.model.setPos(startPos.x,
startPos.y,
0)
for slot in self.mountSlot[:]:
self.mountSlot.remove(slot)
# Create a basic weapon
self.mountSlot.append(Weapon(self.main, "Pistol", 0.30, 25, weaponType="Pistol"))
# Mount the players default weapon
self.mountWeapon(self.mountSlot[0])
self.playerHud.setWeapon("Pistol")
self.acceptKeys()
self.playerHud.show()
taskMgr.add(self.move, "moveTask")
def stop(self):
taskMgr.remove("moveTask")
self.ignoreKeys()
self.unmountWeapon()
self.playerHud.hide()
self.model.hide()
def addPoints(self, args):
self.points += 10
base.messenger.send("setHighscore", [self.points])
def move(self, task):
elapsed = globalClock.getDt()
#self.playerTraverser.traverse(self.main.enemyParent)
#self.playerTraverser.traverse(self.main.itemParent)
# set headding
pos = self.main.mouse.getMousePos()
pos.setZ(0)
self.model.lookAt(pos)
self.model.setP(-90)
# new player position
if self.keyMap["up"]:
# follow mouse mode
#self.model.setZ(self.model, 5 * elapsed * self.runSpeed)
# axis move mode
self.model.setY(self.model.getY() + elapsed * self.runSpeed)
elif self.keyMap["down"]:
#self.model.setZ(self.model, -5 * elapsed * self.runSpeed)
self.model.setY(self.model.getY() - elapsed * self.runSpeed)
if self.keyMap["left"]:
# follow mouse mode
#self.model.setX(self.model, -5 * elapsed * self.runSpeed)
# axis move mode
self.model.setX(self.model.getX() - elapsed * self.runSpeed)
elif self.keyMap["right"]:
#self.model.setX(self.model, 5 * elapsed * self.runSpeed)
self.model.setX(self.model.getX() + elapsed * self.runSpeed)
# actualize cam position
base.camera.setPos(self.model.getPos())
base.camera.setZ(20)
return task.cont
def mountWeapon(self, _weaponToMount):
self.activeWeapon = _weaponToMount # self.mountSlot[0]
if self.activeWeapon.style == "TwoHand":
self.model.find('**/+SequenceNode').node().pose(0)
else:
self.model.find('**/+SequenceNode').node().pose(1)
self.activeWeapon.model.reparentTo(self.model)
self.activeWeapon.model.setY(self.model.getY() - 0.1)
self.model.show()
self.activeWeapon.model.show()
self.fireRate = self.activeWeapon.fireRate
def unmountWeapon(self):
self.activeWeapon.model.hide()
def setWeaponTrigger(self, _state):
self.trigger = _state
if _state:
mpos = self.main.mouse.getMousePos()
self.activeWeapon.doFire(mpos)
if self.activeWeapon.weaponType == "MG":
self.fireActiveWeapon()
else:
self.activeWeapon.stopFire()
else:
self.activeWeapon.stopFire()
taskMgr.remove("Fire")
def fireActiveWeapon(self):
if self.activeWeapon:
#mpos = self.main.mouse.getMousePos()
taskMgr.add(self.fireUpdate, "Fire")
#self.activeWeapon.doFire(mpos)
def fireUpdate(self, task):
dt = globalClock.getDt()
self.lastShot += dt
mpos = self.main.mouse.getMousePos()
#print self.lastShot
if self.lastShot >= self.fireRate:
self.lastShot -= self.fireRate
if self.trigger:
self.activeWeapon.doFire(mpos)
#task.delayTime += self.fireRate
return task.again
def setMouseBtn(self):
self.trigger = False
print "Mouse Released"
def addEnemyDmgEvent(self, _id):
self.accept("intoPlayer-" + "colEnemy" + str(_id), self.setEnemyAttack)
#self.accept("outOfPlayer-" + "colEnemy" + str(_id), self.setEnemyAttackOutOfRange)
def setEnemyAttack(self, _entry):
enemyColName = _entry.getIntoNodePath().node().getName()
base.messenger.send("inRange-" + enemyColName, [True])
def setEnemyAttackOutOfRange(self, _entry):
enemyColName = _entry.getIntoNodePath().node().getName()
base.messenger.send("inRange-" + enemyColName, [False])
def doDamage(self, _dmg):
if self.health <= 0:
#print "KILLED IN ACTION"
self.main.stop()
else:
self.health -= _dmg
#print "Remaining Health: ", self.health
base.messenger.send("setHealth", [self.health])
def addHealItemEvent(self, _id):
self.accept("intoHeal-" + "itemHeal" + str(_id), self.healPlayer)
def healPlayer(self, _entry):
itemColName = _entry.getIntoNodePath().node().getName()
if self.health == 100:
pass
else:
self.health += 50
base.messenger.send("into-" + itemColName)
if self.health > 100:
self.health = 100
print self.health
def addWeaponItemEvent(self, _id):
self.accept("intoWeapon-" + "itemWeapon" + str(_id), self.changeWeapon)
def changeWeapon(self, _entry):
itemColName = _entry.getIntoNodePath().node().getName()
base.messenger.send("into-" + itemColName)
for weapon in self.mountSlot:
if weapon.name == "MachineGun":
return
self.unmountWeapon()
self.mountSlot.append(Weapon(self.main, "MachineGun", 0.15, 50, weaponType="MG"))
self.playerHud.setWeapon("MG")
self.mountWeapon(self.mountSlot[len(self.mountSlot) - 1])
self.activeWeapon.model.show()
def initialize(self):
self.timer = 0
base.enableParticles()
#base.setFrameRateMeter(True)
##########
#
# SETUP COLLISION HANDLERS AND FLAMIE'S MODEL
#
##########
#Create the collision handlers in order to build the level.
WALL_MASK = BitMask32.bit(2)
FLOOR_MASK = BitMask32.bit(1)
#Start up the collision system
self.cTrav = CollisionTraverser()
#Determine how collisions with walls will be handled
self.wallHandler = CollisionHandlerPusher()
self.bobbing = False
#Setup flamie's model
self.flamieNP = base.render.attachNewNode(ActorNode('flamieNP'))
self.flamieNP.reparentTo(base.render)
self.flamie = loader.loadModel('models/Flame/body')
self.flamie.setScale(.5)
self.flamie.setTransparency(TransparencyAttrib.MAlpha)
self.flamie.setAlphaScale(0)
self.flamie.reparentTo(self.flamieNP)
self.flamie.setCollideMask(BitMask32.allOff())
flameLight = DirectionalLight("flameLight")
fl = self.flamie.attachNewNode(flameLight)
fl.setColor(255, 255, 255, 1)
flameLight.setDirection((-5, -5, -5))
self.flamie.setLight(fl)
self.flamie2 = loader.loadModel("models/p.obj")
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f7.png"))
self.flamie2.reparentTo(self.flamieNP)
self.flamie2.setScale(4)
self.flamie2OriZ = 2
self.flamie2.setPos(-6.5, 0, self.flamie2OriZ) #(length, depth, height)
self.flamie2.setLight(fl)
self.flamie2.setTransparency(TransparencyAttrib.MAlpha)
self.flamieFire = PointLight('fire')
self.flamieFire.setColor(VBase4(1,1,1,1))
self.flamieFire.setAttenuation((1,0,1))
plnp = render.attachNewNode(self.flamieFire)
plnp.setPos(self.flamieNP.getPos())
self.flamielight = AmbientLight('light')
self.flamielight.setColor(VBase4(1, 0.5, 0.6, 1))
self.flamielight = self.flamie2.attachNewNode(self.flamielight)
self.flamie2.setLight(self.flamielight)
self.flamie2.setLight(plnp)
self.mayFlamieBob = True
#self.flamie2.setAlphaScale(0.5)
'''self.tree = loader.loadModel("models/p2.obj")
self.tree.setTexture(loader.loadTexture("deadTree.png"))
self.tree.reparentTo(render)
self.tree.setScale(4)
self.tree.setPos(25,25,0) #(length, depth, height)
self.tree.setLight(fl)
self.tree.setTransparency(TransparencyAttrib.MAlpha)
self.treelight = AmbientLight('light')
self.treelight.setColor(VBase4(0.9, 0.9, 0.6, 1))
self.treelight = self.tree.attachNewNode(self.treelight)
self.tree.setLight(self.treelight)'''
x = 150
y = 20
offset1 = 0
treeList2 = [loader.loadModel("models/p2.obj") for i in range(7)]
for j in treeList2:
k = random.randint(1, 100)
if k%5 is 1 or k%5 is 2:
j.setTexture(loader.loadTexture("deadTree.png"))
else:
j.setTexture(loader.loadTexture("tree.png"))
j.reparentTo(render)
j.setScale(random.randint(4,7))
j.setTransparency(TransparencyAttrib.MAlpha)
j.setPos(x + 3*offset1, y + 4*offset1, 0)
treelight = AmbientLight('light')
treelight = j.attachNewNode(treelight)
j.setLight(treelight)
offset1 = offset1 + random.randint(4, 10)
x = 4
y = 90
offset1 = 0
treeList2 = [loader.loadModel("models/p2.obj") for i in range(6)]
for j in treeList2:
k = random.randint(1, 100)
if k%5 is 1 or k%5 is 2:
j.setTexture(loader.loadTexture("deadTree.png"))
else:
j.setTexture(loader.loadTexture("tree.png"))
j.reparentTo(render)
j.setScale(random.randint(4,7))
j.setTransparency(TransparencyAttrib.MAlpha)
j.setPos(x + 3*offset1, y + 4*offset1, 0)
treelight = AmbientLight('light')
treelight = j.attachNewNode(treelight)
j.setLight(treelight)
offset1 = offset1 + random.randint(4, 10)
x = 3
y = 120
offset1 = 0
treeList2 = [loader.loadModel("models/p2.obj") for i in range(4)]
for j in treeList2:
k = random.randint(1, 100)
if k%5 is 1 or k%5 is 2:
j.setTexture(loader.loadTexture("deadTree.png"))
else:
j.setTexture(loader.loadTexture("tree.png"))
j.reparentTo(render)
j.setScale(random.randint(4,7))
j.setTransparency(TransparencyAttrib.MAlpha)
j.setPos(x + 3*offset1, y + 4*offset1, 0)
treelight = AmbientLight('light')
treelight = j.attachNewNode(treelight)
j.setLight(treelight)
offset1 = offset1 + random.randint(4, 10)
x = 200
y = 20
offset1 = 0
treeList2 = [loader.loadModel("models/p2.obj") for i in range(4)]
for j in treeList2:
k = random.randint(1, 100)
if k%5 is 1 or k%5 is 2:
j.setTexture(loader.loadTexture("deadTree.png"))
else:
j.setTexture(loader.loadTexture("tree.png"))
j.reparentTo(render)
j.setScale(random.randint(4,7))
j.setTransparency(TransparencyAttrib.MAlpha)
j.setPos(x + 3*offset1, y + 4*offset1, 0)
treelight = AmbientLight('light')
treelight = j.attachNewNode(treelight)
j.setLight(treelight)
offset1 = offset1 + random.randint(4, 10)
### Something that should look like water ###
w = loader.loadModel("models/flatP.obj")
w.setTexture(loader.loadTexture("ice.png"))
w.reparentTo(render)
w.setScale(75)
w.setTransparency(TransparencyAttrib.MAlpha)
w.setAlphaScale(.7)
w.setLight(treelight)
w.setPos(-200, 0, -10)
self.waterOrigiZ = -10
self.waterSecZ = -95
self.waterThirdZ = -120
self.water = w
### Reskying the sky ###
w = loader.loadModel("models/biggerFlatP.obj")
w.setTexture(loader.loadTexture("models/n2.jpg"))
w.reparentTo(self.flamie2)
w.setScale(15)
w.setLight(treelight)
w.setPos(-200, 450, -200) #(length, depth, height)
#Give flamie gravity
self.floorHandler = CollisionHandlerGravity()
self.floorHandler.setGravity(9.81+100)
self.floorHandler.setMaxVelocity(100)
##########
#
# GENERATING LEVEL PARTS
#
##########
self.ice_reset = ()
self.start = PlatformSeg(LVector3(0,0,0))
self.start.generateAllParts(render)
self.checkpointCreator(70, 90, self.start.pos.z, 10)
self.floater = False
for p in self.start.parts:
if isinstance(p, Prism):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, p.dep, 'terraincollision', 'wallcollision')
if isinstance(p, Square):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, 3, 'terraincollision', 'wallcollision')
if isinstance(p, IceCube):
p.model.setCollideMask(BitMask32.allOff())
self.ice_reset += (p,)
iceCubefloor= p.model.find("**/iceFloor")
iceCubewall = p.model.find("**/iceWall")
iceCubefloor.node().setIntoCollideMask(FLOOR_MASK)
iceCubewall.node().setIntoCollideMask(WALL_MASK)
self.lostWood = LostWood(LVector3(self.start.pos.x + 750, self.start.parts[0].pos.y + self.start.parts[0].wid, self.start.pos.z))
self.lostWood.generateAllParts(render)
self.checkpointCreator(self.lostWood.pos.x+120, self.lostWood.pos.y+150, self.lostWood.pos.z,20)
self.checkpointCreator(self.lostWood.parts[6].pos.x + self.lostWood.parts[6].len/2, self.lostWood.parts[6].pos.y + self.lostWood.parts[6].wid/2, self.lostWood.pos.z, 40)
for p in self.lostWood.parts:
if isinstance(p, Prism):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, p.dep, 'terraincollision', 'wallcollision')
if isinstance(p, Square):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, 3, 'terraincollision', 'wallcollision')
if isinstance(p, IceCube):
p.model.setCollideMask(BitMask32.allOff())
self.ice_reset += (p,)
iceCubefloor= p.model.find("**/iceFloor")
iceCubewall = p.model.find("**/iceWall")
iceCubefloor.node().setIntoCollideMask(FLOOR_MASK)
iceCubewall.node().setIntoCollideMask(WALL_MASK)
self.cave = Cave(LVector3(self.lostWood.pos.x + 1100, self.lostWood.pos.y + 2000, self.lostWood.pos.z - 50))
self.cave.generateAllParts(render)
self.checkpointCreator(self.cave.thirdRoomParts[5].pos.x + self.cave.thirdRoomParts[5].len/2,
self.cave.thirdRoomParts[5].pos.y + self.cave.thirdRoomParts[5].wid/2,
self.cave.thirdRoomParts[5].pos.z, 30)
for p in self.cave.parts:
if isinstance(p, Prism):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, p.dep, 'terraincollision', 'wallcollision')
if isinstance(p, Square):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, 3, 'terraincollision', 'wallcollision')
if isinstance(p, IceCube):
p.model.setCollideMask(BitMask32.allOff())
self.ice_reset += (p,)
iceCubefloor= p.model.find("**/iceFloor")
iceCubewall = p.model.find("**/iceWall")
iceCubefloor.node().setIntoCollideMask(FLOOR_MASK)
iceCubewall.node().setIntoCollideMask(WALL_MASK)
self.end = End(LVector3(self.cave.thirdRoomParts[8].pos.x - 200,
self.cave.thirdRoomParts[8].pos.y + self.cave.thirdRoomParts[8].wid,
self.cave.thirdRoomParts[8].pos.z))
self.end.generate(render)
self.collisionBoxCreator(self.end.floor.pos.x, self.end.floor.pos.y, self.end.floor.pos.z,
self.end.floor.len, self.end.floor.wid, self.end.floor.dep,
'terraincollision', 'wallcollision')
#########
# DRAWING THE CABIN AND FINAL CAMPFIRE
#########
self.checkpointCreator(self.end.floor.pos.x + self.end.floor.len/2,
self.end.floor.pos.y + self.end.floor.wid/2,
self.end.floor.pos.z, 30)
self.cabin = loader.loadModel("models/p2.obj")
self.cabin.setTexture(loader.loadTexture("models/cabin.png"))
self.cabin.setScale(50)
self.cabin.reparentTo(render)
self.cabin.setPos(self.end.floor.pos.x + self.end.floor.len/2,
self.end.floor.pos.y + self.end.floor.wid/1.1,
self.end.floor.pos.z)
self.cabin.setTransparency(TransparencyAttrib.MAlpha)
#Manually creating starting position. Copy and paste the first three parameters of the checkpoint you want to start at.
self.startPos = LVector3(70, 90, self.start.pos.z)
self.flamieNP.setPos(self.startPos)
'''#Testing the tree model
self.tree = loader.loadModel('models/Tree/log')
self.tree.reparentTo(render)
self.tree.setPos(-50,0,100)
self.tree.setScale(2)'''
'''#Add sky background
self.sky = loader.loadModel('models/sphere.obj')
self.sky.reparentTo(self.camera)
self.sky.set_two_sided(True)
self.skyTexture = loader.loadTexture("models/n2.jpg")
self.sky.setTexture(self.skyTexture)
self.sky.set_bin('background', 0)
self.sky.set_depth_write(False)
self.sky.set_compass()'''
##########
#
# CREATE FLAMIE'S COLLISION GEOMETRY
#
##########
#Give flamie a collision sphere in order to collide with walls
flamieCollider = self.flamie.attachNewNode(CollisionNode('flamiecnode'))
flamieCollider.node().addSolid(CollisionSphere(0,0,0,5))
flamieCollider.node().setFromCollideMask(WALL_MASK)
flamieCollider.node().setIntoCollideMask(BitMask32.allOff())
self.wallHandler.addCollider(flamieCollider, self.flamieNP)
self.cTrav.addCollider(flamieCollider, self.wallHandler)
#Give flamie a collision ray to collide with the floor
flamieRay = self.flamie.attachNewNode(CollisionNode('flamieRay'))
flamieRay.node().addSolid(CollisionRay(0,0,8,0,0,-1))
flamieRay.node().setFromCollideMask(FLOOR_MASK)
flamieRay.node().setIntoCollideMask(BitMask32.allOff())
self.floorHandler.addCollider(flamieRay, self.flamieNP)
self.cTrav.addCollider(flamieRay, self.floorHandler)
#Add a sensor that lets us melt ice cubes without standing on the cube.
meltSensor = self.flamie.attachNewNode(CollisionNode('meltSensor'))
cs = CollisionSphere(-2,0,10, 50)
meltSensor.node().addSolid(cs)
meltSensor.node().setFromCollideMask(WALL_MASK)
meltSensor.node().setIntoCollideMask(BitMask32.allOff())
cs.setTangible(0)
self.wallHandler.addCollider(meltSensor, self.flamieNP)
self.cTrav.addCollider(meltSensor, self.wallHandler)
self.wallHandler.addInPattern('%fn-into-%in')
self.wallHandler.addAgainPattern('%fn-again-%in')
self.accept('meltSensor-into-iceWall', self.melt)
self.accept('meltSensor-again-iceWall', self.melt)
self.accept('meltSensor-into-checkpointCol', self.newstart)
#Add in an event handle to prevent the jumping glitch found on the bobbing ice cubes.
self.floorHandler.addInPattern('%fn-into-%in')
self.floorHandler.addAgainPattern('%fn-again-%in')
self.floorHandler.addOutPattern('%fn-out-%in')
self.accept('flamieRay-into-iceFloor', self.jittercancel)
self.accept('flamieRay-again-iceFloor', self.jittercancel)
self.accept('flamieRay-out-iceFloor', self.jittercanceloff)
#Uncomment these lines to see flamie's collision geometry
#flamieCollider.show()
#flamieRay.show()
#meltSensor.show()
#Uncomment this line to see the actual collisions.
#self.cTrav.showCollisions(render)
#This plane is found at the very bottom of the level and adds global gravity.
killfloor = CollisionPlane(Plane(Vec3(0,0,1), Point3(0,0,-1000)))
killfloorCol = CollisionNode('kfcollision')
killfloorCol.addSolid(killfloor)
killfloorCol.setIntoCollideMask(BitMask32.bit(1))
killfloorColNp = self.render.attachNewNode(killfloorCol)
####################
#
# Setting light so that we could see the definition in the walls
#
####################
render.setShaderAuto()
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(LVector4(0.3, 0.1, 0.7, 1))
dlnp = render.attachNewNode(self.dlight)
dlnp.setHpr(90, 20, 0)
render.setLight(dlnp)
self.alight = render.attachNewNode(AmbientLight("Ambient"))
self.alight.node().setColor(LVector4(0.5, 0.5, 1, .1))
render.setLight(self.alight)
self.snow = loader.loadTexture("models/ground.jpg")
#Create a floater object and have it float 2 units above fireball.
#And use this as a target for the camera to focus on.
#This idea is taken from the roaming ralph sample that came with the
#Panda3D SDK.
self.camFocus = NodePath(PandaNode("floater"))
self.camFocus.reparentTo(render)
self.camFocusCurrZ = self.flamie.getZ() + 10
#The camera is locked to the avatar so it always follows regardless of movement.
self.camera.reparentTo(render)
self.cameraTargetHeight = 8.0
self.cameraDistance = 100
self.cameraHeightModes = (self.start.parts[0].pos.z + 45, self.start.parts[0].pos.z + 125, self.camFocus.getZ() + 10, self.camFocus.getZ() + 150,
self.end.floor.pos.z + 10)
self.cameraHeight = self.cameraHeightModes[0]
class RoamingRalphDemo(ShowBase):
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
self.orbCollisionHandler = CollisionHandlerQueue()
self.cTrav = CollisionTraverser()
#hbPath = NodePath()
utils3.setUpKeys(self)
utils3.loadModels(self)
utils3.setUpLighting(self)
utils3.setUpFloatingSpheres(self)
utils3.setUpRalphsShot(self)
utils3.setUpCamera(self)
self.healthTxt = utils3.addInstructions(.06,"Health: 100")
self.orbTxt = utils3.addInstructions(.18,"Orbs: 0")
self.vec = LVector3(0,1,0)#vector for pawns shot
# Create a frame
#frame = DirectFrame(text = "main", scale = 0.001)
# Add button
#bar = DirectWaitBar(text = "", value = 50, pos = (0,.4,.4))
#bar.reparent(render)
# Game state variables
self.isMoving = False
self.jumping = False
self.vz = 0
self.numOrbs = 0
self.healthCount = 100
#self.shotList = []
taskMgr.add(self.move, "moveTask")
#taskMgr.add(utils2.moveChris,"moveChrisTask")
self.sphere = CollisionSphere(0,0,4,2)
self.sphere2 = CollisionSphere(0,0,2,2)
self.cnodePath = self.ralph.attachNewNode((CollisionNode('ralphColNode')))
self.cnodePath.node().addSolid(self.sphere)
self.cnodePath.node().addSolid(self.sphere2)
#self.cnodePath.show()
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(self.cnodePath, self.ralph)
#self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler)
self.cTrav.addCollider(self.cnodePath, self.pusher)
ca = CollisionSphere(0,0,0,20)
cb = self.chik.attachNewNode(CollisionNode('chikCollisionNode'))
cb.node().addSolid(ca)
cb.show()
cc = CollisionSphere(3,5,12,25)
cd = self.gianteye.attachNewNode(CollisionNode('gianteyeCollisionNode'))
cd.node().addSolid(cc)
cd.show()
ci = CollisionSphere(0,0,0,2)
coi = self.catidol.attachNewNode(CollisionNode('catidolCollisionNode'))
coi.node().addSolid(ci)
coi.show()
chi = CollisionSphere(-1,3,3,3)
chco = self.chris.attachNewNode(CollisionNode('chrisColPath'))
chco.node().addSolid(chi)
self.cTrav.addCollider(chco, self.orbCollisionHandler)
#chco.show()
self.chris.setH(90)
self.chris.setR(-90)
self.chris.setZ(2)
#cbox = CollisionBox((-50,30,20),10,85,20)
#cboxPath = self.room.attachNewNode(CollisionNode('roomSide1'))
#cboxPath.node().addSolid(cbox)
#cboxPath.show()
#cbox2 = CollisionBox((200,30,20),10,85,20)
#cboxPath2 = self.room.attachNewNode(CollisionNode('roomSide1'))
#cboxPath2.node().addSolid(cbox2)
#cboxPath2.show()
#cbox3 = CollisionBox((80,-60,20),120,20,20)
#cboxPath3 = self.room.attachNewNode(CollisionNode('roomSide1'))
#cboxPath3.node().addSolid(cbox3)
#cboxPath3.show()
ct = CollisionSphere(0,0,0,1)
cn = self.pawn.attachNewNode(CollisionNode('pawnCollisionNode'))
cn.node().addSolid(ct)
cn.show()
cs2 = CollisionSphere(0,0,0,.2)
cs2path = self.plnp.attachNewNode((CollisionNode('orbColPath')))
cs2path.node().addSolid(cs2)
cs2path.show()
self.cTrav.addCollider(cs2path, self.orbCollisionHandler)
#cs3 = CollisionSphere(0,0,0,1)
cs3path = self.plnp2.attachNewNode((CollisionNode('orbColPath')))
cs3path.node().addSolid(cs2)
cs3path.show()
chrisShotNp = self.chrisShot.attachNewNode((CollisionNode("enemyOrbColPath")))
chrisShotNp.node().addSolid(cs2)
chrisShotNp.show()
self.cTrav.addCollider(cs3path, self.orbCollisionHandler)
self.cTrav.addCollider(chrisShotNp, self.orbCollisionHandler)
# Uncomment this line to show a visual representation of the
# collisions occuring
self.cTrav.showCollisions(render)
self.chrisLastShotTime = globalClock.getFrameTime()
self.chrisTimer = globalClock.getDt()
# Records the state of the arrow keys
def setKey(self, key, value):
self.keyMap[key] = value
# Accepts arrow keys to move either the player or the menu cursor,
# Also deals with grid checking and collision detection
def move(self, task):
# Get the time that elapsed since last frame. We multiply this with
# the desired speed in order to find out with which distance to move
# in order to achieve that desired speed.
dt = globalClock.getDt()
utils3.moveChris(self,dt)
# If the camera-left key is pressed, move camera left.
# If the camera-right key is pressed, move camera right.
if self.keyMap["cam-left"]:
self.camera.setZ(self.camera, -20 * dt)
if self.keyMap["cam-right"]:
self.camera.setZ(self.camera, +20 * dt)
# save ralph's initial position so that we can restore it,
# in case he falls off the map or runs into something.
startpos = self.ralph.getPos()
# If a move-key is pressed, move ralph in the specified direction.
if self.keyMap["left"]:
self.ralph.setH(self.ralph.getH() + 150 * dt)
#self.camera.setX(self.camera, +15.5 * dt)
if self.keyMap["right"]:
self.ralph.setH(self.ralph.getH() - 150 * dt)
#self.camera.setX(self.camera, -15.5 * dt)
if self.keyMap["forward"]:
self.ralph.setY(self.ralph, -35 * dt)
#self.camera.setY(self.camera, -35 * dt)
if self.keyMap["back"]:
self.ralph.setY(self.ralph, +35 * dt)
#self.camera.setY(self.camera, 35 * dt)
if self.keyMap["c"]:
if self.jumping is False:
#self.ralph.setZ(self.ralph.getZ() + 100 * dt)
self.jumping = True
self.vz = 7
if self.keyMap["space"]:
self.keyMap["space"] = False
self.shotList[self.shotCount].lpivot.setPos(self.ralph.getPos())
self.shotList[self.shotCount].lpivot.setZ(self.ralph.getZ() + .5)
self.shotList[self.shotCount].lpivot.setX(self.ralph.getX() - .25)
#self.shotList.append(rShot)
#self.lightpivot3.setPos(self.ralph.getPos())
#self.lightpivot3.setZ(self.ralph.getZ() + .5)
#self.lightpivot3.setX(self.ralph.getX() - .25)
#self.myShot.setHpr(self.ralph.getHpr())
#parent to ralph
#node = NodePath("tmp")
#node.setHpr(self.ralph.getHpr())
#vec = render.getRelativeVector(node,(0,-1,0))
#self.myShotVec = vec
node = NodePath("tmp")
node.setHpr(self.ralph.getHpr())
vec = render.getRelativeVector(node,(0,-1,0))
self.shotList[self.shotCount].vec = vec
self.shotCount = (self.shotCount + 1) % 5
for rs in self.shotList:
rs.lpivot.setPos(rs.lpivot.getPos() + rs.vec * dt * 15 )
#if shot is too far stop updating
if self.jumping is True:
self.vz = self.vz - 16* dt
self.ralph.setZ(self.ralph.getZ() + self.vz * dt )
if self.ralph.getZ() < 0:
self.ralph.setZ(0)
self.jumping = False
else:
if self.ralph.getZ() < 0:
self.ralph.setZ(0)
elif self.ralph.getZ() > 0:
self.ralph.setZ(self.ralph.getZ() -7 * dt)
# If ralph is moving, loop the run animation.
# If he is standing still, stop the animation.
if self.keyMap["forward"] or self.keyMap["left"] or self.keyMap["right"] or self.keyMap["c"] or self.keyMap["forward"] or self.keyMap["back"]:
if self.isMoving is False:
self.ralph.loop("run")
self.isMoving = True
else:
if self.isMoving:
self.ralph.stop()
self.ralph.pose("walk", 5)
self.isMoving = False
# update pawns shot or set up new shot after it reaches a certain distance
node = NodePath("tmp")
node.setHpr(self.pawn.getHpr())
vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0))
self.shot.setPos(self.shot.getPos() + self.vec * dt * 10 )
if self.shot.getY() < -15 or self.shot.getY() > 30 or self.shot.getX() < 5 or self.shot.getX() > 15:
self.shot.setPos(self.pawn.getPos() + (0,0,0))
self.vec = render.getRelativeVector(node,(random.random() * -0.8,random.random() + 1,0))
self.vec = render.getRelativeVector(node,(random.random() * random.randrange(-1,2),random.random() + 1,0))
# If the camera is too far from ralph, move it closer.
# If the camera is too close to ralph, move it farther.
#self.camera.lookAt(self.floater)
camvec = self.ralph.getPos() - self.camera.getPos()
#camvec = Vec3(0,camvec.getY(),0)
camdist = camvec.length()
x = self.camera.getZ()
camvec.normalize()
#if camdist > 6.0:
# self.camera.setPos(self.camera.getPos() + camvec * (camdist - 6))
#if camdist < 6.0:
# self.camera.setPos(self.camera.getPos() - camvec * (6 - camdist))
# Normally, we would have to call traverse() to check for collisions.
# However, the class ShowBase that we inherit from has a task to do
# this for us, if we assign a CollisionTraverser to self.cTrav.
#self.cTrav.traverse(render)
# Adjust camera so it stays at same height
if self.camera.getZ() < self.ralph.getZ() + 1 or self.camera.getZ() > self.ralph.getZ() + 1:
self.camera.setZ(self.ralph.getZ() + 1)
# The camera should look in ralph's direction,
# but it should also try to stay horizontal, so look at
# a floater which hovers above ralph's head.
self.camera.lookAt(self.floater)
entries = list(self.orbCollisionHandler.getEntries())
if(len(entries) > 0):
#self.lightpivot.reparentTo(NodePath())
for entry in self.orbCollisionHandler.getEntries():
#print(entry)
fromColNp = entry.getFromNodePath()
toColNp = entry.getIntoNodePath()
if fromColNp.getName() == "orbColPath" and toColNp.getName() == "ralphColNode":
fromColNp.getParent().reparentTo(NodePath())
self.orbTxt.destroy()
self.numOrbs += 1
str1 = "Orbs: " + str(self.numOrbs)
self.orbTxt = utils3.addInstructions(.18, str1)
elif toColNp.getName() == "orbColPath" and fromColNp.getName() == "ralphColNode":
toColNp.getParent().reparentTo(NodePath())
self.orbTxt.destroy()
self.numOrbs += 1
str1 = "Orbs: " + str(self.numOrbs)
self.orbTxt = utils3.addInstructions(.18, str1)
elif toColNp.getName() == "ralphOrbColPath" and fromColNp.getName() == "chrisColPath":
toColNp.getParent().setPos(-50,0,2)
self.chrisHealth = self.chrisHealth - 1
self.chris.setColor(1,0,0,1)
self.chrisHit = True
self.chrisRedTime = globalClock.getFrameTime()
#print self.chrisRedTime
if self.chrisHealth < 0:
fromColNp.getParent().removeNode()
self.chrisAlive = False
elif toColNp.getName() == "chrisColPath" and fromColNp.getName() == "ralphOrbColPath":
fromColNp.getParent().setPos(-50,0,2)
self.chrisHealth = self.chrisHealth - 1
self.chris.setColor(1,0,0,1)
self.chrisHit = True
self.chrisRedTime = globalClock.getFrameTime()
#print self.chrisRedTime
if self.chrisHealth < 0:
fromColNp.getParent().removeNode()
self.chrisAlive = False
self.chrisShot.setZ(26)
elif toColNp.getName() == "enemyOrbColPath" and fromColNp.getName() == "ralphColNode":
toColNp.getParent().setZ(26)
self.healthTxt.destroy()
self.healthCount -= 3
str1 = "Health: " + str(self.healthCount)
self.healthTxt = utils3.addInstructions(.06, str1)
elif toColNp.getName() == "ralphColNode" and fromColNp.getName() == "enemyOrbColPath":
fromColNp.getParent().setZ(26)
self.healthTxt.destroy()
self.healthCount -= 3
str1 = "Health: " + str(self.healthCount)
self.healthTxt = utils3.addInstructions(.06, str1)
return task.cont
class Player:
STATE_IDLE = "Idle"
STATE_WALK = "Walk"
STATE_RUN = "Run"
STATE_JUMP = "Jump"
STATE_RUNJUMP = "RunJump"
STATE_FALL = "Fall"
STATE_DUCK = "Duck"
STATE_UN_DUCK = "UnDuck"
STATE_FLOAT = "Float"
STATE_SWIM = "Swim"
SUB_STATE_GRAB = "Grab"
JUMP_ACCEL = 3.5
FALL_ACCEL = -9.81
TERRAIN_NONE = 0
TERRAIN_GROUND = 1
TERRAIN_WATER = 2
TERRAIN_AIR = 3
DUCK_FRAME_COUNT = 0
DUCK_FRAME_MID = 0
SUNK_CUTOFF = -0.9
def __init__(self, base):
self.base = base
self.keyState = {
"WalkFw": False,
"WalkBw": False,
"Run": False,
"RotateL": False,
"RotateR": False,
"Jump": False,
"Duck": False
}
self.isKeyDown = self.base.mouseWatcherNode.isButtonDown
self.state = Player.STATE_IDLE
self.sub_state = None
self.walkDir = 0
self.rotationDir = 0
self.zVelocity = 0
self.zOffset = None
self.jumpHeight = None
self.terrainZone = Player.TERRAIN_NONE
self.terrainSurfZ = None
self.waterDepth = 0
self.collidedObjects = list()
# actor
anims = {
"idle": "models/player-idle",
"walk": "models/player-walk",
"run": "models/player-run",
"jump": "models/player-jump",
"duck": "models/player-duck",
"float": "models/player-float",
"swim": "models/player-swim",
"grab": "models/player-grab"
}
self.actor = Actor("models/player", anims)
self.actor.reparentTo(self.base.render)
self.actor.setH(200)
log.debug("actor tight bounds is %s" %
str(self.actor.getTightBounds()))
# animation info
Player.DUCK_FRAME_COUNT = self.actor.getNumFrames("duck")
Player.DUCK_FRAME_MID = int(Player.DUCK_FRAME_COUNT / 2)
# camara point
self.camNode = NodePath("camNode")
self.camNode.reparentTo(self.actor)
self.camNode.setPos(0, 0, 1)
# collision
# ray
collRay = CollisionRay(0, 0, 1.5, 0, 0, -1)
collRayN = CollisionNode("playerCollRay")
collRayN.addSolid(collRay)
collRayN.setFromCollideMask(1)
collRayN.setIntoCollideMask(CollideMask.allOff())
collRayNP = self.actor.attachNewNode(collRayN)
self.collQRay = CollisionHandlerQueue()
self.base.cTrav.addCollider(collRayNP, self.collQRay)
# sphere mask 2
collSphere2 = CollisionSphere(0, 0, 0.5, 0.25)
collSphere2N = CollisionNode("playerCollSphere2")
collSphere2N.addSolid(collSphere2)
collSphere2N.setFromCollideMask(2)
collSphere2N.setIntoCollideMask(CollideMask.allOff())
self.collSphere2NP = self.actor.attachNewNode(collSphere2N)
self.collPSphere = CollisionHandlerPusher()
self.collPSphere.addCollider(self.collSphere2NP, self.actor)
self.base.cTrav.addCollider(self.collSphere2NP, self.collPSphere)
# key events
self.base.accept("i", self.dump_info)
# task
self.base.taskMgr.add(self.update, "playerUpdateTask")
def defineKeys(self):
for k in self.keyState.keys():
self.keyState[k] = False
if self.isKeyDown(KeyboardButton.up()):
self.keyState["WalkFw"] = True
if self.isKeyDown(KeyboardButton.down()):
self.keyState["WalkBw"] = True
if self.isKeyDown(KeyboardButton.left()):
self.keyState["RotateL"] = True
if self.isKeyDown(KeyboardButton.right()):
self.keyState["RotateR"] = True
if self.isKeyDown(KeyboardButton.shift()):
self.keyState["Run"] = True
if self.isKeyDown(KeyboardButton.space()):
self.keyState["Jump"] = True
if self.isKeyDown(KeyboardButton.asciiKey("d")):
self.keyState["Duck"] = True
def defineState(self):
#
newState = self.state
# keys states
ks = self.keyState
# state force
if self.zOffset > 0.2 and self.state != Player.STATE_FALL:
newState = Player.STATE_FALL
# from Idle -> Walk, Jump
if self.state == Player.STATE_IDLE:
# Walk
if ks["WalkFw"] or ks["WalkBw"] or ks["RotateL"] or ks["RotateR"]:
newState = Player.STATE_WALK
elif ks["Jump"]:
newState = Player.STATE_JUMP
elif ks["Duck"]:
newState = Player.STATE_DUCK
# from Walk, Run -> Walk, Run, Idle; from Run -> Jump
elif self.state == Player.STATE_WALK or self.state == Player.STATE_RUN:
if ks["Run"] and self.state != Player.STATE_RUN and self.terrainZone != Player.TERRAIN_WATER:
newState = Player.STATE_RUN
elif not ks["Run"] and self.state == Player.STATE_RUN:
newState = Player.STATE_WALK
if ks["WalkFw"]:
self.walkDir = -1
elif ks["WalkBw"]:
self.walkDir = 1
elif not ks["WalkFw"] and not ks["WalkBw"]:
self.walkDir = 0
if ks["RotateL"]:
self.rotationDir = 1
elif ks["RotateR"]:
self.rotationDir = -1
elif not ks["RotateL"] and not ks["RotateR"]:
self.rotationDir = 0
if ks["Jump"]:
newState = Player.STATE_RUNJUMP
if self.walkDir == 0 and self.rotationDir == 0:
newState = Player.STATE_IDLE
# from Jump -> Fall
elif self.state == Player.STATE_JUMP or self.state == Player.STATE_RUNJUMP:
if self.zVelocity > 0:
newState = Player.STATE_FALL
# from Fall -> Idle
elif self.state == Player.STATE_FALL:
if self.zOffset <= 0:
newState = Player.STATE_IDLE
self.jumpHeight = None
self.zVelocity = 0
self.walkDir = 0
# from Duck -> UnDuck
elif self.state == Player.STATE_DUCK:
if not ks["Duck"]:
newState = Player.STATE_UN_DUCK
# from UnDuck -> Idle
elif self.state == Player.STATE_UN_DUCK:
if not self.actor.getCurrentAnim() == "duck":
newState = Player.STATE_IDLE
return newState
def processState(self, dt):
# terrain sdjustment
if self.zOffset <= 0.2 and not self.state == Player.STATE_FALL:
self.actor.setZ(self.terrainSurfZ)
# idle
if self.state == Player.STATE_IDLE:
self.collSphere2NP.setZ(0)
# walk
if self.walkDir != 0:
if self.zVelocity == 0:
speed = 3.6 if self.state == Player.STATE_RUN else 2.4
else:
speed = 3.2
if self.terrainZone == Player.TERRAIN_WATER:
speed *= 0.5
self.actor.setY(self.actor, speed * self.walkDir * dt)
if self.rotationDir != 0:
self.actor.setH(self.actor.getH() + 3.5 * self.rotationDir)
# jump
if self.state == Player.STATE_JUMP or self.state == Player.STATE_RUNJUMP:
self.zVelocity = Player.JUMP_ACCEL
log.debug("jump start at v=%f" % self.zVelocity)
if self.state == Player.STATE_RUNJUMP:
self.walkDir = -1
# fall
if self.state == Player.STATE_FALL:
dZ = self.zVelocity * dt
dV = Player.FALL_ACCEL * dt
curZ = self.actor.getZ()
newZ = curZ + dZ
if self.jumpHeight == None and newZ < curZ:
self.jumpHeight = self.zOffset
log.debug("jump height=%f" % self.jumpHeight)
log.debug(
"falling... dt=%(dt)f getZ=%(getZ)f v=%(v)f dZ=%(dZ)f newZ=%(newZ)f dV=%(dV)f zOffset=%(zOff)f"
% {
"dt": dt,
"getZ": self.actor.getZ(),
"v": self.zVelocity,
"dZ": dZ,
"newZ": newZ,
"dV": dV,
"zOff": self.zOffset
})
if newZ < self.terrainSurfZ: newZ = self.terrainSurfZ
self.actor.setZ(newZ)
self.zVelocity += dV
# duck
if self.state == Player.STATE_DUCK:
if self.actor.getCurrentAnim() == "duck":
collSphrZ = (self.actor.getCurrentFrame("duck") /
Player.DUCK_FRAME_MID) * 0.25
self.collSphere2NP.setZ(-collSphrZ)
def processTerrainRelation(
self): # -> [terrainZone, terrainSurfZ, zOffset, waterDepth]
collEntries = self.collQRay.getEntries()
newZone = None
#
if len(collEntries) == 0:
#log.error("out of terrain, pos=%s"%str(self.actor.getPos()))
newZone = Player.TERRAIN_NONE
if newZone != self.terrainZone:
self.onTerrainZoneChanged(Player.TERRAIN_NONE)
self.terrainZone = newZone
return Player.TERRAIN_NONE, 0, 0, 0
#
newZone = Player.TERRAIN_NONE
gndZ, wtrZ = -1000, -1000
waterDepth = 0
for entry in collEntries:
eName = entry.getIntoNodePath().getName()
eZ = entry.getSurfacePoint(self.base.render).getZ()
if eName.startswith("Water"):
wtrZ = eZ
if wtrZ > gndZ:
newZone = Player.TERRAIN_WATER
else:
if eZ > gndZ: gndZ = eZ
if gndZ > wtrZ:
newZone = Player.TERRAIN_GROUND
if newZone == Player.TERRAIN_WATER:
waterDepth = gndZ - wtrZ
#log.debug("water depth is %f"%waterDepth)
zOffset = self.actor.getZ() - gndZ
return newZone, gndZ, zOffset, waterDepth
def onTerrainZoneChanged(self, zone):
log.debug("terrain zone chaged to: %i" % zone)
def onStateChanged(self, newState):
curState = self.state
log.debug("state change %s -> %s" % (str(curState), str(newState)))
#self.actor.stop()
if newState == Player.STATE_IDLE:
self.actor.loop("idle")
elif newState == Player.STATE_WALK:
self.actor.setPlayRate(4.0, "walk")
self.actor.loop("walk")
elif newState == Player.STATE_RUN:
self.actor.loop("run")
elif newState == Player.STATE_JUMP or newState == Player.STATE_RUNJUMP:
self.actor.setPlayRate(1.4, "jump")
self.actor.play("jump", fromFrame=20, toFrame=59)
elif newState == Player.STATE_DUCK:
self.actor.play("duck", fromFrame=0, toFrame=Player.DUCK_FRAME_MID)
elif newState == Player.STATE_UN_DUCK:
initFrame = Player.DUCK_FRAME_MID
if self.actor.getCurrentAnim() == "duck":
initFrame = Player.DUCK_FRAME_COUNT - self.actor.getCurrentFrame(
"duck")
self.actor.stop()
self.actor.play("duck",
fromFrame=initFrame,
toFrame=Player.DUCK_FRAME_COUNT)
def updateCollidedObjectsList(self):
pass
def update(self, task):
# clock
dt = self.base.taskMgr.globalClock.getDt()
# keys
self.defineKeys()
# terrain relation
newZone, self.terrainSurfZ, self.zOffset, self.waterDepth = self.processTerrainRelation(
)
if newZone != self.terrainZone:
self.terrainZone = newZone
self.onTerrainZoneChanged(self.terrainZone)
# obstacles relation
self.updateCollidedObjectsList()
# state
newState = self.defineState()
if self.state != newState:
self.onStateChanged(newState)
self.state = newState
self.processState(dt)
# move
return task.cont
def dump_info(self):
info = "position: %s\n" % str(self.actor.getPos())
info += "hpr: %s\n" % str(self.actor.getHpr())
info += "state: %s; sub_state: %s\n" % (str(
self.state), str(self.sub_state))
info += "terrainZone: %s\n" % str(self.terrainZone)
info += "terrainSurfZ: %s\n" % str(self.terrainSurfZ)
info += "zOffset: %s\n" % str(self.zOffset)
log.info("*INFO:\n%s" % info)
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
self.orbCollisionHandler = CollisionHandlerQueue()
self.cTrav = CollisionTraverser()
#hbPath = NodePath()
utils3.setUpKeys(self)
utils3.loadModels(self)
utils3.setUpLighting(self)
utils3.setUpFloatingSpheres(self)
utils3.setUpRalphsShot(self)
utils3.setUpCamera(self)
self.healthTxt = utils3.addInstructions(.06,"Health: 100")
self.orbTxt = utils3.addInstructions(.18,"Orbs: 0")
self.vec = LVector3(0,1,0)#vector for pawns shot
# Create a frame
#frame = DirectFrame(text = "main", scale = 0.001)
# Add button
#bar = DirectWaitBar(text = "", value = 50, pos = (0,.4,.4))
#bar.reparent(render)
# Game state variables
self.isMoving = False
self.jumping = False
self.vz = 0
self.numOrbs = 0
self.healthCount = 100
#self.shotList = []
taskMgr.add(self.move, "moveTask")
#taskMgr.add(utils2.moveChris,"moveChrisTask")
self.sphere = CollisionSphere(0,0,4,2)
self.sphere2 = CollisionSphere(0,0,2,2)
self.cnodePath = self.ralph.attachNewNode((CollisionNode('ralphColNode')))
self.cnodePath.node().addSolid(self.sphere)
self.cnodePath.node().addSolid(self.sphere2)
#self.cnodePath.show()
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(self.cnodePath, self.ralph)
#self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler)
self.cTrav.addCollider(self.cnodePath, self.pusher)
ca = CollisionSphere(0,0,0,20)
cb = self.chik.attachNewNode(CollisionNode('chikCollisionNode'))
cb.node().addSolid(ca)
cb.show()
cc = CollisionSphere(3,5,12,25)
cd = self.gianteye.attachNewNode(CollisionNode('gianteyeCollisionNode'))
cd.node().addSolid(cc)
cd.show()
ci = CollisionSphere(0,0,0,2)
coi = self.catidol.attachNewNode(CollisionNode('catidolCollisionNode'))
coi.node().addSolid(ci)
coi.show()
chi = CollisionSphere(-1,3,3,3)
chco = self.chris.attachNewNode(CollisionNode('chrisColPath'))
chco.node().addSolid(chi)
self.cTrav.addCollider(chco, self.orbCollisionHandler)
#chco.show()
self.chris.setH(90)
self.chris.setR(-90)
self.chris.setZ(2)
#cbox = CollisionBox((-50,30,20),10,85,20)
#cboxPath = self.room.attachNewNode(CollisionNode('roomSide1'))
#cboxPath.node().addSolid(cbox)
#cboxPath.show()
#cbox2 = CollisionBox((200,30,20),10,85,20)
#cboxPath2 = self.room.attachNewNode(CollisionNode('roomSide1'))
#cboxPath2.node().addSolid(cbox2)
#cboxPath2.show()
#cbox3 = CollisionBox((80,-60,20),120,20,20)
#cboxPath3 = self.room.attachNewNode(CollisionNode('roomSide1'))
#cboxPath3.node().addSolid(cbox3)
#cboxPath3.show()
ct = CollisionSphere(0,0,0,1)
cn = self.pawn.attachNewNode(CollisionNode('pawnCollisionNode'))
cn.node().addSolid(ct)
cn.show()
cs2 = CollisionSphere(0,0,0,.2)
cs2path = self.plnp.attachNewNode((CollisionNode('orbColPath')))
cs2path.node().addSolid(cs2)
cs2path.show()
self.cTrav.addCollider(cs2path, self.orbCollisionHandler)
#cs3 = CollisionSphere(0,0,0,1)
cs3path = self.plnp2.attachNewNode((CollisionNode('orbColPath')))
cs3path.node().addSolid(cs2)
cs3path.show()
chrisShotNp = self.chrisShot.attachNewNode((CollisionNode("enemyOrbColPath")))
chrisShotNp.node().addSolid(cs2)
chrisShotNp.show()
self.cTrav.addCollider(cs3path, self.orbCollisionHandler)
self.cTrav.addCollider(chrisShotNp, self.orbCollisionHandler)
# Uncomment this line to show a visual representation of the
# collisions occuring
self.cTrav.showCollisions(render)
self.chrisLastShotTime = globalClock.getFrameTime()
self.chrisTimer = globalClock.getDt()
class CogdoFlyingCollisions(GravityWalker):
wantFloorSphere = 0
def __init__(self):
GravityWalker.__init__(self, gravity=0.0)
def initializeCollisions(self,
collisionTraverser,
avatarNodePath,
avatarRadius=1.4,
floorOffset=1.0,
reach=1.0):
self.cHeadSphereNodePath = None
self.cFloorEventSphereNodePath = None
self.setupHeadSphere(avatarNodePath)
self.setupFloorEventSphere(avatarNodePath,
ToontownGlobals.FloorEventBitmask,
avatarRadius)
GravityWalker.initializeCollisions(self, collisionTraverser,
avatarNodePath, avatarRadius,
floorOffset, reach)
return
def setupWallSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75,
self.avatarRadius)
cSphereNode = CollisionNode('Flyer.cWallSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
if config.GetBool('want-fluid-pusher', 0):
self.pusher = CollisionHandlerFluidPusher()
else:
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(cSphereNodePath, self.avatarNodePath)
self.cWallSphereNodePath = cSphereNodePath
def setupEventSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75,
self.avatarRadius * 1.04)
cSphere.setTangible(0)
cSphereNode = CollisionNode('Flyer.cEventSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.event = CollisionHandlerEvent()
self.event.addInPattern('enter%in')
self.event.addOutPattern('exit%in')
self.cEventSphereNodePath = cSphereNodePath
def setupRay(self, bitmask, floorOffset, reach):
cRay = CollisionRay(0.0, 0.0, 3.0, 0.0, 0.0, -1.0)
cRayNode = CollisionNode('Flyer.cRayNode')
cRayNode.addSolid(cRay)
self.cRayNodePath = self.avatarNodePath.attachNewNode(cRayNode)
cRayNode.setFromCollideMask(bitmask)
cRayNode.setIntoCollideMask(BitMask32.allOff())
self.lifter = CollisionHandlerGravity()
self.lifter.setLegacyMode(self._legacyLifter)
self.lifter.setGravity(self.getGravity(0))
self.lifter.addInPattern('%fn-enter-%in')
self.lifter.addAgainPattern('%fn-again-%in')
self.lifter.addOutPattern('%fn-exit-%in')
self.lifter.setOffset(floorOffset)
self.lifter.setReach(reach)
self.lifter.addCollider(self.cRayNodePath, self.avatarNodePath)
def setupHeadSphere(self, avatarNodePath):
collSphere = CollisionSphere(0, 0, 0, 1)
collSphere.setTangible(1)
collNode = CollisionNode('Flyer.cHeadCollSphere')
collNode.setFromCollideMask(ToontownGlobals.CeilingBitmask)
collNode.setIntoCollideMask(BitMask32.allOff())
collNode.addSolid(collSphere)
self.cHeadSphereNodePath = avatarNodePath.attachNewNode(collNode)
self.cHeadSphereNodePath.setZ(base.localAvatar.getHeight() + 1.0)
self.headCollisionEvent = CollisionHandlerEvent()
self.headCollisionEvent.addInPattern('%fn-enter-%in')
self.headCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(self.cHeadSphereNodePath,
self.headCollisionEvent)
def setupFloorEventSphere(self, avatarNodePath, bitmask, avatarRadius):
cSphere = CollisionSphere(0.0, 0.0, 0.0, 0.75)
cSphereNode = CollisionNode('Flyer.cFloorEventSphere')
cSphereNode.addSolid(cSphere)
cSphereNodePath = avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.floorCollisionEvent = CollisionHandlerEvent()
self.floorCollisionEvent.addInPattern('%fn-enter-%in')
self.floorCollisionEvent.addAgainPattern('%fn-again-%in')
self.floorCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(cSphereNodePath, self.floorCollisionEvent)
self.cFloorEventSphereNodePath = cSphereNodePath
def deleteCollisions(self):
GravityWalker.deleteCollisions(self)
if self.cHeadSphereNodePath != None:
base.cTrav.removeCollider(self.cHeadSphereNodePath)
self.cHeadSphereNodePath.detachNode()
self.cHeadSphereNodePath = None
self.headCollisionsEvent = None
if self.cFloorEventSphereNodePath != None:
base.cTrav.removeCollider(self.cFloorEventSphereNodePath)
self.cFloorEventSphereNodePath.detachNode()
self.cFloorEventSphereNodePath = None
self.floorCollisionEvent = None
self.cRayNodePath.detachNode()
del self.cRayNodePath
self.cEventSphereNodePath.detachNode()
del self.cEventSphereNodePath
return
def setCollisionsActive(self, active=1):
if self.collisionsActive != active:
if self.cHeadSphereNodePath != None:
base.cTrav.removeCollider(self.cHeadSphereNodePath)
if active:
base.cTrav.addCollider(self.cHeadSphereNodePath,
self.headCollisionEvent)
if self.cFloorEventSphereNodePath != None:
base.cTrav.removeCollider(self.cFloorEventSphereNodePath)
if active:
base.cTrav.addCollider(self.cFloorEventSphereNodePath,
self.floorCollisionEvent)
GravityWalker.setCollisionsActive(self, active)
return
def enableAvatarControls(self):
pass
def disableAvatarControls(self):
pass
def handleAvatarControls(self, task):
pass
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
# Set the background color to black
self.win.setClearColor((0, 0, 0, 1))
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0, "right": 0, "forward": 0, "back": 0, "cam-left": 0, "cam-right": 0}
# Post the instructions
self.title = addTitle(
"Adventurer: 3rd Person File Manager (in progress)")
self.inst1 = addInstructions(0.06, "[ESC]: Quit")
self.inst2 = addInstructions(0.12, "[Arrows]: Angle Camera")
self.inst3 = addInstructions(0.18, "[WASD]: Move")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
#self.environ = loader.loadModel("models/world")
#self.environ.reparentTo(render)
#loader.unload_model
startPos = Point3(0,0,0)#self.environ.find("**/start_point").getPos()
# Setup controls
self.keys = {}
for key in ['arrow_left', 'arrow_right', 'arrow_up', 'arrow_down',
'a', 'd', 'w', 's']:
self.keys[key] = 0
self.accept(key, self.push_key, [key, 1])
self.accept('shift-%s' % key, self.push_key, [key, 1])
self.accept('%s-up' % key, self.push_key, [key, 0])
#self.accept('f', self.toggleWireframe)
#self.accept('x', self.toggle_xray_mode)
#self.accept('b', self.toggle_model_bounds)
self.accept('escape', __import__('sys').exit, [0])
self.disableMouse()
taskMgr.add(self.update, "moveTask")
#insert test features
#addCube(models, render, startPos + (0, 1, 0.5), 0.5)
#addWall(models, render, startPos + (0, 1, 0.5), 30, 0.2)
addDir(render, startPos + (0, 1, 0.5))
# Game state variables
self.isMoving = False
# Set up the camera
self.disableMouse()
lens = PerspectiveLens()
lens.setFov(60)
lens.setNear(0.01)
lens.setFar(1000.0)
self.cam.node().setLens(lens)
self.camera.setPos(startPos)
self.heading = -95.0
self.pitch = 0.0
# Add collision to keept he camera in the room
cn = CollisionNode('camera')
cn.addSolid(CollisionSphere(0, 0, 0, 0.5))
camColl = self.camera.attachNewNode(cn)
self.cTrav = CollisionTraverser('camera traverser')
self.camGroundHandler = CollisionHandlerPusher()
self.camGroundHandler.addCollider(camColl, NodePath(self.camera))
self.cTrav.addCollider(camColl, self.camGroundHandler)
# Makes colliding objects show up
self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
self.exitFunc = self.cleanup
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
render.setShaderAuto()
self.environment = loader.loadModel("Models/Misc/environment")
self.environment.reparentTo(render)
self.camera.setPos(0, 0, 32)
self.camera.setP(-90)
self.keyMap = {
"up" : False,
"down" : False,
"left" : False,
"right" : False,
"shoot" : False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.pusher = CollisionHandlerPusher()
self.cTrav = CollisionTraverser()
self.pusher.setHorizontal(True)
self.pusher.add_in_pattern("%fn-into-%in")
self.accept("trapEnemy-into-wall", self.stopTrap)
self.accept("trapEnemy-into-trapEnemy", self.stopTrap)
self.accept("trapEnemy-into-player", self.trapHitsSomething)
self.accept("trapEnemy-into-walkingEnemy", self.trapHitsSomething)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
self.updateTask = taskMgr.add(self.update, "update")
self.player = None
self.enemies = []
self.trapEnemies = []
self.deadEnemies = []
self.spawnPoints = []
numPointsPerWall = 5
for i in range(numPointsPerWall):
coord = 7.0/numPointsPerWall + 0.5
self.spawnPoints.append(Vec3(-7.0, coord, 0))
self.spawnPoints.append(Vec3(7.0, coord, 0))
self.spawnPoints.append(Vec3(coord, -7.0, 0))
self.spawnPoints.append(Vec3(coord, 7.0, 0))
self.initialSpawnInterval = 1.0
self.minimumSpawnInterval = 0.2
self.spawnInterval = self.initialSpawnInterval
self.spawnTimer = self.spawnInterval
self.maxEnemies = 2
self.maximumMaxEnemies = 20
self.numTrapsPerSide = 2
self.difficultyInterval = 5.0
self.difficultyTimer = self.difficultyInterval
self.enemySpawnSound = loader.loadSfx("Sounds/enemySpawn.ogg")
self.gameOverScreen = DirectDialog(frameSize = (-0.7, 0.7, -0.7, 0.7),
fadeScreen = 0.4,
relief = DGG.FLAT,
frameTexture = "UI/stoneFrame.png")
self.gameOverScreen.hide()
self.font = loader.loadFont("Fonts/Wbxkomik.ttf")
buttonImages = (
loader.loadTexture("UI/UIButton.png"),
loader.loadTexture("UI/UIButtonPressed.png"),
loader.loadTexture("UI/UIButtonHighlighted.png"),
loader.loadTexture("UI/UIButtonDisabled.png")
)
label = DirectLabel(text = "Game Over!",
parent = self.gameOverScreen,
scale = 0.1,
pos = (0, 0, 0.2),
text_font = self.font,
relief = None)
self.finalScoreLabel = DirectLabel(text = "",
parent = self.gameOverScreen,
scale = 0.07,
pos = (0, 0, 0),
text_font = self.font,
relief = None)
btn = DirectButton(text = "Restart",
command = self.startGame,
pos = (-0.3, 0, -0.2),
parent = self.gameOverScreen,
scale = 0.07,
text_font = self.font,
clickSound = loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture = buttonImages,
frameSize = (-4, 4, -1, 1),
text_scale = 0.75,
relief = DGG.FLAT,
text_pos = (0, -0.2))
btn.setTransparency(True)
btn = DirectButton(text = "Quit",
command = self.quit,
pos = (0.3, 0, -0.2),
parent = self.gameOverScreen,
scale = 0.07,
text_font = self.font,
clickSound = loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture = buttonImages,
frameSize = (-4, 4, -1, 1),
text_scale = 0.75,
relief = DGG.FLAT,
text_pos = (0, -0.2))
btn.setTransparency(True)
self.titleMenuBackdrop = DirectFrame(frameColor = (0, 0, 0, 1),
frameSize = (-1, 1, -1, 1),
parent = render2d)
self.titleMenu = DirectFrame(frameColor = (1, 1, 1, 0))
title = DirectLabel(text = "Panda-chan",
scale = 0.1,
pos = (0, 0, 0.9),
parent = self.titleMenu,
relief = None,
text_font = self.font,
text_fg = (1, 1, 1, 1))
title2 = DirectLabel(text = "and the",
scale = 0.07,
pos = (0, 0, 0.79),
parent = self.titleMenu,
text_font = self.font,
frameColor = (0.5, 0.5, 0.5, 1))
title3 = DirectLabel(text = "Endless Horde",
scale = 0.125,
pos = (0, 0, 0.65),
parent = self.titleMenu,
relief = None,
text_font = self.font,
text_fg = (1, 1, 1, 1))
btn = DirectButton(text = "Start Game",
command = self.startGame,
pos = (0, 0, 0.2),
parent = self.titleMenu,
scale = 0.1,
text_font = self.font,
clickSound = loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture = buttonImages,
frameSize = (-4, 4, -1, 1),
text_scale = 0.75,
relief = DGG.FLAT,
text_pos = (0, -0.2))
btn.setTransparency(True)
btn = DirectButton(text = "Quit",
command = self.quit,
pos = (0, 0, -0.2),
parent = self.titleMenu,
scale = 0.1,
text_font = self.font,
clickSound = loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture = buttonImages,
frameSize = (-4, 4, -1, 1),
text_scale = 0.75,
relief = DGG.FLAT,
text_pos = (0, -0.2))
btn.setTransparency(True)
music = loader.loadMusic("Music/Defending-the-Princess-Haunted.ogg")
music.setLoop(True)
music.setVolume(0.075)
music.play()
class CogdoFlyingCollisions(GravityWalker):
wantFloorSphere = 0
def __init__(self):
GravityWalker.__init__(self, gravity=0.0)
def initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius = 1.4, floorOffset = 1.0, reach = 1.0):
self.cHeadSphereNodePath = None
self.cFloorEventSphereNodePath = None
self.setupHeadSphere(avatarNodePath)
self.setupFloorEventSphere(avatarNodePath, ToontownGlobals.FloorEventBitmask, avatarRadius)
GravityWalker.initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius, floorOffset, reach)
return
def setupWallSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius)
cSphereNode = CollisionNode('Flyer.cWallSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
if config.GetBool('want-fluid-pusher', 0):
self.pusher = CollisionHandlerFluidPusher()
else:
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(cSphereNodePath, self.avatarNodePath)
self.cWallSphereNodePath = cSphereNodePath
def setupEventSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius * 1.04)
cSphere.setTangible(0)
cSphereNode = CollisionNode('Flyer.cEventSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.event = CollisionHandlerEvent()
self.event.addInPattern('enter%in')
self.event.addOutPattern('exit%in')
self.cEventSphereNodePath = cSphereNodePath
def setupRay(self, bitmask, floorOffset, reach):
cRay = CollisionRay(0.0, 0.0, 3.0, 0.0, 0.0, -1.0)
cRayNode = CollisionNode('Flyer.cRayNode')
cRayNode.addSolid(cRay)
self.cRayNodePath = self.avatarNodePath.attachNewNode(cRayNode)
cRayNode.setFromCollideMask(bitmask)
cRayNode.setIntoCollideMask(BitMask32.allOff())
self.lifter = CollisionHandlerGravity()
self.lifter.setLegacyMode(self._legacyLifter)
self.lifter.setGravity(self.getGravity(0))
self.lifter.addInPattern('%fn-enter-%in')
self.lifter.addAgainPattern('%fn-again-%in')
self.lifter.addOutPattern('%fn-exit-%in')
self.lifter.setOffset(floorOffset)
self.lifter.setReach(reach)
self.lifter.addCollider(self.cRayNodePath, self.avatarNodePath)
def setupHeadSphere(self, avatarNodePath):
collSphere = CollisionSphere(0, 0, 0, 1)
collSphere.setTangible(1)
collNode = CollisionNode('Flyer.cHeadCollSphere')
collNode.setFromCollideMask(ToontownGlobals.CeilingBitmask)
collNode.setIntoCollideMask(BitMask32.allOff())
collNode.addSolid(collSphere)
self.cHeadSphereNodePath = avatarNodePath.attachNewNode(collNode)
self.cHeadSphereNodePath.setZ(base.localAvatar.getHeight() + 1.0)
self.headCollisionEvent = CollisionHandlerEvent()
self.headCollisionEvent.addInPattern('%fn-enter-%in')
self.headCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent)
def setupFloorEventSphere(self, avatarNodePath, bitmask, avatarRadius):
cSphere = CollisionSphere(0.0, 0.0, 0.0, 0.75)
cSphereNode = CollisionNode('Flyer.cFloorEventSphere')
cSphereNode.addSolid(cSphere)
cSphereNodePath = avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.floorCollisionEvent = CollisionHandlerEvent()
self.floorCollisionEvent.addInPattern('%fn-enter-%in')
self.floorCollisionEvent.addAgainPattern('%fn-again-%in')
self.floorCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(cSphereNodePath, self.floorCollisionEvent)
self.cFloorEventSphereNodePath = cSphereNodePath
def deleteCollisions(self):
GravityWalker.deleteCollisions(self)
if self.cHeadSphereNodePath != None:
base.cTrav.removeCollider(self.cHeadSphereNodePath)
self.cHeadSphereNodePath.detachNode()
self.cHeadSphereNodePath = None
self.headCollisionsEvent = None
if self.cFloorEventSphereNodePath != None:
base.cTrav.removeCollider(self.cFloorEventSphereNodePath)
self.cFloorEventSphereNodePath.detachNode()
self.cFloorEventSphereNodePath = None
self.floorCollisionEvent = None
self.cRayNodePath.detachNode()
del self.cRayNodePath
self.cEventSphereNodePath.detachNode()
del self.cEventSphereNodePath
return
def setCollisionsActive(self, active = 1):
if self.collisionsActive != active:
if self.cHeadSphereNodePath != None:
base.cTrav.removeCollider(self.cHeadSphereNodePath)
if active:
base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent)
if self.cFloorEventSphereNodePath != None:
base.cTrav.removeCollider(self.cFloorEventSphereNodePath)
if active:
base.cTrav.addCollider(self.cFloorEventSphereNodePath, self.floorCollisionEvent)
GravityWalker.setCollisionsActive(self, active)
return
def enableAvatarControls(self):
pass
def disableAvatarControls(self):
pass
def handleAvatarControls(self, task):
pass
