Esempio n. 1
0
 def cutScene(self):
     self.destroyLevel()
     self.stopAllSounds()
     
     self.cut = OnscreenImage("GUI/bossKilled.png",scale = Vec3(1.6, 0, 1.0),pos = Vec3(0, 0,0))
     self.cut.reparentTo(aspect2d)
     self.cut.setTransparency(1)
     transition = Transitions(loader) 
     transition.setFadeColor(0, 0, 0)
     self.cheer.play()
     if(self.currentLevel=="rainforest"):
         Sequence(Wait(2.0),Func(transition.fadeOut),Wait(1.0),Func(transition.fadeIn),Func(self.cut.setImage,"GUI/map_11.png"),
                  Wait(1.5),Func(self.cut.setImage, "GUI/map_12.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_13.png"),
                  Wait(0.5),Func(self.cut.setImage,"GUI/map_14.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_15.png"),
                  Wait(0.5),Func(self.cut.setImage,"GUI/map_16.png"),Wait(3.5),Func(self.cut.destroy), Func(transition.fadeOut), Func(self.loadingScreen), Wait(1.0),Func(transition.fadeIn)).start()
     elif(self.currentLevel=="africa"):
         Sequence(Wait(2.0),Func(transition.fadeOut),Wait(1.0),Func(transition.fadeIn),Func(self.cut.setImage,"GUI/map_21.png"),
                  Wait(1.5),Func(self.cut.setImage, "GUI/map_22.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_23.png"),
                  Wait(0.5),Func(self.cut.setImage,"GUI/map_24.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_25.png"),
                  Wait(0.5),Func(self.cut.setImage,"GUI/map_26.png"), Wait(3.5),Func(self.cut.destroy), Func(transition.fadeOut),Func(self.loadingScreen), Wait(1.0),Func(transition.fadeIn)).start()
     elif(self.currentLevel=="asia"):
         Sequence(Wait(2.0),Func(transition.fadeOut),Wait(1.0),Func(transition.fadeIn),Func(self.cut.setImage,"GUI/map_31.png"),
                  Wait(1.5),Func(self.cut.setImage, "GUI/map_32.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_33.png"),
                  Wait(0.5),Func(self.cut.setImage,"GUI/map_34.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_35.png"),
                  Wait(0.5),Func(self.cut.setImage,"GUI/map_36.png"),Wait(3.5),Func(self.cut.destroy), Func(transition.fadeOut),Func(self.loadingScreen), Wait(1.0),Func(transition.fadeIn)).start()
     elif(self.currentLevel=="newyork"):
         Sequence(Wait(2.0),Func(transition.fadeOut),Wait(1.0),Func(transition.fadeIn),Func(self.cut.setImage,"GUI/win.png"),
                  Wait(6.5),Func(self.cut.destroy), Func(transition.fadeOut),Func(self.loadingScreen), Wait(1.0),Func(transition.fadeIn)).start()
Esempio n. 2
0
 def alienDie(self, currLvl):
     self.alien.stop()
     self.pause=True
     temp = NodePath(PandaNode("temp"))
     
     base.camera.reparentTo(self.floater)
     base.camera.setZ(base.camera.getZ()+1)
     base.camera.setY(base.camera.getY()-25)
     self.deadSound.play()
     
     fall = LerpHprInterval(nodePath=self.alien, duration=1.5, hpr=(self.alien.getH(),self.alien.getP(), self.alien.getR()-80))
     fall.start()
     
     
     taskMgr.remove("moveTask")
     taskMgr.remove("laterFc")
     transition = Transitions(loader) 
     transition.setFadeColor(0, 0, 0)
     self.dieImage = OnscreenImage("GUI/died.png",scale = Vec3(0.7, 0, 0.2),pos = Vec3(0, 0,-0.5))
     self.dieImage.reparentTo(aspect2d)
     self.dieImage.setTransparency(1)
     if(self.currentLevel == "rainforest"):
         Sequence(Wait(2.0),Func(transition.fadeOut),Wait(2.0),Func(self.destroyLevel),Func(self.loadRainforestLevel),Func(self.dieImage.destroy),Func(transition.fadeIn)).start()
     elif(self.currentLevel == "africa"):
         Sequence(Wait(2.0),Func(transition.fadeOut),Wait(2.0),Func(self.destroyLevel),Func(self.loadAfricaLevel),Func(self.dieImage.destroy),Func(transition.fadeIn)).start()
     elif(self.currentLevel == "asia"):
         Sequence(Wait(2.0),Func(transition.fadeOut),Wait(2.0),Func(self.destroyLevel),Func(self.loadAsiaLevel),Func(self.dieImage.destroy),Func(transition.fadeIn)).start()
     elif(self.currentLevel == "newyork"):
         Sequence(Wait(2.0),Func(transition.fadeOut),Wait(2.0),Func(self.destroyLevel),Func(self.loadNewYorkLevel),Func(self.dieImage.destroy),Func(transition.fadeIn)).start()
Esempio n. 3
0
    def __init__(self):
        ShowBase.__init__(self)
        self.disableMouse()

        props = WindowProperties()
        props.setTitle('Test')
        self.win.requestProperties(props)

        # self.render.setAntiAlias(AntialiasAttrib.MAuto)

        self.transitions = Transitions(self.loader)
        self.transitions.setFadeColor(0, 0, 0)

        self.filters = CommonFilters(self.win, self.cam)
        # self.filters.setCartoonInk()
        self.filters.setBlurSharpen(1)
        # self.filters.setVolumetricLighting(self.render)

        # self.buffer = self.win.makeTextureBuffer("Post-processing buffer", self.win.getXSize(), self.win.getXSize())
        # print self.buffer.getYSize()
        # self.texture = self.buffer.getTexture()
        # self.buffer.setSort(-100)
        #
        # self.originalCamera = self.camera
        # self.offScreenCamera = self.makeCamera(self.buffer)
        # self.camera = self.offScreenCamera
        #
        # self.img = OnscreenImage(image=self.texture, pos=(0, 0, 0.5))

        self.scene = None
        self.channel = Channel()
Esempio n. 4
0
	def __init__(self, filename):
		FSM.__init__(self, 'Game')
		
		self.savedGame = PlayerFileParser("save.xml")
		self.playerData = self.savedGame.playerData
		self.playerData.setShip(shipDb[self.playerData.ship.name])
		
		self.crosshair = MouseCursor()
		self.crosshair.setMode(1)
		
		self.mainMenu = MainMenu()
		self.mainMenu.hide()
		self.mainMenu.buttons[0]["command"] = self.request
		self.mainMenu.buttons[0]["extraArgs"] = ["Space"]
		
		self.mainMenu.buttons[1]["command"] = self.request
		self.mainMenu.buttons[1]["extraArgs"] = ["Ground"]
		
		self.mainMenu.buttons[3]["command"] = self.quit
		self.mainMenu.buttons[3]["extraArgs"] = [0]
		
		
		#self.groundGui = GroundGui(self.playerData)
		#self.groundWorldManager = GroundManager(self)
		
		#self.spaceWorldManager = SpaceOdeWorldManager(self)
		
		self.prevState = None
		
		self.trans = Transitions(loader)
		
		self.request("IntroMainMenu")
Esempio n. 5
0
	def __init__(self, stage, characters, player, player2):
		State.__init__(self)

		# how to know the players that will be in game? a ChoosePlayer screen before the constructor?
		self.characters = characters

		self.player = player
		self.player2 = player2

		self.stage = stage
		self.room = self.stage.start
		self.isOver = False

		self.players = []

		#print(self.players)
		self.startMap()

		self.status = {}

		posi = 0
		for c in self.characters:
			# initialize character status string
			self.status[c] = (OnscreenText(mayChange= True ,
				                             style=2, fg=(1,1,1,1),
				                             pos=(1.4*posi - 0.8,-0.83), scale = .07)
			)
			posi += 1

		self.transitions = Transitions(GameLoader.loader)
		self.clock = ClockObject()
		self.lastTime = 0

		GameLoader.music.addSfx('barrel_breaks')
		GameLoader.music.addSfx('stone','aif')
    def goToBoss(self):

        self.transition = Transitions(loader)
        self.transition.setFadeColor(0, 0, 0)
        self.fadeOut = self.transition.fadeOut(2)
        self.unload(self.levelMap[1])
        self.load(self.levelMap[4])
        self.currentLevel = 4
Esempio n. 7
0
 def __init__(self):
     self.trans = Transitions(loader)
     self.scene = render.getPythonTag('SceneManager').createScene('Make-A-Toon')
     self.setupEnvironment()
     self.randomizeData()
     self.setupHUD()
     self.bgm = SoundBank.getSound('make_a_toon')
     self.bgm.setLoop(True)
     self.bgm.play()
Esempio n. 8
0
 def loadingScreen(self):
     self.intro.play()
     transition = Transitions(loader) 
     transition.setFadeColor(0, 0, 0)
     text = TextNode('node name')
     dummy = NodePath(PandaNode("dummy"))
     black = OnscreenImage(image="GUI/black.png",pos=(0,0,0), scale=100)
     black.reparentTo(dummy)
     textNodePath = aspect2d.attachNewNode(text)
     textNodePath.reparentTo(aspect2d, 2)
     textNodePath.setScale(0.07)
     text.setTextColor(1, 1, 1, 1)
     
     if(self.currentLevel=="newyork"):
         Sequence(Func(transition.fadeOut),Func(black.reparentTo, aspect2d),Func(transition.fadeIn),Func(textNodePath.reparentTo,aspect2d, 10),Func(text.setText, "loading"),Wait(1.0),Func(text.setText, "loading."), 
                 Wait(1.0),Func(text.setText, "loading.."), Wait(1.0), Func(text.setText, "loading..."), Func(self.loadNextLevel),Wait(3.0),Func(transition.fadeIn),Func(textNodePath.remove), Func(black.destroy)).start()
     elif(self.currentLevel=="asia"):
         Sequence(Func(transition.fadeOut),Func(black.reparentTo, aspect2d),Func(transition.fadeIn),Func(textNodePath.reparentTo,aspect2d, 10),Func(text.setText, "loading"),Wait(1.0),Func(text.setText, "loading."), 
                 Wait(1.0),Func(text.setText, "loading.."), Wait(1.0), Func(text.setText, "loading..."), Func(self.loadNextLevel),Wait(3.0),Func(transition.fadeIn),Func(textNodePath.remove), Func(black.destroy)).start()
     else:
         Sequence(Func(transition.fadeOut),Func(black.reparentTo, aspect2d),Func(transition.fadeIn),Func(textNodePath.reparentTo,aspect2d, 10),Func(text.setText, "loading"),Wait(0.5),Func(text.setText, "loading."), 
                 Wait(0.5),Func(text.setText, "loading.."), Wait(0.5), Func(text.setText, "loading..."), Func(self.loadNextLevel),Wait(1.5),Func(transition.fadeIn),Func(textNodePath.remove), Func(black.destroy)).start()
 def __init__(self):
     self.notify = DirectNotifyGlobal.directNotify.newCategory("Starting Make A Toon.")
     self.localAvatar = LocalAvatar.toonBody
     base.localAvatar = self.localAvatar
     self.toonColors = Localizer.toonColorDict
     self.colorNum = randint(0, Localizer.numColors)
     self.numColors = Localizer.numColors
     self.goRight()
     self.MakeAToonText = Localizer.MakeAToonText
     self.Mickey = Localizer.Mickey
     self.transition = Transitions(loader)
     self.transition.irisIn(1)
     self.transition.fadeIn(5)
     self.load()
Esempio n. 10
0
    def changeLevel(self, task):
        
        if(self.levelComplete == True):
           
            self.transition = Transitions(loader)
            self.transition.setFadeColor(0, 0, 0)
            self.fadeOut = self.transition.fadeOut(2)

            #unload the current level and models
            self.unload(self.levelMap[self.currentLevel])

            #load the next level and models
            self.load(self.levelMap[self.currentLevel + 1])

            #self.fadeIn = self.transition.fadeIn(5)
            base.taskMgr.remove(task)
        
        return task.cont
Esempio n. 11
0
 def __init__(self):
     self.notify = DirectNotifyGlobal.directNotify.newCategory("Starting Make A Toon.")
     self.localAvatar = LocalAvatar.toonBody
     base.localAvatar = self.localAvatar
     self.toonColors = Localizer.toonColorDict
     self.colorNum = 0
     self.numColors = Localizer.numColors
     self.MakeAToonText = Localizer.MakeAToonText
     self.Mickey = Localizer.Mickey
     self.mickeyFont = loader.loadFont('phase_3/models/fonts/MickeyFont.bam')
     self.Text = OnscreenText(text = "Make A Toon", pos = (0, 0.75), font = self.mickeyFont, fg = (1, 0, 0, 1),scale=(0.2, 0.2, 0.2))
     self.gui = loader.loadModel('phase_3/models/gui/tt_m_gui_mat_mainGui.bam')
     self.gui.flattenMedium()
     self.gui1 = loader.loadModel('phase_3/models/gui/create_a_toon_gui.bam')
     self.gui2 = loader.loadModel('phase_3/models/gui/gui_toongen.bam')
     self.guiNextUp = self.gui.find('**/tt_t_gui_mat_nextUp')
     self.transition = Transitions(loader)
     self.transition.irisIn(1)
     self.transition.fadeIn(5)
     self.load()
Esempio n. 12
0
 def __init__(self, parent):
   #Turn off default mouse control
   base.disableMouse()
   base.setFrameRateMeter(True)
   
   #globalClock = ClockObject.getGlobalClock()
   #globalClock.setMode(ClockObject.MLimited)
   #globalClock.setFrameRate(1000)
   #Set windows properties
   self.props = WindowProperties()
   self.props.setCursorHidden(True)
   #props.setFullscreen(1)
   #props.setSize(int(base.pipe.getDisplayWidth()), int(base.pipe.getDisplayHeight()))
   self.props.setMouseMode(WindowProperties.MRelative)
   base.win.requestProperties(self.props)
   
   self.transition = Transitions(loader)
   self.transition.setFadeColor(0,0,0)
   
   self.parent = parent
   base.accept("escape", self.togglePause)
   self.setupSounds()
   self.startLevel(0, True)
   self.task = taskMgr.add(self.update, "updateTask")
Esempio n. 13
0
class SMWorld(DirectObject):

	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Constructor
	# (Game state, Map name, Height of death plane)
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def __init__(self, mapID, tObj, aObj):

		self.mapID = mapID
		
		# EX: maps/map-1/map-1.yetimap
		metaFile = open("../maps/map" + str(self.mapID) + "/map" + str(self.mapID) + ".yetimap", 'r')
		metaLines = metaFile.readlines()
		lineCount = len(metaLines)
		self.snowflakeCount = lineCount - 2
		self.snowCount = 0
		
		# First Line: Player's starting position
		# EX: 50,50,50 (NO SPACES)
		playerLine = metaLines[0]
		playerPosList = playerLine.split(",")
		playerInitX = int(playerPosList[0])
		playerInitY = int(playerPosList[1])
		playerInitZ = int(playerPosList[2])
		self.playerStart = Point3(playerInitX, playerInitY, playerInitZ)
		
		# 2nd Line: Deathzone Height
		# ONE INTEGER
		self.deathHeight = int(metaLines[1])
		
		# Get dem snowflakes
		self.snowflakePositions = []
		print("Snowflake Count: " + str(self.snowflakeCount))
		for i in xrange(0, self.snowflakeCount):
			sfline = metaLines[i+2]
			sfList = sfline.split(",")
			sfx = int(sfList[0])
			sfy = int(sfList[1])
			sfz = int(sfList[2])
			self.snowflakePositions.append(Point3(sfx, sfy, sfz))
			print("New snowflake to add: (" + str(sfx) + "," + str(sfy) + "," + str(sfz) + ")")

		#load in controls
		ctrlFl = open("ctrConfig.txt")
		#will skip n lines where [n,]
		#makes a list of controls
		self.keymap = eval(ctrlFl.read())
		#close file
		ctrlFl.close()
		
		# Create new instances of our various objects
		self.mapName = str(mapID)
		self.audioMgr = aObj
		self.worldObj = self.setupWorld()
		self.heightMap = self.setupHeightmap(self.mapName)
		self.deathZone = self.setupDeathzone(self.deathHeight)
		self.debugNode = self.setupDebug()	
		
		# Player Init
		self.playerObj = SMPlayer(self.worldBullet, self.worldObj, self, self.playerStart, self.audioMgr)
		self.playerNP = self.playerObj.getNodePath()
		self.playerNP.setH(180);
		self.canUseShift = True
		self.canAirDash = True
		
		# Snowball Init
		self.ballObj = SMBall(self.worldBullet, self.worldObj, self.playerObj, self.playerNP)
		self.sbCollideFlag = False
		self.ballNP = self.ballObj.getNodePath()
		
		# Key Handler
		self.kh = SMKeyHandler()
		self.lastMousePos = self.kh.getMouse()
		
		# Collision Handler
		self.colObj = self.setupCollisionHandler()
		
		# Lighting
		self.ligObj = SMLighting(Vec4(.4, .4, .4, 1), Vec3(-5, -5, -5), Vec4(2.0, 2.0, 2.0, 1.0))
		
		# Camera
		self.camObj = SMCamera(self.playerObj, self.worldBullet, self.worldObj)
		self.cameraControl = False

		# GUI
		self.GUI = SMGUI()
		self.snowflakeCounter = SMGUICounter("snowflake", self.snowflakeCount) # Replace 3 with # of snowflakes in level.
		self.snowMeter = SMGUIMeter(100)
		self.GUI.addElement("snowflake", self.snowflakeCounter)
		self.GUI.addElement("snowMeter", self.snowMeter)
		
		#Snowy Outside
		# base.enableParticles()
		# self.p = ParticleEffect()
		# self.p.cleanup()
		# self.p = ParticleEffect()
		# self.p.loadConfig('snow.ptf')        
		# self.p.start(self.camObj.getNodePath())
		# self.p.setPos(0.00, 0.500, 0.000)

		# AI
		# self.goat1 = SMAI("../res/models/goat.egg", 75.0, self.worldBullet, self.worldObj, -70, -95, 5)
		# self.goat1.setBehavior("flee", self.playerNP)
		# self.goat2 = SMAI("../res/models/goat.egg", 75.0, self.worldBullet, self.worldObj, -80, -83, 5)
		# self.goat2.setBehavior("flee", self.playerNP)
		# print("AI Initialized")
		
		# Debug Text
		self.textObj = tObj
		self.textObj.addText("yetiPos", "Position: ")
		self.textObj.addText("yetiVel", "Velocity: ")
		self.textObj.addText("yetiFric", "Friction: ")
		self.textObj.addText("onIce", "Ice(%): ")
		self.textObj.addText("onSnow", "Snow(%): ")
		self.textObj.addText("terrHeight", "T Height: ")
		self.textObj.addText("terrSteepness", "Steepness: ")
		
		# Pause screen transition
		self.transition = Transitions(loader)

		# Method-based keybindings
		# self.accept('b', self.spawnBall)
		self.accept('escape', base.userExit)
		self.accept('enter', self.pauseUnpause)
		self.accept('f1', self.toggleDebug)
		
		self.accept('lshift-up', self.enableShiftActions)
		self.accept('mouse1', self.enableCameraControl)
		self.accept('mouse1-up', self.disableCameraControl)
		self.accept('wheel_up', self.camObj.zoomIn)
		self.accept('wheel_down', self.camObj.zoomOut)
		
		self.pauseUnpause()
		
		# Disable the mouse
		base.disableMouse()
		props = WindowProperties()
		props.setCursorHidden(True)
		base.win.requestProperties(props)
		
		# Uncomment this to see everything being rendered.
		self.printSceneGraph()
		
		# Play the BGM
		self.audioMgr.playBGM("snowmanWind")
		
		# Skybox formed
		skybox = loader.loadModel("../res/models/skybox.egg")
		# skybox.set_two_sided(true)
		skybox.setScale(500)
		skybox.setPos(0, 0, -450)
		skybox.reparentTo(render)
		
		mountain = loader.loadModel("../res/models/mountain.egg")
		mountain.reparentTo(render)
		mountain.setPos(650,800,20)
		mountain.setScale(120)
		
		self.colObjects = []
		
		self.caveNew = SMCollide("../res/models/cave_new.egg", self.worldBullet, self.worldObj, Point3(-50, 95, -13), 11, Vec3(0,0,0))
		self.colObjects.append(self.caveNew)
		
		self.planeFront = SMCollide("../res/models/plane_front", self.worldBullet, self.worldObj, Point3(190, -100, -15), 8, Vec3(190,0,30))
		self.colObjects.append(self.planeFront)
		
		self.caveModel = SMCollide("../res/models/cave_tunnel.egg", self.worldBullet, self.worldObj, Point3(233, 68, 32), 4, Vec3(135,180,0))
		self.colObjects.append(self.caveModel)
		
		self.planeTail = SMCollide("../res/models/plane_tail.egg", self.worldBullet, self.worldObj, Point3(-40, -130, -7), 10, Vec3(230,0,0))
		self.colObjects.append(self.planeTail)
		
		self.ropeBridge = SMCollide("../res/models/rope_bridge.egg", self.worldBullet, self.worldObj, Point3(180, 115, 30), 6, Vec3(50,0,0))
		self.colObjects.append(self.ropeBridge)
		
		self.colObjectCount = len(self.colObjects)
		
		print("World initialized.")


	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Enables the camera to be rotated by moving the mouse horizontally.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def enableCameraControl(self):
		self.cameraControl = True
	
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Disables the camera control.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def disableCameraControl(self):
		self.cameraControl = False
		
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Enables the use of shift actions again.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def enableShiftActions(self):
		self.canUseShift = True
		
	def disableShiftActions(self):
		self.canUseShift = False
	
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Respawns the yeti's snowball.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
		
	def spawnBall(self):
		if(not(self.playerObj.getAirborneFlag())):
			self.ballObj.respawn()
		
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Toggles the pause screen
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def pauseUnpause(self):
		if taskMgr.hasTaskNamed('UpdateTask'):
			taskMgr.remove('UpdateTask')
			self.transition.fadeScreen(0.5)
		else:
			taskMgr.add(self.update, 'UpdateTask')
			self.transition.noFade()
	
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Sets up the world and returns a NodePath of the BulletWorld
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def setupWorld(self):
		self.worldBullet = BulletWorld()
		self.worldBullet.setGravity(Vec3(0, 0, -GRAVITY))
		self.terrSteepness = -1
		wNP = render.attachNewNode('WorldNode')
		
		self.audioMgr.loadSFX("snowCrunch01")
		self.audioMgr.loadBGM("snowmanWind")
		
		return wNP
		
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Prints all nodes that are a child of render.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def printSceneGraph(self):
		print(render.ls())
	
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Initializes and returns a DebugNode NodePath.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def setupDebug(self):
		debug = BulletDebugNode()
		debug.showWireframe(False) # Yeah, don't set this to true unless you want to emulate an 80's computer running Crysis on Ultra settings.
		debug.showConstraints(True)
		debug.showBoundingBoxes(True) # This is the main use I have for it.
		debug.showNormals(True)
		debugNP = render.attachNewNode(debug)
		self.worldBullet.setDebugNode(debugNP.node())
		debugNP.hide()
		return debugNP
	
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Initializes and returns a BulletRigidBodyNode of the terrain, which loads the map with the specified name.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def setupHeightmap(self, name):
		
		# Automatically generate a heightmap mesh from a monochrome image.
		self.hmHeight = 120
		hmPath = "../maps/map" + name + "/map" + name + "-h.png"
		imPath = "../maps/map" + name + "/map" + name + "-i.png"
		smPath = "../maps/map" + name + "/map" + name + "-s.png"
		scmPath = "../maps/map" + name + "/map" + name + "-sc.png"
		print(hmPath)
		print(imPath)
		print(smPath)
		print(scmPath)
		hmImg = PNMImage(Filename(hmPath))
		hmShape = BulletHeightfieldShape(hmImg, self.hmHeight, ZUp)
		hmNode = BulletRigidBodyNode('Terrain')
		hmNode.addShape(hmShape)
		hmNode.setMass(0)
		self.hmNP = render.attachNewNode(hmNode)
		self.worldBullet.attachRigidBody(hmNode)
		self.hmOffset = hmImg.getXSize() / 2.0 - 0.5
		self.hmTerrain = GeoMipTerrain('gmTerrain')
		self.hmTerrain.setHeightfield(hmImg)
		
		# Optimizations and fixes
		self.hmTerrain.setBruteforce(True) # I don't think this is actually needed. 
		self.hmTerrain.setMinLevel(3) # THIS is what triangulates the terrain.
		self.hmTerrain.setBlockSize(128)  # This does a pretty good job of raising FPS.
		# Level-of-detail (not yet working)
		# self.hmTerrain.setNear(40)
		# self.hmTerrain.setFar(200)
		
		self.hmTerrain.generate()
		
		self.hmTerrainNP = self.hmTerrain.getRoot()
		self.hmTerrainNP.setSz(self.hmHeight)
		self.hmTerrainNP.setPos(-self.hmOffset, -self.hmOffset, -self.hmHeight / 2.0)
		self.hmTerrainNP.flattenStrong() # This only reduces the number of nodes; nothing to do with polys.
		self.hmTerrainNP.analyze()

		# Here begins the scenery mapping
		treeModel = loader.loadModel("../res/models/tree_1.egg")
		rockModel = loader.loadModel("../res/models/rock_1.egg")
		rock2Model = loader.loadModel("../res/models/rock_2.egg")
		rock3Model = loader.loadModel("../res/models/rock_3.egg")
		# caveModel = loader.loadModel("../res/models/cave_new.egg")
		# planeFrontModel = loader.loadModel("../res/models/plane_front.egg")
		# planeWingModel = loader.loadModel("../res/models/plane_wing.egg")
		texpk = loader.loadTexture(scmPath).peek()
		
		# GameObject nodepath for flattening
		self.objNP = render.attachNewNode("gameObjects")
		self.treeNP = self.objNP.attachNewNode("goTrees")
		self.rockNP = self.objNP.attachNewNode("goRocks")
		self.rock2NP = self.objNP.attachNewNode("goRocks2")
		self.rock3NP = self.objNP.attachNewNode("goRocks3")
		# self.caveNP = self.objNP.attachNewNode("goCave")
		# self.planeFrontNP = self.objNP.attachNewNode("goPlaneFront")
		# self.planeWingNP = self.objNP.attachNewNode("goPlaneWing")
		
		for i in range(0, texpk.getXSize()):
			for j in range(0, texpk.getYSize()):
				color = VBase4(0, 0, 0, 0)
				texpk.lookup(color, float(i) / texpk.getXSize(), float(j) / texpk.getYSize())
				if(int(color.getX() * 255.0) == 255.0):
					newTree = self.treeNP.attachNewNode("treeNode")
					treeModel.instanceTo(newTree)
					newTree.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2)
					# newTree.setScale(randint(0,4))
					newTree.setScale(2)
					
				if(int(color.getX() * 255.0) == 128):
					newRock = self.rockNP.attachNewNode("newRock")
					newRock.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2)
					rockModel.instanceTo(newRock)
					
				if(int(color.getX() * 255.0) == 77):
					newRock2 = self.rock2NP.attachNewNode("newRock2")
					newRock2.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2)
					rock2Model.instanceTo(newRock2)
					
				if(int(color.getX() * 255.0) == 102):
					newRock3 = self.rock3NP.attachNewNode("newRock3")
					newRock3.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2)
					rock3Model.instanceTo(newRock3)
					
				# if(int(color.getX() * 255.0) == 64):
					# newCave = self.caveNP.attachNewNode("newCave")
					# newCave.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2)
					# newCave.setScale(5)
					# newCave.setP(180)
					# caveModel.instanceTo(newCave)
				
				# if(int(color.getX() * 255.0) == 191):
					# newPlaneFront = self.planeFrontNP.attachNewNode("newPlaneFront")
					# newPlaneFront.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2)
					# newPlaneFront.setScale(6)
					# planeFrontModel.instanceTo(newPlaneFront)
					
				# if(int(color.getX() * 255.0) == 179):
					# newPlaneWing = self.planeWingNP.attachNewNode("newPlaneWing")
					# newPlaneWing.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2)
					# newPlaneWing.setScale(6)
					# newPlaneWing.setH(250)
					# newPlaneWing.setR(180)
					# newPlaneWing.setP(135)
					# planeWingModel.instanceTo(newPlaneWing)

		self.snowflakes = []
		
		for i in xrange(0, self.snowflakeCount):
			print("Call " + str(i))
			sf = SMCollect(self.worldBullet, self.worldObj, self.snowflakePositions[i])
			self.snowflakes.append(sf)
					
		# render.flattenStrong()
		self.hmTerrainNP.reparentTo(render)
		
		# Here begins the attribute mapping
		ts = TextureStage("stage-alpha")
		ts.setSort(0)
		ts.setPriority(1)
		ts.setMode(TextureStage.MReplace)
		ts.setSavedResult(True)
		self.hmTerrainNP.setTexture(ts, loader.loadTexture(imPath, smPath))

		ts = TextureStage("stage-stone")
		ts.setSort(1)
		ts.setPriority(1)
		ts.setMode(TextureStage.MReplace)
		self.hmTerrainNP.setTexture(ts, loader.loadTexture("../res/textures/stone_tex.png"))
		self.hmTerrainNP.setTexScale(ts, 32, 32)

		ts = TextureStage("stage-ice")
		ts.setSort(2)
		ts.setPriority(1)
		ts.setCombineRgb(TextureStage.CMInterpolate, TextureStage.CSTexture, TextureStage.COSrcColor,
						 TextureStage.CSPrevious, TextureStage.COSrcColor,
						 TextureStage.CSLastSavedResult, TextureStage.COSrcColor)
		self.hmTerrainNP.setTexture(ts, loader.loadTexture("../res/textures/ice_tex.png"))
		self.hmTerrainNP.setTexScale(ts, 32, 32)

		ts = TextureStage("stage-snow")
		ts.setSort(3)
		ts.setPriority(0)
		ts.setCombineRgb(TextureStage.CMInterpolate, TextureStage.CSTexture, TextureStage.COSrcColor,
						 TextureStage.CSPrevious, TextureStage.COSrcColor,
						 TextureStage.CSLastSavedResult, TextureStage.COSrcAlpha)
		self.hmTerrainNP.setTexture(ts, loader.loadTexture("../res/textures/snow_tex_1.png"))
		self.hmTerrainNP.setTexScale(ts, 32, 32)

		# print(self.snowflakes)
		
		return hmNode
	
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Sets up and returns the death zone plane (returns its NodePath) with the specified height.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def setupDeathzone(self, height):
		planeShape = BulletPlaneShape(Vec3(0, 0, 1), 1)
		planeNode = BulletRigidBodyNode('DeathZone')
		planeNode.addShape(planeShape)
		planeNP = render.attachNewNode(planeNode)
		planeNP.setPos(0, 0, height)
		self.worldBullet.attachRigidBody(planeNode)
		return planeNP
	
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Sets up and returns the collision handler.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def setupCollisionHandler(self):
		colHand = SMCollisionHandler(self.worldBullet)
		return colHand
	
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Toggles showing bounding boxes.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def toggleDebug(self):
		if self.debugNode.isHidden():
			self.debugNode.show()
		else:
			self.debugNode.hide()
	
	
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Returns the terrain height of the nearest vertical descending raycast from the passed Point3.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def getTerrainHeight(self, pos):
		result = 0
		x = pos.getX()
		y = pos.getY()
		z = pos.getZ()
		rayTerrA = Point3(x, y, z)
		rayTerrB = Point3(x, y, z - 256)
		rayTest = self.worldBullet.rayTestClosest(rayTerrA, rayTerrB)
		
		rayNode = rayTest.getNode()
		if (rayTest.hasHit()):
			rayPos = rayTest.getHitPos()
			result = rayPos.getZ()
		else:
			self.playerObj.respawn()
		return result
		# return self.hmTerrain.get_elevation(x + self.hmOffset, y + self.hmOffset) * self.hmHeight
	
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Handles player movement
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def playerMove(self):
	
		# Go through the collision and flag tests, and update them
		self.doPlayerTests()
		
		# Rotation and camera movement
		if self.kh.poll(self.keymap['Left']):
			self.playerObj.turn(True)
		elif self.kh.poll(self.keymap['Right']):
			self.playerObj.turn(False)
		elif(self.cameraControl):
			newMousePos = self.kh.getMouse()
			mx = newMousePos.getX()
			self.camObj.rotateCamera(mx)
		
		self.camObj.calculatePosition()
		
		# Movement
		if self.kh.poll(self.keymap['Forward']):
			self.playerObj.move(True)
			self.camObj.rotateTowards(90)
		elif self.kh.poll(self.keymap['Back']):

			self.playerObj.move(False)
		else:
			self.playerObj.stop()

		# Jump
		if(self.kh.poll(self.keymap['Space']) and self.terrSteepness < 0.25): #and not(self.ballObj.isRolling())):
			self.playerObj.jump()
		else:
			self.playerObj.resetJump()
		
		# Air Dash
		if(self.kh.poll(self.keymap['airDash'])): #and self.playerObj.getAirborneFlag() == True and self.canAirDash == True):
			self.canAirDash = False
			self.playerObj.airDash()
		
		# Shift-based actions
		if(self.kh.poll("lshift") and not(self.sbCollideFlag) and not(self.playerObj.getAirborneFlag()) and self.canUseShift):
		
			# If there's another snowball already placed
			if(self.ballObj.exists() and not(self.ballObj.isRolling())):
				self.ballObj.respawn()
				
			# If we're rolling a snowball
			elif(self.ballObj.isRolling()):
			
				# Absorb snowball
				if(self.kh.poll("v")):
					self.canUseShift = False
					snowAmt = self.ballObj.getSnowAmount()
					self.playerObj.addSnow(snowAmt)
					# self.snowMeter.fillBy(snowAmt)
					self.ballObj.destroy()
					
				# Go to iceball throwing mode
				elif(self.kh.poll("b")):
					print("TODO: Ice ball throwing mode.")
					
				# Grow the snowball
				elif(self.kh.poll("w")):
					self.ballObj.grow()
					
			# Spawn a new snowball
			elif(self.ballObj.exists() == False):
				self.ballObj.respawn()
				
		# If the player is not pressing shift
		else:
			if(self.ballObj.isRolling()):
				self.ballObj.dropBall()

		base.win.movePointer(0, 400, 300)
		
		# So updating the stats is VERY expensive.
		if (self.debugNode.isHidden() == False):
			self.updateStats()
	
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Various tests concerning the player flags and collisions.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def doPlayerTests(self):
		
		# Player's position
		plPos = self.playerObj.getPosition()
		px = plPos.getX()
		py = plPos.getY()
		pz = plPos.getZ()
		
		# Raycast directly down for terrain steepness
		rayYetiA = Point3(px, py, pz)
		rayYetiB = Point3(px, py, pz - 300)
		self.downRayTest = self.worldBullet.rayTestClosest(rayYetiA, rayYetiB).getHitNormal()
		rx = self.downRayTest.getX()
		ry = self.downRayTest.getY()
		rz = self.downRayTest.getZ()
		self.terrSteepness = 1.0 - rz

		# Redo collision flags later
		objCollisionFlag = False
		
		# Snow/Ice height adjust
		self.playerObj.updateTerrain()
		
		# Collision: Player x Objects
		for i in xrange(0, self.colObjectCount):
			if(self.colObj.didCollide(self.playerNP.node(), self.colObjects[i].AINode)):
				objCollisionFlag = True
				self.playerObj.setAirborneFlag(False)
				self.canAirDash = True
				self.playerObj.setFactor(1,1,1)
		
		# Collision: Player x Snowball
		if(self.ballObj.exists() and self.colObj.didCollide(self.playerNP.node(), self.ballObj.getRigidbody())):
			self.sbCollideFlag = True
			self.playerObj.setAirborneFlag(False)
			self.playerObj.setFactor(1, 1, 1)
		else:
			self.sbCollideFlag = False
		
		# Collision: Player x Terrain
		if(self.colObj.didCollide(self.playerNP.node(), self.heightMap)):
			if(self.playerObj.getAirborneFlag()):
				self.audioMgr.playSFX("snowCrunch01")
			self.playerObj.setAirborneFlag(False)
			self.canAirDash = True
			self.playerObj.setFactor(1, 1, 1)
			objCollisionFlag = False
			
		# Collision: Player x Death Zone
		# if(pz - 7 <= self.deathHeight or (self.colObj.didCollide(self.playerNP.node(), self.deathZone.node()))):
		if(self.colObj.didCollide(self.playerNP.node(), self.deathZone.node())):
			print("Player confirmed #REKT")
			self.playerObj.respawn()
		
		# Out of bounds checking
		if(abs(px) > 254 or abs(py) > 254):
			print("Player out of bounds!")
			self.playerObj.respawn()
		
		# Snap to terrain if... something. I need to restructure this. Don't read it.
		if(not(self.playerObj.getAirborneFlag()) and not(self.sbCollideFlag) and not(objCollisionFlag)):
			z = self.getTerrainHeight(Point3(px, py, pz))
			self.playerObj.snapToTerrain(z)
			# self.playerObj.snapToTerrain(th, self.hmHeight)
		
		# Collision: Player x Snowflakes
		for i in xrange(0, self.snowflakeCount):
			if(self.snowflakes[i].exists() and self.colObj.didCollide(self.playerNP.node(), self.snowflakes[i].getNode())):
				self.snowflakes[i].destroy()
				self.snowflakeCounter.increment()
				self.snowCount += 1
			
		self.snowMeter.updateSnow(self.playerObj)
		
		#Check if there is a "next" level. If there is, load it. Otherwise display end game screen.
		if(self.snowCount >= self.snowflakeCount):
			file_path="../maps/map" + str(self.mapID+1) + "/map" + str(self.mapID+1) + ".yetimap"
			if  os.path.lexists(file_path):
			
				self.snowCount = 0
				self.snowflakeCount = 0
				self.snowflakeCounter.setValue(0)
				self.snowflakeCounter.setState(2)
				
				#Loading Screen
				self.transition.fadeScreen(0.7)	
				self.loadingText=OnscreenText("Loading...",1,fg=(1,1,1,0),pos=(0,0),align=TextNode.ACenter,scale=.07,mayChange=1)
				base.graphicsEngine.renderFrame() 
				base.graphicsEngine.renderFrame() 
				base.graphicsEngine.renderFrame() 
				base.graphicsEngine.renderFrame()
				self.transition.noFade()
				
				#destroy objects
				self.worldBullet.removeRigidBody(self.heightMap)
				self.hmTerrainNP.removeNode()
				self.objNP.removeNode()
				self.treeNP.removeNode()
				self.rockNP.removeNode()
				self.rock2NP.removeNode()
				self.rock3NP.removeNode()
				# self.caveNP.removeNode()
				# self.planeFrontNP.removeNode()
				# self.planeWingNP.removeNode()
				self.hmNP.removeNode()
				if(int(self.mapID) == 1):
					self.ropeBridge.AIChar.setPos(-200,-300,-200)
					# self.ropeBridge.AIChar.removeNode()
					self.planeFront.AIChar.removeNode()
					self.planeTail.AIChar.setPos(-200,-200,-200)
					# self.planeTail.AIChar.removeNode()
					self.caveNew.AIChar.setPos(-1000,-1000,-1000);
					self.caveModel.AIChar.removeNode()
					#Added More Props here!
					self.boulder = SMCollide("../res/models/rock_3.egg", self.worldBullet, self.worldObj, Point3(117, 123, 17), 15, Vec3(0,0,0))
				elif(int(self.mapID) == 2):
					self.boulder.AIChar.setPos(-222,-222,-222)
					self.caveNew.AIChar.setScale(150)
					self.caveNew.AIChar.setPos(-50, 95, -50)
					# self.skybox.setScale(600)
					# self.caveNew.setH(0)
					# self.boulder.removeNode()
			
				self.mapID += 1
				print self.mapID
				# EX: maps/map-1/map-1.yetimap
				metaFile = open("../maps/map" + str(self.mapID) + "/map" + str(self.mapID) + ".yetimap", 'r')
				metaLines = metaFile.readlines()
				lineCount = len(metaLines)
				self.snowflakeCount = lineCount - 2
			
				# First Line: Player's starting position
				# EX: 50,50,50 (NO SPACES)
				playerLine = metaLines[0]
				playerPosList = playerLine.split(",")
				playerInitX = int(playerPosList[0])
				playerInitY = int(playerPosList[1])
				playerInitZ = int(playerPosList[2])
				self.playerObj.playerNP.setPos(playerInitX, playerInitY, playerInitZ)
				self.playerObj.startX = playerInitX
				self.playerObj.startY = playerInitY
				self.playerObj.startZ = playerInitZ
			
				# 2nd Line: Deathzone Height
				# ONE INTEGER
				self.deathHeight = int(metaLines[1])
			
				
				self.snowflakePositions = []
				print("Snowflake Count: " + str(self.snowflakeCount))
				for i in xrange(0, self.snowflakeCount):
					sfline = metaLines[i+2]
					sfList = sfline.split(",")
					sfx = int(sfList[0])
					sfy = int(sfList[1])
					sfz = int(sfList[2])
					self.snowflakePositions.append(Point3(sfx, sfy, sfz))
					print("New snowflake to add: (" + str(sfx) + "," + str(sfy) + "," + str(sfz) + ")")
				self.snowflakeCounter.setMaxValue(self.snowflakeCount)
				
				#load new map
				self.mapName = str(self.mapID)
				self.heightMap = self.setupHeightmap(self.mapName)
				self.deathZone = self.setupDeathzone(self.deathHeight)
					
				
				self.loadingText.cleanup() 
			else:
				taskMgr.remove('UpdateTask')
				self.endImage=OnscreenImage(image = "../res/icons/endgame1.png", pos = (0.0, 0.0, 0.0), scale = (1.35, 2, 1))
				
		
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Update the debug text.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def updateStats(self):
		pos = self.playerObj.getPosition()
		x = pos.getX()
		y = pos.getY()
		z = pos.getZ()
		vel = self.playerObj.getVelocity()
		vx = str(round(vel.getX(), 1))
		vy = str(round(vel.getY(), 1))
		vz = str(round(vel.getZ(), 1))
		sx = str(round(x, 1))
		sy = str(round(y, 1))
		sz = str(round(z, 1))
		rx = str(round(self.downRayTest.getX(), 2))
		ry = str(round(self.downRayTest.getY(), 2))
		rz = str(round(self.terrSteepness, 2))
		fric = str(round(self.playerObj.getFriction(), 2))
		ip = str(round(self.playerObj.getIceCoefficient(), 2))
		sp = str(round(self.playerObj.getSnowCoefficient(), 2))
		tHeight = str(round(self.getTerrainHeight(Point3(x, y, z)), 1))
		self.textObj.editText("yetiPos", "Position: (" + sx + ", " + sy + ", " + sz + ")")
		self.textObj.editText("yetiVel", "Velocity: (" + vx + ", " + vy + ", " + vz + ")")
		self.textObj.editText("yetiFric", "Friction: " + fric)
		self.textObj.editText("onIce", "Ice(%): " + ip)
		self.textObj.editText("onSnow", "Snow(%): " + sp)
		self.textObj.editText("terrHeight", "T Height: " + tHeight)
		self.textObj.editText("terrSteepness", "Steepness: " + rz)

	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# throw Snowball
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	def throw(self):
		self.throwing = True
		size = self.ballObj.getSize()
		#zoom camera and grab pos you wish to throw
		self.camObj.aimMode()
		taskMgr.add(self.controlCamera, "camera-task")
		rotation = self.camObj.getH()
		pitch =self.camObj.getP()
		self.ballObj.throwBall(size, pitch, rotation)
		#fix camera
		#self.throwing = False
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	# Update the world. Called every frame.
	#------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	def update(self, task):
		dt = globalClock.getDt()
		self.worldBullet.doPhysics(dt)
		# self.goat1.AIUpdate()
		# self.goat2.AIUpdate()
		self.playerMove()
		return task.cont
Esempio n. 14
0
class Play(DirectObject):
  def __init__(self, parent):
    #Turn off default mouse control
    base.disableMouse()
    base.setFrameRateMeter(True)
    
    #globalClock = ClockObject.getGlobalClock()
    #globalClock.setMode(ClockObject.MLimited)
    #globalClock.setFrameRate(1000)
    #Set windows properties
    self.props = WindowProperties()
    self.props.setCursorHidden(True)
    #props.setFullscreen(1)
    #props.setSize(int(base.pipe.getDisplayWidth()), int(base.pipe.getDisplayHeight()))
    self.props.setMouseMode(WindowProperties.MRelative)
    base.win.requestProperties(self.props)
    
    self.transition = Transitions(loader)
    self.transition.setFadeColor(0,0,0)
    
    self.parent = parent
    base.accept("escape", self.togglePause)
    self.setupSounds()
    self.startLevel(0, True)
    self.task = taskMgr.add(self.update, "updateTask")
  
  def fadeOut(self):
    self.transition.fadeOut(1)
    
  def fadeIn(self):
    self.transition.irisIn(1)
  
  def togglePause(self):
    if self.parent.paused:
      self.props.setCursorHidden(True)
      base.win.requestProperties(self.props)
      base.win.movePointer(0, base.win.getXSize()/2, base.win.getYSize()/2)
      taskMgr.add(self.task)
      self.parent.paused = False 
      self.parent.continueImage.hide()
      self.parent.restartImage.hide()
      self.parent.exitImage.hide()
      self.parent.mainFrame.hide()
      self.playingBGM.setTime(self.bgmTime) 
      self.playingBGM.play()
    else:
      self.props.setCursorHidden(False)
      base.win.requestProperties(self.props)
      taskMgr.remove(self.task)
      self.parent.paused = True
      self.parent.mainFrame.show()
      self.parent.continueImage.show()
      self.parent.restartImage.show()
      self.parent.exitImage.show()
      self.bgmTime = self.playingBGM.getTime() 
      self.playingBGM.stop()
  
  def chaseBGM(self, chasing = False):
    if chasing and self.playingBGM != self.bgFast:
      self.playingBGM.stop()
      self.playingBGM = self.bgFast
      self.bgmTime = 0
      self.playingBGM.play()
    elif not chasing and self.playingBGM != self.bgSlow:
      self.playingBGM.stop()
      self.playingBGM = self.bgSlow
      self.bgmTime = 0
      self.playingBGM.play()
    
  def initModels(self):
    self.map = MapGen(self)
    # self.player = Player(self)
    # self.level = Level()
    self.enemies = []
  
  def transitionFunc(self, level, next = False):
    tSequence = Sequence(Func(self.fadeOut), Wait(1), Func(self.startLevel, level, next), 
                               Func(self.fadeIn))
    tSequence.start()
  
  #level number, next = true if next level (false = respawning)
  def startLevel(self, level, next = False):
    # per pixel lighting
    render.clearLight()
    render.setShaderAuto()
    try:
        self.level.initLight()
    except AttributeError:
        pass
    try:
        self.player.initHandLight()
    except AttributeError:
        pass

    # """
    # render.clearLight()
    # render.setShaderAuto()
    # """
    # self.map = MapGen(self)
    # self.player = Player(self)
    # self.level = Level()
    # self.enemies = []
    
    if next:
      for node in render.getChildren():
        node.removeNode()
      for node in base.camera.getChildren():
        if node.getName() != 'cam':
          print node.getName()
          node.removeNode()
    else:
      #Clear render
      self.player.clearItems()
    
    #If next level, load level map
    
      #and initialize enemies
    if next:
      level += 1
      for node in render.getChildren():
        node.removeNode()
      
      self.player = Player(self)
      self.level = Level()
      self.enemies = []
      self.player.level = level

      self.level.loadLevel(level)
      for enemy in self.level.enemies:
        enemySpawn = Enemy( self, enemy[0], enemy[1] )
        self.enemies.append(enemySpawn)
        
    playerPos = self.level.playerPos #level.spawnPos
    walls = self.level.numWalls
    lights = self.level.numLights
    #Spawn player using spawn (spawn pos, max walls, max lights)
    self.player.spawn(playerPos,walls,lights)
    
    if not next:
      for enemy in self.enemies:
        enemy.respawn()
        
    self.playingBGM = self.bgSlow
    self.playingBGM.play()
    
    if next:
      self.setupCollisions()
    
    
  def die(self, level, next = False):
    self.transitionFunc(level, next)
    
  def setupCollisions(self): 
    #Make a collision traverser, set it to default   
    base.cTrav = CollisionTraverser()
    base.itemTrav = CollisionTraverser()
    base.pusher = CollisionHandlerPusher()
    
    base.cHandler = CollisionHandlerEvent()
    base.queue = CollisionHandlerQueue()
    base.eQueue = CollisionHandlerQueue()
    #Set the pattern for the event sent on collision
    base.cHandler.setAgainPattern("%fn-again-%in")
    base.cHandler.setInPattern("%fn-into-%in")
    base.cHandler.setOutPattern("%fn-out-%in")
    
    self.player.initCollisions()
    for enemy in self.enemies:
      enemy.initCollisions(self.player)
    
    #base.cTrav.showCollisions(render)

  #Set up BGM
  def setupSounds(self):
    ######################slow music##########################
    self.bgSlow = base.loadMusic("sounds/slow.ogg")
    self.bgSlow.setLoopCount(0)
    ######################fast music############################
    self.bgFast = base.loadMusic("sounds/fast.ogg")
    self.bgFast.setLoopCount(0)
    self.playingBGM = self.bgSlow    
    
  def update(self, task):
    dt = globalClock.getDt()
    self.player.update(globalClock.getDt())
    if self.player.newLevel:
      return task.cont
    for enemy in self.enemies:
      enemy.update(globalClock.getDt(), self.player)
    return task.cont
Esempio n. 15
0
class GameManager(FSM):
	
	def __init__(self, filename):
		FSM.__init__(self, 'Game')
		
		self.savedGame = PlayerFileParser("save.xml")
		self.playerData = self.savedGame.playerData
		self.playerData.setShip(shipDb[self.playerData.ship.name])
		
		self.crosshair = MouseCursor()
		self.crosshair.setMode(1)
		
		self.mainMenu = MainMenu()
		self.mainMenu.hide()
		self.mainMenu.buttons[0]["command"] = self.request
		self.mainMenu.buttons[0]["extraArgs"] = ["Space"]
		
		self.mainMenu.buttons[1]["command"] = self.request
		self.mainMenu.buttons[1]["extraArgs"] = ["Ground"]
		
		self.mainMenu.buttons[3]["command"] = self.quit
		self.mainMenu.buttons[3]["extraArgs"] = [0]
		
		
		#self.groundGui = GroundGui(self.playerData)
		#self.groundWorldManager = GroundManager(self)
		
		#self.spaceWorldManager = SpaceOdeWorldManager(self)
		
		self.prevState = None
		
		self.trans = Transitions(loader)
		
		self.request("IntroMainMenu")
		#self.request("Space")
	
	def quit(self, extraArgs=[]):
		audio3d.detachListener()
		sys.exit()
		
	def getEscape(self):
		if self.state == "Space":
			if self.spaceWorldManager.camHandler.mode == "turret":
				self.spaceWorldManager.setMode("manual")
			else:
				self.prevState = "Space"
				self.request("IntroMainMenu")
			
		elif self.state == "Ground":
			self.prevState = "Ground"
			self.request("IntroMainMenu")
		elif self.state == "IntroMainMenu":
			if self.prevState is not None:
				self.request(self.prevState)
		
	def saveGame(self):
		self.savedGame.save()
	
	def enterIntroMainMenu(self):
		#print "we entered intro main menu"
		self.mainMenu.show()
		self.trans.fadeIn()
		
	def exitIntroMainMenu(self):
		#print("we exited intro main menu")
		self.trans.fadeOut()
		self.mainMenu.hide()
		
	def enterSpace(self):
		#print "we entered space"
		'''
		audio3d = Audio3DManager.Audio3DManager(base.sfxManagerList[0], camera)
		audio3d.setDistanceFactor(100)
		audio3d.setListenerVelocityAuto()
		#audio3d.attachListener(camera)
		'''
		self.trans.fadeIn()
		self.spaceWorldManager = SpaceOdeWorldManager(self)
		self.spaceWorldManager.start()
		
		
	def exitSpace(self):
		#print("we exited space")
		self.trans.fadeOut()
		self.spaceWorldManager.destroy()
		del self.spaceWorldManager
		
	def enterGround(self):
		#print "we entered ground"
		self.trans.fadeIn()
		self.groundWorldManager = GroundManager(self)
		self.groundWorldManager.start()
		
		
	def exitGround(self):
		#print("we exited ground")
		self.trans.fadeOut()
		self.groundWorldManager.destroy()
		del self.groundWorldManager
Esempio n. 16
0
    def initgame(self):
        self.transition = Transitions(loader)
        self.getparameters()

        self.GameOver = False
        self.BlackScreen = 0

        self.p_ID = self.b.get()
        self.p_age = self.d.get()
        self.p_gender = self.f.get()

        self.file = open(
            'logs/Reversal3D_end30_5of6_logfile_' + str(self.p_ID) + '.txt',
            'w')
        # added two extra columns to the log file
        self.file.write(
            "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t"
            % ("pID", "Age", "Gender", "TrialNumber", "Reversal", "Target",
               "Choice", "Correct", "TotalScore", "RunningTotal",
               "Last6TrialsTotal", "TrialNumPhase", "Visits0", "Visits1",
               "Visits2", "Visits3", "ResponseTime"))
        self.file.close()

        print "ID:", self.p_ID, "Gender:", self.p_gender, "Age:", self.p_age

        print "ID:", self.p_ID, "Gender:", self.p_gender, "Age:", self.p_age

        self.rungame = True
        self.TotalScore = 0
        self.RunningTotal = 0
        self.trial_no = -1
        self.new_trial = True
        self.end_aq_after = 30
        self.end_rev_after = 30
        self.trial_num_phase = 0

        self.reverse_now = False
        self.TrialScoreList = []
        self.TrialScoreLastFiveSix = []
        self.LastFiveSixCount = 0

        # when starting a new trial, pick gender and kiki parameters
        self.new_trial = True
        if self.p_gender == "Male":
            self.kiki = CreateActor("Models/baseboy.x",
                                    "textures/baseboy2.png", 0, 0, 0, 0)
        else:
            self.kiki = CreateActor("Models/kiki.x", "textures/kiki.jpg", 0, 0,
                                    0, 0)
        self.kiki.currentframe = 0
        self.kiki.reparentTo(self.render)
        self.isTurning = False
        self.lag = 0
        self.ScoreText = None

        # how often screen refreshes
        self.framerate = 30
        globalClock.setMode(ClockObject.MLimited)
        globalClock.setFrameRate(self.framerate)
        self.frames = [
            int(round(i)) for i in np.arange(0, 1200, 60. / self.framerate)
        ]
        # creating the boxes
        self.present1 = CreateActor("Models/test.x",
                                    "textures/presentgrey.png", 0, 0, 0, 0)
        self.present1.reparentTo(self.render)
        self.present2 = CreateActor("Models/test.x",
                                    "textures/presentgrey.png", 0, 0, 0, 0)
        self.present2.reparentTo(self.render)
        self.present3 = CreateActor("Models/test.x",
                                    "textures/presentgrey.png", 0, 0, 0, 0)
        self.present3.reparentTo(self.render)
        self.present4 = CreateActor("Models/test.x",
                                    "textures/presentgrey.png", 0, 0, 0, 0)
        self.present4.reparentTo(self.render)
        self.presents = [
            self.present1, self.present2, self.present3, self.present4
        ]

        self.texgrey = loader.loadTexture("textures/presentgrey.png")
        if self.boxcol == "A":
            self.tex1 = loader.loadTexture("textures/presentblue.png")
            self.tex2 = loader.loadTexture("textures/presentyellow.jpg")
            self.tex3 = loader.loadTexture("textures/presentpink.jpg")
            self.tex4 = loader.loadTexture("textures/presentgreen.png")
            self.tex5 = loader.loadTexture("textures/presentpurple.png")
        else:
            self.tex1 = loader.loadTexture("textures/presentbrown.jpg")
            self.tex2 = loader.loadTexture("textures/presentorange.png")
            self.tex3 = loader.loadTexture("textures/presentred.png")
            self.tex4 = loader.loadTexture("textures/presentgreys.png")
            self.tex5 = loader.loadTexture("textures/presentlightpurple.png")

        self.textures = [self.tex1, self.tex2, self.tex3, self.tex4]
        # making the star and positions
        self.star = self.loader.loadModel("Models/star.x")
        tex = loader.loadTexture("textures/gold_texture.jpg")
        self.star.setTexture(tex)
        self.star.setScale(self.starsize)
        self.star.setPos(0, 0, 3)
        # making the black cloud and their positions
        self.clouds = CreateActor("Models/clouds.x", "textures/cotton.jpg", 0,
                                  0, 0, 0)
        self.star.setScale(self.cloudsize)
        # setting up the room environment
        self.environ = self.loader.loadModel("Models/Room.x")
        self.environ.reparentTo(self.render)

        # setting the wall colors - note that Reversal task uses set "A" and
        # practice task uses set B
        if self.wallcol == "A":
            tex = loader.loadTexture("textures/arena.png")
        else:  # set B
            tex = loader.loadTexture("textures/room2.png")
        self.environ.setTexture(tex)
        self.environ.setScale(2, 2, 2)
        self.environ.setPos(0, 0, 0)

        self.starLoc = []
        for i in range(4):
            for j in range(10):
                self.starLoc.append([i, j])

        self.floater = NodePath(PandaNode("floater"))
        self.floater.reparentTo(self.kiki)
        self.floater.setZ(2.0)

        self.angle = -2 * np.pi * self.kiki.getH() / 360

        alight = AmbientLight('alight')
        alight.setColor(VBase4(2, 2, 2, 1))
        alnp = render.attachNewNode(alight)
        render.setLight(alnp)
        self.plight = PointLight('plight')
        self.plight.setColor(VBase4(0, 0, 0, 0))
        self.plnp = render.attachNewNode(self.plight)

        #animation frames:
        self.runframe = get_frames(1, 40, self.framerate)
        self.digframe = get_frames(60, 240, self.framerate)
        self.presentsframe = get_frames(0, 180, self.framerate)
        self.winframe = get_frames(320, 360, self.framerate)
        self.losingframe = get_frames(380, 460, self.framerate)
        self.dragframe = get_frames(242, 302, self.framerate)
        self.cloudsframe = get_frames(0, 180, self.framerate)

        # this is the new way to randomize the correct box for each subject
        # this will also reset for reversal
        self.correctbox = fluffle([0, 1, 2])[0]  #np.random.randint(0,3)
        self.reversal = 0

        self.savelog = False
        # we don't have the joystick version
        # will always print error in console
        self.joystickon = 0

        try:
            if joystick.get_count() > 0:
                self.joystickon = 1
                self.joystick = joystick.Joystick(0)
                self.joystick.init()
        except:
            print "Joystick Error"
            self.joystickon = 0
Esempio n. 17
0
class Engine(ShowBase):
    def __init__(self):
        ShowBase.__init__(self)
        self.disableMouse()

        props = WindowProperties()
        props.setTitle('Test')
        self.win.requestProperties(props)

        # self.render.setAntiAlias(AntialiasAttrib.MAuto)

        self.transitions = Transitions(self.loader)
        self.transitions.setFadeColor(0, 0, 0)

        self.filters = CommonFilters(self.win, self.cam)
        # self.filters.setCartoonInk()
        self.filters.setBlurSharpen(1)
        # self.filters.setVolumetricLighting(self.render)

        # self.buffer = self.win.makeTextureBuffer("Post-processing buffer", self.win.getXSize(), self.win.getXSize())
        # print self.buffer.getYSize()
        # self.texture = self.buffer.getTexture()
        # self.buffer.setSort(-100)
        #
        # self.originalCamera = self.camera
        # self.offScreenCamera = self.makeCamera(self.buffer)
        # self.camera = self.offScreenCamera
        #
        # self.img = OnscreenImage(image=self.texture, pos=(0, 0, 0.5))

        self.scene = None
        self.channel = Channel()

    def set_scene(self, scene_module):
        # self.transitions.fadeOut(0.2)
        args = []

        if self.scene:
            args.append(Parallel(Func(self.fade_out), LerpFunc(self.blur_out, duration=0.2)))
            args.append(Wait(0.2))

        args.append(Func(self._set_scene, scene_module))
        args.append(Parallel(Func(self.fade_in), LerpFunc(self.blur_in, duration=0.4)))

        Sequence(*args).start()

    def blur_out(self, t):
        # index = int(t)
        # self.filters.delBlurSharpen()
        self.filters.setBlurSharpen(1 - t)
        self.filters.setBloom(intensity=t)

    def blur_in(self, t):
        # index = int(t)
        # self.filters.delBlurSharpen()
        self.filters.setBlurSharpen(t)
        self.filters.setBloom(intensity=-t)

    def fade_out(self):
        self.transitions.fadeOut(0.2)

    def fade_in(self):
        self.transitions.fadeIn(0.2)

    def _set_scene(self, scene_module):
        group, class_ = scene_module.split('.')
        module = importlib.import_module('game.scenes.{}'.format(group))
        scene_class = getattr(module, class_)
        if self.scene:
            self.scene.destroy()
            del self.scene
        self.scene = scene_class(self)
        # self.transitions.fadeIn(0.2)

    def start(self):
        self.channel = Channel()
        self.channel.connect()

        self.set_scene('auth.AuthScene')

        while True:
            self.taskMgr.step()
            if self.channel.can_read():
                for packet in self.channel.read_packets():
                    self.scene.on_packet(packet)
Esempio n. 18
0
class ToonCreator(DirectObject):
    __module__ = __name__
    
    notify = DirectNotifyGlobal.directNotify.newCategory("ToonCreator")
    
    dataCache = {
      'Animal' : None,
      'Gender' : None,
      'Weight' : None,
      'Height' : None,
      'Color' : None,
      'HeadType' : None,
      'HeadLength' : None,
      'Shirt' : None,
      'Bottoms' : None
    }
    
    avatar = Avatar()
    subject = None
    
    def __init__(self):
        self.trans = Transitions(loader)
        self.scene = render.getPythonTag('SceneManager').createScene('Make-A-Toon')
        self.setupEnvironment()
        self.randomizeData()
        self.setupHUD()
        self.bgm = SoundBank.getSound('make_a_toon')
        self.bgm.setLoop(True)
        self.bgm.play()
        
    def setupHUD(self):
        gui1 = loader.loadModel('phase_3/models/gui/create_a_toon_gui.bam')
        gui2 = loader.loadModel('phase_3/models/gui/gui_toongen.bam')
        mickeyFont = loader.loadFont('MickeyFont.bam')
        self.guiElements = [
            OnscreenImage(image = gui1.find("**/CrtATn_TopBar"), parent=render2d, pos=(0, 0, 0.9), scale=(0.85, 0.85, 1)),
            OnscreenText(text = "Make Your Toon", pos = (0, 0.85), font = mickeyFont, fg = (1, 0, 0, 1),
                scale=(0.2, 0.2, 0.2)),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.66, 0, 0.4), relief=None, command=self.setData, extraArgs=['Animal', 'prev']),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0, 0, 0.41), hpr=(0, 0, 180), command=self.setData, extraArgs=['Animal', 'next'], relief=None),
            OnscreenText(text = "Animal", pos = (0.325, 0.38), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.08, 0.08, 0.08)),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.66, 0, 0.1), relief=None, command=self.setData, extraArgs=['Weight', 'prev']),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0, 0, 0.11), hpr=(0, 0, 180), command=self.setData, extraArgs=['Weight', 'next'], relief=None),
            OnscreenText(text = "Body", pos = (0.325, 0.1), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.08, 0.08, 0.08)),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.66, 0, -0.20), relief=None, command=self.setData, extraArgs=['Height', 'prev']),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0, 0, -0.19), hpr=(0, 0, 180), command=self.setData, extraArgs=['Height', 'next'], relief=None),
            OnscreenText(text = "Height", pos = (0.325, -0.2), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.08, 0.08, 0.08)),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.66, 0, -0.50), relief=None, command=self.setData, extraArgs=['HeadType', 'prev']),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0, 0, -0.49), hpr=(0, 0, 180), command=self.setData, extraArgs=['HeadType', 'next'], relief=None),
            OnscreenText(text = "Head", pos = (0.325, -0.5), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.08, 0.08, 0.08)),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.66, 0, -0.8), relief=None, command=self.setData, extraArgs=['Color', 'prev']),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0, 0, -0.79), hpr=(0, 0, 180), command=self.setData, extraArgs=['Color', 'next'], relief=None),
            OnscreenText(text = "Length", pos = (0.328, -0.67), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.08, 0.08, 0.08)),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.57, 0, -0.65), scale = 0.4, relief=None, command=self.setData, extraArgs=['HeadLength', 'short']),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.11, 0, -0.64), scale = 0.4, hpr=(0, 0, 180), command=self.setData, extraArgs=['HeadLength', 'long'], relief=None),            
            OnscreenText(text = "Color", pos = (0.325, -0.8), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.08, 0.08, 0.08)),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui2.find("**/tt_t_gui_mat_girlUp"), gui2.find("**/tt_t_gui_mat_girlDown")), pos=(0.66, 0, 0.68), relief=None, command=self.randomizeData, extraArgs = ['girl'], scale=(0.55, 0.55, 0.55)),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui2.find("**/tt_t_gui_mat_boyUp"), gui2.find("**/tt_t_gui_mat_boyDown")), pos=(0, 0, 0.68), command=self.randomizeData, extraArgs = ['boy'], relief=None, scale=(0.55, 0.55, 0.55)),
            DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom=(gui2.find("**/tt_t_gui_mat_okUp"), gui2.find("**/tt_t_gui_mat_okDown")), pos=(1, 0, -0.2), relief=None, command=self.done)
        ] 
        
    def done(self):
        self.trans.irisOut()
        self.bgm.stop()
        for element in self.guiElements:
            element.removeNode()
        base.taskMgr.doMethodLater(0.8, self.cleanUp, 'Cleanup Scene')
        
    def cleanUp(self, task):
        self.bgm.stop()
        self.scene.delete()
        ToontownCentral().loadScene()
        self.trans.irisIn()
        from doomsday.avatar.LocalAvatar import Player
        Player(self.avatar).setupToon()
        return Task.done
        
    def setData(self, key, value):
        attr = AvatarAttributes()
        tables = {'Animal' : attr.getAnimals(), 
                  'Gender' : ['boy', 'girl'],
                  'Color' : attr.convertColorDictToTbl(),
                  'Weight' : attr.getWeights(),
                  'Height' : attr.getHeights(),
                  'HeadType' : attr.getHeadTypes(),
                  'HeadLength' : ['short', 'long']}
        if(key not in self.dataCache):
            return
        if(value == 'prev' or value == 'next'):
            table = tables[key]
            index = 0
            for i in xrange(len(table)):
                if(table[i] == self.dataCache[key]):
                    index = i
            if(value == 'prev'):
                if(index == 0):
                    self.dataCache[key] = table[(len(table) - 1)]
                else:
                    self.dataCache[key] = table[index - 1]
            else:
                if(index == (len(table) - 1)):
                    self.dataCache[key] = table[0]
                else:
                    self.dataCache[key] = table[index + 1]
        else:
            self.dataCache[key] = value
        self.generateAvatar()
            
        
    def randomizeData(self, gender = None):
        def setData(key, value):
            self.dataCache[key] = value
        
        attr = AvatarAttributes()
        setData('Animal', random.choice(attr.getAnimals()))
        if(gender == None):
            setData('Gender', random.choice(['boy', 'girl']))
        else:
            setData('Gender', gender)
        setData('Weight', random.choice(attr.getWeights()))
        setData('Height', random.choice(attr.getHeights()))
        setData('Color', random.choice(attr.convertColorDictToTbl()))
        setData('HeadType', random.choice(attr.getHeadTypes()))
        setData('HeadLength', random.choice(['short', 'long']))
        self.generateAvatar()
    
    def generateAvatar(self):
        self.cleanupAvatar()
        for key in self.dataCache.keys():
            self.avatar.setData(key, self.dataCache[key])
        self.avatar.generate()
        self.avatar.getAvatar().setPosHprScale(-2, 0, 0, 200, 0, 0, 1, 1, 1)
        self.avatar.getAvatar().reparentTo(render)
        self.subject = self.avatar.getAvatar()
        self.subject.setName("Temp Toon")
        self.subject.loop('neutral')
        shirtColor = random.choice(AvatarAttributes().convertColorDictToTbl())
        bttColor = random.choice(AvatarAttributes().convertColorDictToTbl())
        self.subject.find("**/torso-top").setColor(shirtColor)
        self.subject.find("**/sleeves").setColor(shirtColor)
        self.subject.find('**/torso-bot').setColor(bttColor)
    
    def cleanupAvatar(self):
        if(self.subject != None):
            self.subject.stop('neutral')
            self.subject.cleanup()
            self.subject.removeNode()
        
    def setupEnvironment(self):
        self.trans.fadeIn(2)
        room = loader.loadModel('phase_3/models/gui/create_a_toon.bam')
        room.find('**/sewing_machine').removeNode()
        room.find('**/drafting_table').removeNode()
        room.find("**/wall_floor").setColor(0.7294117647058824, 0.5490196078431373, 0.2392156862745098, 1)
        room.setName("Room")
        self.scene.addModel(room)
Esempio n. 19
0
class LevelChanger(DirectObject):
    
    #Use this to handle changing of levels
    #check the emeny list and if it is empty then change the level
    #Flag to tell if the level is complete
    levelComplete = False

    def __init__(self):
        
        #Level map
        self.level01 = "resources/theSouthBridge"
        self.level02 = "resources/theSocket"
        self.level03 = "resources/theDualChannel"
        self.level04 = "resources/theRoot"
        self.levelMap = {1:self.level01, 2:self.level02, 3:self.level03, 4:self.level04}
        self.currentLevel = 1
        
        #Level music map
        self.level01M = base.loader.loadMusic("resources/sounds/level1.wav")
        self.level02M = base.loader.loadMusic("resources/sounds/level2.wav")
        self.level03M = base.loader.loadMusic("resources/sounds/level3.wav")
        self.level04M = base.loader.loadMusic("resources/sounds/bossMusic.wav")
        self.musicMap = {1:self.level01M, 2:self.level02M, 3:self.level03M, 4:self.level04M}

        self.currentMusic = self.musicMap[self.currentLevel]

        self.currentMusic.setLoop(True)
        self.currentMusic.play()

        #Open file to get player spawns 
        self.pSpawnsFile = open("playerSpawns.txt")
        self.pSpawnsList = self.pSpawnsFile.readlines()
        self.pSpawnsFile.close()
        
        #Set players current spawn
        self.spawnIndex = 0
        base.xPos = float(self.pSpawnsList[self.spawnIndex + 1].split("=")[1].translate(None,"\n"))
        base.yPos = float(self.pSpawnsList[self.spawnIndex + 2].split("=")[1].translate(None,"\n"))
        base.zPos = float(self.pSpawnsList[self.spawnIndex + 3].split("=")[1].translate(None,"\n"))
        base.player.playerNode.setPos(0, 0, 30) #resets height
        base.player.playerModel.setPos(base.xPos, base.yPos, base.zPos) #resets position

    #checks the enemy list
    #if the list is empty, level is complete
    #set flag to true and change the level.
    def checkLevel (self, task):
        
        enemy = base.spawner.spawnId
        
        if(len(base.enemyList) == 0):
            if enemy > 0:
                self.levelComplete = True
                if self.currentLevel == len(self.levelMap):
                    base.player.hide()
                    base.player.canUseWeapons = False
                    base.fsm.request('WinMenu', 1)
                    return task.done
                else:
                    self.changeLevel(task)
        
        return task.cont
        

    def changeLevel(self, task):
        
        if(self.levelComplete == True):
           
            self.transition = Transitions(loader)
            self.transition.setFadeColor(0, 0, 0)
            self.fadeOut = self.transition.fadeOut(2)

            #unload the current level and models
            self.unload(self.levelMap[self.currentLevel])

            #load the next level and models
            self.load(self.levelMap[self.currentLevel + 1])

            #self.fadeIn = self.transition.fadeIn(5)
            base.taskMgr.remove(task)
        
        return task.cont

    #Unloads current level objects
    def unload(self, level):

        for i in base.pickuplist:
           
            i.deletePickup = True
        
        for i in base.enemyList:
            
            i.delFlag = True
            i.deadFlag = True
        
        #stop the music
        self.currentMusic.stop()
        
        #detach playerNode
        base.player.playerNode.detachNode()
        
        #Remove enemies
        #base.taskMgr.remove("Spawn Enemies")
        base.taskMgr.remove("enemyCleanup")

        #unload the env and detach remove the node
        base.loader.unloadModel(level)
        base.environ.removeNode()
    
    #Load the next level
    def load(self, level):
        
        #Reset player health for the next level
        base.player.adjustHealth(base.player.maxEnergy)

        #load Environment - new level
        base.environ = base.loader.loadModel(level)
        base.environ.reparentTo(base.render)
        base.environ.setScale(7, 7, 3)
        
        #update the currentLevel.
        self.currentLevel += 1

        #reattach player to render
        base.player.playerNode.reparentTo(render)
	    
        #Set the next levels spawn coordinates 
        self.spawnIndex += 4
        base.xPos = float(self.pSpawnsList[self.spawnIndex + 1].split("=")[1].translate(None,"\n"))
        base.yPos = float(self.pSpawnsList[self.spawnIndex + 2].split("=")[1].translate(None,"\n"))
        base.zPos = float(self.pSpawnsList[self.spawnIndex + 3].split("=")[1].translate(None,"\n"))
        
        base.player.playerNode.setPos(0,0,30) #resets height
        base.player.playerModel.setPos(base.xPos, base.yPos, base.zPos) #resets position
        
        #create new spawner on the env
        base.spawner = Spawner(base.environ, level.split("/")[1].translate(None,"\n"))
        #Reinit enemies
        base.spawner.spawn()
        base.taskMgr.add(self.checkLevel, "checkLevel")
        base.taskMgr.add(base.enemyCleanUp, "enemyCleanup", taskChain='GameTasks')

        self.fadeIn = self.transition.fadeIn(2)
        
        self.currentMusic = self.musicMap[self.currentLevel]

        self.currentMusic.setLoop(True)
        self.currentMusic.play()
        
    #Returns the current level
    def getCurrentLevel(self):

        return self.currentLevel
    
    #Goes direcctly to the boss level
    def goToBoss(self):

        self.transition = Transitions(loader)
        self.transition.setFadeColor(0, 0, 0)
        self.fadeOut = self.transition.fadeOut(2)
        self.unload(self.levelMap[1])
        self.load(self.levelMap[4])
        self.currentLevel = 4
    
    #Resets enemies upon death
    def resetEnemy(self):

        base.player.playerModel.setPos(base.xPos, base.yPos, base.zPos)
        base.player.playerNode.setPos(0,0,30) #resets height
        
        for i in base.enemyList:
            i.delFlag = True
            i.deadFlag = True
            
        for i in base.pickuplist:
            i.deletePickup = True
            
        #create new spawner on the current level
        base.spawner = Spawner(base.environ, self.levelMap[self.currentLevel].split("/")[1].translate(None,"\n"))
        #Reinit enemies
        base.spawner.spawn()
Esempio n. 20
0
class MakeAToon:
    def __init__(self):
        self.notify = DirectNotifyGlobal.directNotify.newCategory("Starting Make A Toon.")
        self.localAvatar = LocalAvatar.toonBody
        base.localAvatar = self.localAvatar
        self.toonColors = Localizer.toonColorDict
        self.colorNum = 0
        self.numColors = Localizer.numColors
        self.MakeAToonText = Localizer.MakeAToonText
        self.Mickey = Localizer.Mickey
        self.mickeyFont = loader.loadFont('phase_3/models/fonts/MickeyFont.bam')
        self.Text = OnscreenText(text = "Make A Toon", pos = (0, 0.75), font = self.mickeyFont, fg = (1, 0, 0, 1),scale=(0.2, 0.2, 0.2))
        self.gui = loader.loadModel('phase_3/models/gui/tt_m_gui_mat_mainGui.bam')
        self.gui.flattenMedium()
        self.gui1 = loader.loadModel('phase_3/models/gui/create_a_toon_gui.bam')
        self.gui2 = loader.loadModel('phase_3/models/gui/gui_toongen.bam')
        self.guiNextUp = self.gui.find('**/tt_t_gui_mat_nextUp')
        self.transition = Transitions(loader)
        self.transition.irisIn(1)
        self.transition.fadeIn(5)
        self.load()

    def load(self):
        self.Music = loader.loadMusic('phase_3/audio/bgm/create_a_toon.mid')
        self.Music.setLoop(1)
        self.MusicVolume = (0.4)
        self.Music.play()
        self.Music.setVolume(self.MusicVolume)
        base.localAvatar.setPos(0.80, 2, 0)
        base.localAvatar.setHpr(176, 0, 0)
        LocalAvatar.setMovementAnimation('neutral')
        self.room = loader.loadModel('phase_3/models/gui/create_a_toon.bam')
        self.room.reparentTo(render)
        self.room.find('**/sewing_machine').removeNode()
        self.room.find('**/drafting_table').removeNode()
        self.room.find("**/wall_floor").setColor(0.7294117647058824, 0.5490196078431373, 0.2392156862745098, 1)
        self.room.setName("Room")
        self.ee = DirectFrame(pos=(-1, 1, 1), frameSize=(-.01, 0.01, -.01, 0.01), frameColor=(0, 0, 0, 0.05), state='normal')
        self.ee.bind(DGG.B1PRESS, lambda x, ee = self.ee: self.toggleSlide())
        self.eee = self.ee
        self.toonSpin = base.localAvatar.hprInterval(2, Vec3(540, 0, 0))
        self.toonSpin2 = base.localAvatar.hprInterval(2, Vec3(180, 0, 0))
        self.CameraMove = camera.posInterval(1,
                                  Point3(-0.50, -11, 3),
                                  startPos=Point3(1, -11, 3))
        self.CameraMoveSequence = Sequence(self.CameraMove)
        self.ToonEnter = base.localAvatar.posInterval(1,
                                  Point3(0.60, 2, 0),
                                  startPos=Point3(-4, 2, 0))
        self.ToonEnterPace = Sequence(self.ToonEnter)
        self.ToonEnter.start()
        self.oobeButton = DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (self.gui1.find("**/CrtATn_R_Arrow_UP"), self.gui1.find("**/CrtATn_R_Arrow_DN"), self.gui1.find("**/CrtATn_R_Arrow_RLVR")), relief=None, hpr=(0, 0, 180), command=self.goBack)
        self.oobeButton.setScale(1)
        self.oobeButton.setPos(-0.70,3,-0.25)
        self.goBackButton = DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (self.gui1.find("**/CrtATn_R_Arrow_UP"), self.gui1.find("**/CrtATn_R_Arrow_DN"), self.gui1.find("**/CrtATn_R_Arrow_RLVR")), relief=None, command=self.goRight)
        self.goBackButton.setScale(1)
        self.goBackButton.setPos(0.80,3,-0.25)
        self.spinButton = DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (self.gui1.find("**/CrtATn_R_Arrow_UP"), self.gui1.find("**/CrtATn_R_Arrow_DN"), self.gui1.find("**/CrtATn_R_Arrow_RLVR")), relief=None, command=self.HprToon)
        self.spinButton.setScale(0.60)
        self.spinButton.setPos(0.50,2,-0.50)
        self.spinButton2 = DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (self.gui1.find("**/CrtATn_R_Arrow_UP"), self.gui1.find("**/CrtATn_R_Arrow_DN"), self.gui1.find("**/CrtATn_R_Arrow_RLVR")), relief=None, hpr=(0, 0, 180), command=self.HprToon2)
        self.spinButton2.setScale(0.60)
        self.spinButton2.setPos(-0.40,2,-0.50)
        self.OK = DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom=(self.gui2.find("**/tt_t_gui_mat_okUp"), self.gui2.find("**/tt_t_gui_mat_okDown")), pos=(0.90,1,-0.80), relief=None, command=self.CameraButton)


    def goRight(self):
        for color in self.toonColors[self.colorNum]:
            LocalAvatar.bodyNodes[color].setColor(self.toonColors[self.colorNum][color])
        self.colorNum += 1
        if self.colorNum > self.numColors:
            self.colorNum = 0

    def goBack(self):
        for color in self.toonColors[self.colorNum]:
            LocalAvatar.bodyNodes[color].setColor(self.toonColors[self.colorNum][color])
        self.colorNum -= 1
        if self.colorNum < 0:
            self.colorNum = self.numColors
    
    def HprToon(self):
        self.toonSpin.start()

    def HprToon2(self):
        self.toonSpin2.start()

    def CameraButton(self):
        self.transition.irisIn()
        self.transition.fadeOut(1)
        self.Music.stop()
Esempio n. 21
0
class Game(State):
	mapOffset = {"up": (0,1), "down": (0,-1), "left": (-1,0), "right": (1,0)}

	def __init__(self, stage, characters, player, player2):
		State.__init__(self)

		# how to know the players that will be in game? a ChoosePlayer screen before the constructor?
		self.characters = characters

		self.player = player
		self.player2 = player2

		self.stage = stage
		self.room = self.stage.start
		self.isOver = False

		self.players = []

		#print(self.players)
		self.startMap()

		self.status = {}

		posi = 0
		for c in self.characters:
			# initialize character status string
			self.status[c] = (OnscreenText(mayChange= True ,
				                             style=2, fg=(1,1,1,1),
				                             pos=(1.4*posi - 0.8,-0.83), scale = .07)
			)
			posi += 1

		self.transitions = Transitions(GameLoader.loader)
		self.clock = ClockObject()
		self.lastTime = 0

		GameLoader.music.addSfx('barrel_breaks')
		GameLoader.music.addSfx('stone','aif')

	def spawnObject(self, ob):
		ob.setMap(self.currentMap())
		ob.getNode().reparentTo(NodePath(self.currentMap().getNode()))
		x,y = self.currentMap().posToGrid(ob.getPos())

		if ob.symbol == 'i':
			GameLoader.music.addSfx(ob.sfx)

		try:
			self.currentMap().tiles[Map.COLLISION][y][x] = ob.symbol
		except IndexError as e:
			print('Index error: ' , ob.id, e )

	def currentMap(self):
		return self.stage.maps[self.room]

	def exitMap(self):
		for i in range(self.currentMap().width):
			for j in range(self.currentMap().height):
				atype = self.currentMap().tileType(1,(i,j))
				if atype == 'block' or atype == 'liftable':
					self.currentMap().tiles[1][j][i] = ' '

		for b in self.currentMap().blocks:
			b.setPos(b.originalPos)
			x,y = self.currentMap().posToGrid(b.getPos())
			self.currentMap().tiles[Map.COLLISION][y][x] = 'b'
			b.getNode().reparentTo(NodePath(self.currentMap().getNode()))

		for b in self.currentMap().liftables:
			b.setPos(b.originalPos)
			x,y = self.currentMap().posToGrid(b.getPos())
			self.currentMap().tiles[Map.COLLISION][y][x] = 'l'
			b.getNode().reparentTo(NodePath(self.currentMap().getNode()))

		for d in self.currentMap().doors:
			if d.permanent:
				x,y = self.currentMap().posToGrid(d.getPos())
				self.currentMap().tiles[Map.COLLISION][y][x] = 'd'
				d.getNode().reparentTo(NodePath(self.currentMap().getNode()))

		for char in [self.characters[self.player], self.characters[self.player2]]:
			char.lifting = None

		NodePath(self.currentMap().getNode()).detachNode()

	def startMap(self):
		if not self.currentMap().started:
			for obstacle in self.currentMap().obstacles:
				self.spawnObject(obstacle)

			for item in self.currentMap().items:
				self.spawnObject(item)

			for block in self.currentMap().blocks:
				self.spawnObject(block)

			for liftable in self.currentMap().liftables:
				self.spawnObject(liftable)

			for switch in self.currentMap().switches:
				switch.getNode().reparentTo(NodePath(self.currentMap().getNode()))

			for door in self.currentMap().doors:
				self.spawnObject(door)

			self.currentMap().started = True

			for e in self.currentMap().enemies:
				self.spawnObject(e)

		self.characters[self.player].setMap(self.currentMap())
		self.characters[self.player2].setMap(self.currentMap())

	def changeMap(self,direction,char):

		self.transitions.fadeOut(1)
		self.transitions.fadeIn(2)

		#TODO modularize for more characters
		self.exitMap()
		self.room = self.stage.doors[self.room][direction]
		NodePath(self.currentMap().getNode()).reparentTo(self.node)

		map = self.stage.maps[self.room]
		x, y = self.currentMap().posToGrid(char.getPos())
		if   direction == "right": x = 1
		elif direction == "left":  x = map.width-2
		elif direction == "down":  y = 1
		elif direction == "up":    y = map.height-2
		pos = self.currentMap().gridToPos((x,y))

		self.characters[self.player].setPos(pos)
		self.characters[self.player2].setPos(pos)
		self.characters[self.player2].setDirection(self.characters[self.player].direction)


		self.startMap()

	def register(self, render, camera, keys, render2d):
		State.register(self, render, camera, keys, render2d)
		self.node.attachNewNode(self.stage.maps[self.room].getNode())


		for c in self.characters:
			self.status[c].reparentTo(self.node2d)

		for char in self.characters.values():
			char.getNode().reparentTo(self.node)
			char.stunRender = self.node

		for l in self.stage.getLights():
			render.setLight(l)

		# COWABUNGA test!!!
		self.hearts = {}
		numChar=0

		self.heartsNode = NodePath(PandaNode('hearts'))
		self.heartsNode.reparentTo(self.node2d)

		for char in self.characters:
			self.hearts[char] = []

			for i in range(Character.maxHearts):
				self.hearts[char].append(Sprite("heart.png", 0.05, 0.05))
				self.hearts[char][i].setPos(-0.8 + 1.4*numChar + (i%3)*0.055 , -0.9 - int(i/3)*0.055)
				self.hearts[char][i].getNode().reparentTo(self.heartsNode)

			numChar += 1

		#COWABUNGA comment this to stop the madness
		render.setAttrib(LightRampAttrib.makeSingleThreshold(0.1, 1))

		# THE TRUE CARTOON SHADER :P
#		self.separation = 1 # Pixels
		self.filters = CommonFilters(base.win, self.camera.camera)
		# cell shading
#		filterok = self.filters.setCartoonInk(separation=self.separation)
		# glow
		filterok = self.filters.setBloom(blend=(0.5,0.5,0.5,1), desat=-0.5, intensity=0.5, size="small")

		self.camera.setPos(0, -2.5, -2.5)
		self.camera.lookAt(0, 0, 0)

	def iterate(self):
		State.iterate(self)
		self.camera.look()

		self.moveObjects()
		self.doCharActions()
		self.moveChars()
		self.buryDeadPeople()

		self.activateSwitches()

		self.updateHUD()

		for c in self.characters:
			self.characters[c].tryToRecover()

		if self.isOver:
			return "GameOver"
		elif self.keys['start']:
			return "Paused"

	def updateHUD(self):

		for c in self.characters:
			self.status[c].setText(self.characters[c].getStatus())

			if self.characters[c].healthChanged:
				for heart in self.hearts[c]:
					heart.getNode().detachNode()

				for i in range(self.characters[c].hearts):
					self.hearts[c][i].getNode().reparentTo(self.heartsNode)

				self.characters[c].healthChanged = False

	def moveObjects(self):
		# BLOCK MOVEMENT ACTION
		for block in self.currentMap().blocks:
			if block.isMoving:
				block.move(block.direction)
				p1, p2 = block.getCollisionPos(block.direction)
				x1, y1 = self.currentMap().posToGrid(p1)
				x2, y2 = self.currentMap().posToGrid(p2)
				try:
					for x,y in [(x1,y1), (x2,y2)]:
						if self.stage.maps[self.room].tileType(1, (x,y)) == 'enemy':
							for enemy in self.currentMap().enemies:
								lPos = self.currentMap().posToGrid(enemy.getPos())
								if tuple(lPos) == (x,y):
									self.collision(block, enemy)
						else:
							for char in self.characters:
								if (x,y) == self.currentMap().posToGrid(self.characters[char].getPos()):
									bx,by = self.currentMap().posToGrid(block.getPos())
									self.currentMap().tiles[Map.COLLISION][by][bx] = ' '
									self.characters[char].stun()
									block.stop()
									block.getNode().detachNode()
				except IndexError:
					block.stop()

		# LIFTABLE MOVEMENT ACTION
		for liftable in self.currentMap().liftables:
			if liftable.isMoving:
				liftable.move(liftable.direction)
				p1, p2 = liftable.getCollisionPos(liftable.direction)
				x1, y1 = self.currentMap().posToGrid(p1)
				x2, y2 = self.currentMap().posToGrid(p2)
				try:
					for x,y in [(x1,y1), (x2,y2)]:
						if self.stage.maps[self.room].tileType(1, (x,y)) == 'enemy':
							for enemy in self.currentMap().enemies:
								lPos = self.currentMap().posToGrid(enemy.getPos())
								if tuple(lPos) == (x,y):
									self.collision(liftable, enemy)
						elif self.stage.maps[self.room].tileType(1, (x,y)) != 'free':
							liftable.stop()
							liftable.getNode().detachNode()
						else:
							for char in self.characters:
								if (x,y) == self.currentMap().posToGrid(self.characters[char].getPos()):
									print "Stun nele!"
									self.characters[char].stun()
									liftable.stop()
									liftable.getNode().detachNode()
				except IndexError:
					# to do, create a liftable.destroy(), which animates the liftable and do these two actions:
					liftable.stop()
					liftable.getNode().detachNode()

	def doCharActions(self):
		for char in [self.characters[self.player], self.characters[self.player2]]:
			add = "1"
			if char == self.characters[self.player]:
				add = ""

			if self.keys['attack'+add]:
				self.keys['attack'+add] = False
				print('Using %s' % (char.currentItem()) )
				p1, p2 = char.getCollisionPos(char.direction)
				x1, y1 = self.currentMap().posToGrid(p1)
				x2, y2 = self.currentMap().posToGrid(p2)

				for x,y in [(x1,y1), (x2,y2)]:
					if self.stage.maps[self.room].tileType(Map.COLLISION, (x,y)) == 'door':
						for d in self.currentMap().doors:
							if tuple(self.currentMap().posToGrid(d.getPos())) == (x,y):
								opened = d.open(char.currentItem())
								if opened:
									self.currentMap().tiles[Map.COLLISION][y][x] = ' '
									char.destroyCurrentItem()

			if self.keys['cancel'+add]:
				self.keys['cancel'+add] = False
				print('Changing slot')
				char.changeSlot()

			if self.keys['action'+add]:
				self.keys['action'+add] = False
				if char.lifting:
					char.lifting.setHeight(0)
					char.lifting.move(char.direction)
					char.lifting = None
				else:
					p1, p2 = char.getCollisionPos(char.direction)
					x1, y1 = self.currentMap().posToGrid(p1)
					x2, y2 = self.currentMap().posToGrid(p2)

					for x,y in [(x1,y1), (x2,y2)]:
						if self.stage.maps[self.room].tileType(Map.COLLISION, (x,y)) == 'block':
							for block in self.currentMap().blocks:
								if tuple(self.currentMap().posToGrid(block.getPos())) == (x,y):
									GameLoader.music.playSfx('stone')
									block.move(char.direction)
						elif self.stage.maps[self.room].tileType(Map.COLLISION, (x,y)) == 'item':
							for item in self.currentMap().items:
								if tuple(self.currentMap().posToGrid(item.getPos())) == (x,y):
									self.collision(char, item)
						elif self.currentMap().tileType(Map.COLLISION, (x,y)) == 'liftable':
							for liftable in self.currentMap().liftables:
								lPos = self.currentMap().posToGrid(liftable.getPos())
								if tuple(lPos) == (x,y):
									char.pick(liftable)
									self.currentMap().tiles[1][y][x] = ' '

	def moveChars(self):
		for char in [self.characters[self.player], self.characters[self.player2]]:
			add = "1"
			if char == self.characters[self.player]:
				add = ""

			directions = [key for key in ["up","down","left","right"] if self.keys[key+add]]

			if len(directions) == 0:
				char.stop()

			for dir in directions:
				#TODO to be re-refactored
				p1, p2 = char.getCollisionPos(dir)

				if self.currentMap().futPosAreFree(p1, p2):
					char.move(dir)
					if char.lifting:
						char.lifting.setPos(char.getPos())

					ex = self.stage.maps[self.room].getExit(self.currentMap().posToGrid(p1))

					if ex and (ex in self.stage.doors[self.room].keys()):
						self.changeMap(ex,char)
				else:
					char.setDirection(dir)

			for enemy in self.currentMap().enemies:
				#TODO actually enemies are still present in the map
				x,y = self.currentMap().posToGrid(enemy.getPos())
				self.currentMap().tiles[Map.COLLISION][y][x] = ' '

				# COWABUNGA
				# se botarmos aqui uma funcao que define como o inimigo anda
				# vai dar tudo certo
				# por exemplo ele pode as vezes andar em direcao a um heroi e
				# as vezes ser random
				# por enquanto e so random
				# - OK, agreed
				dir = ['up','down','left','right'][random.randint(0,3)]
				p1, p2 = enemy.getCollisionPos(dir)

				if self.currentMap().futPosAreFree(p1, p2):
					enemy.enemy_move(dir)
				else:
					enemy.setDirection(dir)

				x,y = self.currentMap().posToGrid(enemy.getPos())
				self.currentMap().tiles[Map.COLLISION][y][x] = 'e'

			p1, p2 = char.getCollisionPos(char.direction)
			x1, y1 = self.currentMap().posToGrid(p1)
			x2, y2 = self.currentMap().posToGrid(p2)
			for x,y in [(x1,y1), (x2,y2)]:
				collisionTiles = ["enemy"]
				collisionElements = {"enemy": self.currentMap().enemies}

				for t in collisionTiles:
					if self.stage.maps[self.room].tileType(Map.COLLISION, (x,y)) == t:
						for e in collisionElements[t]:
							lPos = self.currentMap().posToGrid(e.getPos())
							if tuple(lPos) == (x,y):
								self.collision(char, e)

	def activateSwitches(self):
		mp = self.currentMap()
		for s in mp.switches:
			x,y = mp.posToGrid(s.getPos())
			charPos = [self.currentMap().posToGrid(self.characters[char].getPos()) for char in self.characters]
			if mp.tiles[Map.COLLISION][y][x] != ' ' or ((x,y) in charPos):
				#print 'activated!'
				mp.tiles[Map.GROUND][y][x] = 'S'
				s.activate()
			else:
				#print 'deactivated!'
				mp.tiles[Map.GROUND][y][x] = 's'
				s.deactivate()

		for d in mp.doors:
			openDoor = True
			if d.openWith == "switches":
				for ds in d.switches:
					for ms in mp.switches:
						if (ds == ms.name) and (not ms.active):
							openDoor = False
							break
				if openDoor:
					d.open("switches")
					x,y = mp.posToGrid(d.getPos())
					mp.tiles[Map.COLLISION][y][x] = ' '

	def collision(self, a, b):
		print "Collision: TYPE A:", a.getType(), "TYPE B:", b.getType()

		if b.getType() == 'item':
			for i in range(len(self.currentMap().items)):
				if i < len(self.currentMap().items): #we need this because the size of the list may change if we remove an item
					if tuple(self.currentMap().items[i].getPos()) == tuple(b.getPos()):
						# removes the item
						self.currentMap().items.pop(i)

						x, y = self.currentMap().posToGrid((NodePath(b.getNode()).getX(), NodePath(b.getNode()).getZ()))

						# it's not drawed anymore
						self.currentMap().tiles[Map.COLLISION][y][x] = ' '
						NodePath(b.getNode()).detachNode()

						#it's picked
						oldItem = a.pickItem(b)
						if oldItem != None:
							print oldItem.name
							oldItem.setPos(self.currentMap().gridToPos((x,y)))
							oldItem.originalPos = oldItem.getPos()
							self.spawnObject(oldItem)
							self.currentMap().items.append(oldItem)

		if a.getType() == 'liftable' or b.getType() == 'liftable':
			GameLoader.music.playSfx('barrel_breaks')

		if a.getType() == 'liftable' and b.getType() == 'enemy':
			a.stop()
			a.getNode().detachNode()
			x,y = self.currentMap().posToGrid(a.getPos()) #nao precisaria
			self.currentMap().tiles[Map.COLLISION][y][x] = ' '
			b.takeDamage(10000)

			if not b.isAlive():
				x, y = self.currentMap().posToGrid(b.getPos())
				self.currentMap().tiles[Map.COLLISION][y][x] = ' '
				NodePath(b.getNode()).removeNode()
				self.currentMap().enemies.remove(b)

		if a.getType() == 'block' and b.getType() == 'enemy':
			a.stop()
			a.getNode().detachNode()
			x,y = self.currentMap().posToGrid(a.getPos())
			self.currentMap().tiles[Map.COLLISION][y][x] = ' '
			b.takeDamage(10000)

			if not b.isAlive():
				x, y = self.currentMap().posToGrid(b.getPos())
				self.currentMap().tiles[Map.COLLISION][y][x] = ' '
				NodePath(b.getNode()).removeNode()
				self.currentMap().enemies.remove(b)

		if a.getType() == 'Character':
			print("Character collided with", b.getType())
			if b.getType() == 'enemy':
				a.takeDamage(1)

	def buryDeadPeople(self):
		# commented while fixing the bugs
		for enemy in self.currentMap().enemies:
			if not enemy.isAlive():
				x, y = self.currentMap().posToGrid(enemy.getPos())
				self.currentMap().tiles[Map.COLLISION][y][x] = ' '
				NodePath(enemy.getNode()).removeNode()
				self.currentMap().enemies.remove(enemy)

		#if not self.player.isAlive() : #tratar isso corretamente!
		for char in self.characters:
			if not self.characters[char].isAlive():
				self.isOver = True


	def enter(self):
		State.enter(self)
		self.stage.playMusic()

	def exit(self):

#		self.transitions.fadeOut(2)
#		self.transitions.fadeIn(3)
#		self.transitions.noFade()

		self.stage.stopMusic()
#		self.heartsNode.removeNode()
#		for c in self.characters:
#			NodePath(self.characters[c].getNode()).removeNode()
#			self.status[c].removeNode()

#		NodePath(self.currentMap().getNode()).removeNode()
		State.exit(self)
Esempio n. 22
0
	def __init__(self, mapID, tObj, aObj):

		self.mapID = mapID
		
		# EX: maps/map-1/map-1.yetimap
		metaFile = open("../maps/map" + str(self.mapID) + "/map" + str(self.mapID) + ".yetimap", 'r')
		metaLines = metaFile.readlines()
		lineCount = len(metaLines)
		self.snowflakeCount = lineCount - 2
		self.snowCount = 0
		
		# First Line: Player's starting position
		# EX: 50,50,50 (NO SPACES)
		playerLine = metaLines[0]
		playerPosList = playerLine.split(",")
		playerInitX = int(playerPosList[0])
		playerInitY = int(playerPosList[1])
		playerInitZ = int(playerPosList[2])
		self.playerStart = Point3(playerInitX, playerInitY, playerInitZ)
		
		# 2nd Line: Deathzone Height
		# ONE INTEGER
		self.deathHeight = int(metaLines[1])
		
		# Get dem snowflakes
		self.snowflakePositions = []
		print("Snowflake Count: " + str(self.snowflakeCount))
		for i in xrange(0, self.snowflakeCount):
			sfline = metaLines[i+2]
			sfList = sfline.split(",")
			sfx = int(sfList[0])
			sfy = int(sfList[1])
			sfz = int(sfList[2])
			self.snowflakePositions.append(Point3(sfx, sfy, sfz))
			print("New snowflake to add: (" + str(sfx) + "," + str(sfy) + "," + str(sfz) + ")")

		#load in controls
		ctrlFl = open("ctrConfig.txt")
		#will skip n lines where [n,]
		#makes a list of controls
		self.keymap = eval(ctrlFl.read())
		#close file
		ctrlFl.close()
		
		# Create new instances of our various objects
		self.mapName = str(mapID)
		self.audioMgr = aObj
		self.worldObj = self.setupWorld()
		self.heightMap = self.setupHeightmap(self.mapName)
		self.deathZone = self.setupDeathzone(self.deathHeight)
		self.debugNode = self.setupDebug()	
		
		# Player Init
		self.playerObj = SMPlayer(self.worldBullet, self.worldObj, self, self.playerStart, self.audioMgr)
		self.playerNP = self.playerObj.getNodePath()
		self.playerNP.setH(180);
		self.canUseShift = True
		self.canAirDash = True
		
		# Snowball Init
		self.ballObj = SMBall(self.worldBullet, self.worldObj, self.playerObj, self.playerNP)
		self.sbCollideFlag = False
		self.ballNP = self.ballObj.getNodePath()
		
		# Key Handler
		self.kh = SMKeyHandler()
		self.lastMousePos = self.kh.getMouse()
		
		# Collision Handler
		self.colObj = self.setupCollisionHandler()
		
		# Lighting
		self.ligObj = SMLighting(Vec4(.4, .4, .4, 1), Vec3(-5, -5, -5), Vec4(2.0, 2.0, 2.0, 1.0))
		
		# Camera
		self.camObj = SMCamera(self.playerObj, self.worldBullet, self.worldObj)
		self.cameraControl = False

		# GUI
		self.GUI = SMGUI()
		self.snowflakeCounter = SMGUICounter("snowflake", self.snowflakeCount) # Replace 3 with # of snowflakes in level.
		self.snowMeter = SMGUIMeter(100)
		self.GUI.addElement("snowflake", self.snowflakeCounter)
		self.GUI.addElement("snowMeter", self.snowMeter)
		
		#Snowy Outside
		# base.enableParticles()
		# self.p = ParticleEffect()
		# self.p.cleanup()
		# self.p = ParticleEffect()
		# self.p.loadConfig('snow.ptf')        
		# self.p.start(self.camObj.getNodePath())
		# self.p.setPos(0.00, 0.500, 0.000)

		# AI
		# self.goat1 = SMAI("../res/models/goat.egg", 75.0, self.worldBullet, self.worldObj, -70, -95, 5)
		# self.goat1.setBehavior("flee", self.playerNP)
		# self.goat2 = SMAI("../res/models/goat.egg", 75.0, self.worldBullet, self.worldObj, -80, -83, 5)
		# self.goat2.setBehavior("flee", self.playerNP)
		# print("AI Initialized")
		
		# Debug Text
		self.textObj = tObj
		self.textObj.addText("yetiPos", "Position: ")
		self.textObj.addText("yetiVel", "Velocity: ")
		self.textObj.addText("yetiFric", "Friction: ")
		self.textObj.addText("onIce", "Ice(%): ")
		self.textObj.addText("onSnow", "Snow(%): ")
		self.textObj.addText("terrHeight", "T Height: ")
		self.textObj.addText("terrSteepness", "Steepness: ")
		
		# Pause screen transition
		self.transition = Transitions(loader)

		# Method-based keybindings
		# self.accept('b', self.spawnBall)
		self.accept('escape', base.userExit)
		self.accept('enter', self.pauseUnpause)
		self.accept('f1', self.toggleDebug)
		
		self.accept('lshift-up', self.enableShiftActions)
		self.accept('mouse1', self.enableCameraControl)
		self.accept('mouse1-up', self.disableCameraControl)
		self.accept('wheel_up', self.camObj.zoomIn)
		self.accept('wheel_down', self.camObj.zoomOut)
		
		self.pauseUnpause()
		
		# Disable the mouse
		base.disableMouse()
		props = WindowProperties()
		props.setCursorHidden(True)
		base.win.requestProperties(props)
		
		# Uncomment this to see everything being rendered.
		self.printSceneGraph()
		
		# Play the BGM
		self.audioMgr.playBGM("snowmanWind")
		
		# Skybox formed
		skybox = loader.loadModel("../res/models/skybox.egg")
		# skybox.set_two_sided(true)
		skybox.setScale(500)
		skybox.setPos(0, 0, -450)
		skybox.reparentTo(render)
		
		mountain = loader.loadModel("../res/models/mountain.egg")
		mountain.reparentTo(render)
		mountain.setPos(650,800,20)
		mountain.setScale(120)
		
		self.colObjects = []
		
		self.caveNew = SMCollide("../res/models/cave_new.egg", self.worldBullet, self.worldObj, Point3(-50, 95, -13), 11, Vec3(0,0,0))
		self.colObjects.append(self.caveNew)
		
		self.planeFront = SMCollide("../res/models/plane_front", self.worldBullet, self.worldObj, Point3(190, -100, -15), 8, Vec3(190,0,30))
		self.colObjects.append(self.planeFront)
		
		self.caveModel = SMCollide("../res/models/cave_tunnel.egg", self.worldBullet, self.worldObj, Point3(233, 68, 32), 4, Vec3(135,180,0))
		self.colObjects.append(self.caveModel)
		
		self.planeTail = SMCollide("../res/models/plane_tail.egg", self.worldBullet, self.worldObj, Point3(-40, -130, -7), 10, Vec3(230,0,0))
		self.colObjects.append(self.planeTail)
		
		self.ropeBridge = SMCollide("../res/models/rope_bridge.egg", self.worldBullet, self.worldObj, Point3(180, 115, 30), 6, Vec3(50,0,0))
		self.colObjects.append(self.ropeBridge)
		
		self.colObjectCount = len(self.colObjects)
		
		print("World initialized.")
Esempio n. 23
0
class MakeAToon:
    def __init__(self):
        self.notify = DirectNotifyGlobal.directNotify.newCategory(
            "Starting Make A Toon.")
        self.localAvatar = LocalAvatar.toonBody
        base.localAvatar = self.localAvatar
        self.toonColors = Localizer.toonColorDict
        self.colorNum = 0
        self.numColors = Localizer.numColors
        self.MakeAToonText = Localizer.MakeAToonText
        self.Mickey = Localizer.Mickey
        self.mickeyFont = loader.loadFont(
            'phase_3/models/fonts/MickeyFont.bam')
        self.Text = OnscreenText(text="Make A Toon",
                                 pos=(0, 0.75),
                                 font=self.mickeyFont,
                                 fg=(1, 0, 0, 1),
                                 scale=(0.2, 0.2, 0.2))
        self.gui = loader.loadModel(
            'phase_3/models/gui/tt_m_gui_mat_mainGui.bam')
        self.gui.flattenMedium()
        self.gui1 = loader.loadModel(
            'phase_3/models/gui/create_a_toon_gui.bam')
        self.gui2 = loader.loadModel('phase_3/models/gui/gui_toongen.bam')
        self.guiNextUp = self.gui.find('**/tt_t_gui_mat_nextUp')
        self.transition = Transitions(loader)
        self.transition.irisIn(1)
        self.transition.fadeIn(5)
        self.load()

    def load(self):
        self.Music = loader.loadMusic('phase_3/audio/bgm/create_a_toon.mid')
        self.Music.setLoop(1)
        self.MusicVolume = (0.4)
        self.Music.play()
        self.Music.setVolume(self.MusicVolume)
        base.localAvatar.setPos(0.80, 2, 0)
        base.localAvatar.setHpr(176, 0, 0)
        LocalAvatar.setMovementAnimation('neutral')
        self.room = loader.loadModel('phase_3/models/gui/create_a_toon.bam')
        self.room.reparentTo(render)
        self.room.find('**/sewing_machine').removeNode()
        self.room.find('**/drafting_table').removeNode()
        self.room.find("**/wall_floor").setColor(0.7294117647058824,
                                                 0.5490196078431373,
                                                 0.2392156862745098, 1)
        self.room.setName("Room")
        self.ee = DirectFrame(pos=(-1, 1, 1),
                              frameSize=(-.01, 0.01, -.01, 0.01),
                              frameColor=(0, 0, 0, 0.05),
                              state='normal')
        self.ee.bind(DGG.B1PRESS, lambda x, ee=self.ee: self.toggleSlide())
        self.eee = self.ee
        self.toonSpin = base.localAvatar.hprInterval(2, Vec3(540, 0, 0))
        self.toonSpin2 = base.localAvatar.hprInterval(2, Vec3(180, 0, 0))
        self.CameraMove = camera.posInterval(1,
                                             Point3(-0.50, -11, 3),
                                             startPos=Point3(1, -11, 3))
        self.CameraMoveSequence = Sequence(self.CameraMove)
        self.ToonEnter = base.localAvatar.posInterval(1,
                                                      Point3(0.60, 2, 0),
                                                      startPos=Point3(
                                                          -4, 2, 0))
        self.ToonEnterPace = Sequence(self.ToonEnter)
        self.ToonEnter.start()
        self.oobeButton = DirectButton(
            clickSound=Globals.getClickSound(),
            rolloverSound=Globals.getRlvrSound(),
            geom=(self.gui1.find("**/CrtATn_R_Arrow_UP"),
                  self.gui1.find("**/CrtATn_R_Arrow_DN"),
                  self.gui1.find("**/CrtATn_R_Arrow_RLVR")),
            relief=None,
            hpr=(0, 0, 180),
            command=self.goBack)
        self.oobeButton.setScale(1)
        self.oobeButton.setPos(-0.70, 3, -0.25)
        self.goBackButton = DirectButton(
            clickSound=Globals.getClickSound(),
            rolloverSound=Globals.getRlvrSound(),
            geom=(self.gui1.find("**/CrtATn_R_Arrow_UP"),
                  self.gui1.find("**/CrtATn_R_Arrow_DN"),
                  self.gui1.find("**/CrtATn_R_Arrow_RLVR")),
            relief=None,
            command=self.goRight)
        self.goBackButton.setScale(1)
        self.goBackButton.setPos(0.80, 3, -0.25)
        self.spinButton = DirectButton(
            clickSound=Globals.getClickSound(),
            rolloverSound=Globals.getRlvrSound(),
            geom=(self.gui1.find("**/CrtATn_R_Arrow_UP"),
                  self.gui1.find("**/CrtATn_R_Arrow_DN"),
                  self.gui1.find("**/CrtATn_R_Arrow_RLVR")),
            relief=None,
            command=self.HprToon)
        self.spinButton.setScale(0.60)
        self.spinButton.setPos(0.50, 2, -0.50)
        self.spinButton2 = DirectButton(
            clickSound=Globals.getClickSound(),
            rolloverSound=Globals.getRlvrSound(),
            geom=(self.gui1.find("**/CrtATn_R_Arrow_UP"),
                  self.gui1.find("**/CrtATn_R_Arrow_DN"),
                  self.gui1.find("**/CrtATn_R_Arrow_RLVR")),
            relief=None,
            hpr=(0, 0, 180),
            command=self.HprToon2)
        self.spinButton2.setScale(0.60)
        self.spinButton2.setPos(-0.40, 2, -0.50)
        self.OK = DirectButton(clickSound=Globals.getClickSound(),
                               rolloverSound=Globals.getRlvrSound(),
                               geom=(self.gui2.find("**/tt_t_gui_mat_okUp"),
                                     self.gui2.find("**/tt_t_gui_mat_okDown")),
                               pos=(0.90, 1, -0.80),
                               relief=None,
                               command=self.CameraButton)

    def goRight(self):
        for color in self.toonColors[self.colorNum]:
            LocalAvatar.bodyNodes[color].setColor(
                self.toonColors[self.colorNum][color])
        self.colorNum += 1
        if self.colorNum > self.numColors:
            self.colorNum = 0

    def goBack(self):
        for color in self.toonColors[self.colorNum]:
            LocalAvatar.bodyNodes[color].setColor(
                self.toonColors[self.colorNum][color])
        self.colorNum -= 1
        if self.colorNum < 0:
            self.colorNum = self.numColors

    def HprToon(self):
        self.toonSpin.start()

    def HprToon2(self):
        self.toonSpin2.start()

    def CameraButton(self):
        self.transition.irisIn()
        self.transition.fadeOut(1)
        self.Music.stop()