Example #1
0
	def __init__(self):
		ShowBase.__init__(self)
		
		#start the time
		self.globalTime = 0
		self.nextEnemy = 1
		
		#setup your collision event handlers, apparently needs a direct object
		
		self.do = DirectObject()
		self.do.accept('unit-into-unit', self.handleUnitIntoCollision)
		self.do.accept('unit-out-unit', self.handleUnitOutCollision)
		self.do.accept('unit-into-cube', self.handleCubeIntoCollision)
		self.do.accept('unit-into-wing', self.handleWingIntoCollision)
		self.do.accept('unit-into-bar', self.handleBarIntoCollision)
		
		#get window properties
		self.winProps = WindowProperties()
		#self.winProps.setFullscreen(True)
		self.winProps.setCursorHidden(True)
		base.win.requestProperties(self.winProps)
		
		self.winProps = base.win.getProperties()
		self.screenHeight = self.winProps.getYSize()
		
		#set up the control scheme
		self.controlScheme = ControlScheme(base.mouseWatcherNode, base.win, \
										[LEFT, RIGHT, UP, DOWN, PAUSE, PULL, PUSH, SWITCH, QUIT])
		
		#disable the automatic task to move the camera
		#(this does not actually disable the mouse)
		base.disableMouse()
		
		#declare null values for variables, fill them in later
		self.environment = None
		self.player = None
		
		#a node for holding all in-game units
		self.unitNodePath = NodePath('unit holder')
		self.unitNodePath.reparentTo(self.render)
		
		#object lists
		self.enemies = []
		self.obstacles = []
		self.projectiles = []
		#list of enemies to be spawned
		self.eSpawnList = []
		
		#not paused by default
		self.paused = False
		self.pauseWasPressed = False
		
		#variables for tracking time
		self.previousFrameTime = 0
		
		#start the collision traverser
		traverser = CollisionTraverser()
		base.cTrav = traverser#run every frame
		self.cTrav = base.cTrav
		#set the check for units accidentally passing through level geometry
		self.cTrav.setRespectPrevTransform(True)
		
		#self.cTrav.showCollisions(self.render)
		#self.cTrav.showCollisions(self.unitNodePath)#show the collisions
		
		#load terrain and enemies
		
		#load the environment, it seems that an x value of zero, a y value of -50 puts the origin point relatively in the middle of the crater
		filename = PARAMS_PATH + "environment.txt"
		self.loadLevelGeom(filename)
		#load the enemies
		filename = PARAMS_PATH + "enemies.txt"
		self.loadLevelEnemies(filename)
		
		#lookup table for actors
		self.actors = {}
		
		#place the player in the environment
		self.player = Player(self.controlScheme, self.camera, self, 0, 0, 0)
		self.player.setName("player")
		self.player.setH(180)
		self.player.reparentTo(self.unitNodePath)
		self.player.nodePath = self.render.find("player")
		self.actors["player"] = self.player
		
		
		#add some lights
		topLight = DirectionalLight("top light")
		topLight.setColor(Vec4(0.5, 0.5, 0.5, 1))
		topLight.setDirection(Vec3(0, -90, 0))
		self.render.setLight(self.render.attachNewNode(topLight))
		
		ambientLight = AmbientLight("ambient light")
		ambientLight.setColor(Vec4(0.5, 0.5, 0.5, 1))
		self.render.setLight(self.render.attachNewNode(ambientLight))
		
		#the distance the camera is from the player
		self.cameraHOffset = 45
		self.cameraVOffset = 10
		
		#add the collision sound
		self.collisionSound = self.loader.loadSfx(SFX_PATH + "collide.wav")
		
		#register the update task
		self.taskMgr.add(self.updateGame, "updateGame")
		
		#add targeting to the world
		self.setupTargeting()
		
		#seed the random number generator
		random.seed()

		# configure the entire GUI
		self.setupGUI()

		# configure the title screen
		self.setupTitleScreen()
Example #2
0
class Game(ShowBase):
	def __init__(self):
		ShowBase.__init__(self)
		
		#start the time
		self.globalTime = 0
		self.nextEnemy = 1
		
		#setup your collision event handlers, apparently needs a direct object
		
		self.do = DirectObject()
		self.do.accept('unit-into-unit', self.handleUnitIntoCollision)
		self.do.accept('unit-out-unit', self.handleUnitOutCollision)
		self.do.accept('unit-into-cube', self.handleCubeIntoCollision)
		self.do.accept('unit-into-wing', self.handleWingIntoCollision)
		self.do.accept('unit-into-bar', self.handleBarIntoCollision)
		
		#get window properties
		self.winProps = WindowProperties()
		#self.winProps.setFullscreen(True)
		self.winProps.setCursorHidden(True)
		base.win.requestProperties(self.winProps)
		
		self.winProps = base.win.getProperties()
		self.screenHeight = self.winProps.getYSize()
		
		#set up the control scheme
		self.controlScheme = ControlScheme(base.mouseWatcherNode, base.win, \
										[LEFT, RIGHT, UP, DOWN, PAUSE, PULL, PUSH, SWITCH, QUIT])
		
		#disable the automatic task to move the camera
		#(this does not actually disable the mouse)
		base.disableMouse()
		
		#declare null values for variables, fill them in later
		self.environment = None
		self.player = None
		
		#a node for holding all in-game units
		self.unitNodePath = NodePath('unit holder')
		self.unitNodePath.reparentTo(self.render)
		
		#object lists
		self.enemies = []
		self.obstacles = []
		self.projectiles = []
		#list of enemies to be spawned
		self.eSpawnList = []
		
		#not paused by default
		self.paused = False
		self.pauseWasPressed = False
		
		#variables for tracking time
		self.previousFrameTime = 0
		
		#start the collision traverser
		traverser = CollisionTraverser()
		base.cTrav = traverser#run every frame
		self.cTrav = base.cTrav
		#set the check for units accidentally passing through level geometry
		self.cTrav.setRespectPrevTransform(True)
		
		#self.cTrav.showCollisions(self.render)
		#self.cTrav.showCollisions(self.unitNodePath)#show the collisions
		
		#load terrain and enemies
		
		#load the environment, it seems that an x value of zero, a y value of -50 puts the origin point relatively in the middle of the crater
		filename = PARAMS_PATH + "environment.txt"
		self.loadLevelGeom(filename)
		#load the enemies
		filename = PARAMS_PATH + "enemies.txt"
		self.loadLevelEnemies(filename)
		
		#lookup table for actors
		self.actors = {}
		
		#place the player in the environment
		self.player = Player(self.controlScheme, self.camera, self, 0, 0, 0)
		self.player.setName("player")
		self.player.setH(180)
		self.player.reparentTo(self.unitNodePath)
		self.player.nodePath = self.render.find("player")
		self.actors["player"] = self.player
		
		
		#add some lights
		topLight = DirectionalLight("top light")
		topLight.setColor(Vec4(0.5, 0.5, 0.5, 1))
		topLight.setDirection(Vec3(0, -90, 0))
		self.render.setLight(self.render.attachNewNode(topLight))
		
		ambientLight = AmbientLight("ambient light")
		ambientLight.setColor(Vec4(0.5, 0.5, 0.5, 1))
		self.render.setLight(self.render.attachNewNode(ambientLight))
		
		#the distance the camera is from the player
		self.cameraHOffset = 45
		self.cameraVOffset = 10
		
		#add the collision sound
		self.collisionSound = self.loader.loadSfx(SFX_PATH + "collide.wav")
		
		#register the update task
		self.taskMgr.add(self.updateGame, "updateGame")
		
		#add targeting to the world
		self.setupTargeting()
		
		#seed the random number generator
		random.seed()

		# configure the entire GUI
		self.setupGUI()

		# configure the title screen
		self.setupTitleScreen()
	
	def setupGUI(self):
		GUIFont = loader.loadFont(FONTS_PATH + 'orbitron-medium.ttf')
		
		"""
		self.debugText = TextNode('debug')
		self.debugText.setText("")
		self.debugText.setAlign(TextNode.ALeft)
		self.debugText.setFont(GUIFont)
		
		dTextNodePath = aspect2d.attachNewNode(self.debugText)
		dTextNodePath.setScale(0.075)
		dTextNodePath.setPos(-1.2, 0, -0.9)
		"""
		
		#INTRO
		self.introText = TextNode('intro')
		self.introText.setText("")
		self.introText.setAlign(TextNode.ALeft)
		self.introText.setFont(GUIFont)
		self.introText.setCardColor(0.1, 0.1, 0.1, 0.6)
		self.introText.setCardAsMargin(0.5, 0.5, 0.5, 0.5)
		self.introText.setCardDecal(True)
		self.introText.setWordwrap(30.0)
		
		self.iTextNodePath = aspect2d.attachNewNode(self.introText)
		self.iTextNodePath.setScale(0.06)
		self.iTextNodePath.setPos(-1.2, 0, -0.7)
		
		#image is 171 x 323
		self.leftMouseImage = OnscreenImage()
		self.leftMouseImage.setImage(GUI_PATH + "mouse-icon-left.png")
		self.leftMouseImage.setTransparency(1)
		self.leftMousePath = aspect2d.attachNewNode(self.leftMouseImage.node())
		
		self.rightMouseImage = OnscreenImage()
		self.rightMouseImage.setImage(GUI_PATH + "mouse-icon-right.png")
		self.rightMouseImage.setTransparency(1)
		self.rightMousePath = aspect2d.attachNewNode(self.rightMouseImage.node())
		
		self.middleMouseImage = OnscreenImage()
		self.middleMouseImage.setImage(GUI_PATH + "mouse-icon-middle.png")
		self.middleMouseImage.setTransparency(1)
		self.middleMousePath = aspect2d.attachNewNode(self.middleMouseImage.node())
		
		self.leftMousePath.setScale(.105882, 0, .2)
		self.leftMousePath.setPos(1.1, 0, -0.75)
		self.rightMousePath.setScale(.105882, 0, .2)
		self.rightMousePath.setPos(1.1, 0, -0.75)
		self.middleMousePath.setScale(.105882, 0, .2)
		self.middleMousePath.setPos(1.1, 0, -0.75)
		
		self.leftMousePath.hide()
		self.rightMousePath.hide()
		self.middleMousePath.hide()
		
		#HUD
		#image is 365 x 187
		self.attackModeImage = OnscreenImage()
		self.attackModeImage.setImage(GUI_PATH + "mode-area.png")
		self.attackModeImage.setTransparency(1)
		
		modeNodePath = aspect2d.attachNewNode(self.attackModeImage.node())
		modeNodePath.setScale(.136631, 0, .07)
		modeNodePath.setPos(-1.13, 0, 0.88)
		
		self.energyBarImage = OnscreenImage()
		self.energyBarImage.setImage(GUI_PATH + "energy-bar-full.png")
		self.energyBarImage.setTransparency(1)
		
		eBarNodePath = aspect2d.attachNewNode(self.energyBarImage.node())
		eBarNodePath.setScale(.400, 0, .0475)
		eBarNodePath.setPos(-0.66, 0, 0.88)
		
		self.healthBarImage = OnscreenImage()
		self.healthBarImage.setImage(GUI_PATH + "health-bar-full.png")
		self.healthBarImage.setTransparency(1)
		
		hBarNodePath = aspect2d.attachNewNode(self.healthBarImage.node())
		hBarNodePath.setScale(.400, 0, .0475)
		hBarNodePath.setPos(0.85, 0, 0.88)
	
	def setupTitleScreen(self):
		self.titleScreenIsActive = True
		
		#image is 800 x 600
		self.titleImage = OnscreenImage()
		self.titleImage.setImage(GUI_PATH + "title.png")
		
		titleNodePath = aspect2d.attachNewNode(self.titleImage.node())
		titleNodePath.setScale(1.33333, 0, 1)
		titleNodePath.setPos(0, 0, 0)
	
	def updateTitleScreen(self):
		if (self.controlScheme.keyDown(PUSH) or self.controlScheme.keyDown(PULL) or self.controlScheme.keyDown(SWITCH)) and self.titleScreenIsActive:
			self.titleImage.hide()
			self.titleScreenIsActive = False
		elif self.titleScreenIsActive:
			self.titleImage.setImage(GUI_PATH + "title.png")
			self.globalTime=0
		else:
			pass
	
	def calculateBarImage(self, level):
		if level == 0:
			level = "empty"
		elif level == 10:
			level = "full"
		elif level == 1:
			level = "1"
		elif level == 2:
			level = "2"
		elif level == 3:
			level = "3"
		elif level == 4:
			level = "4"
		elif level == 5:
			level = "5"
		elif level == 6:
			level = "6"
		elif level == 7:
			level = "7"
		elif level == 8:
			level = "8"
		elif level == 9:
			level = "9"
		
		return level
	
	def updateGUI(self):
		"""
		self.debugText.setText("Energy: "+str((100*self.player.energy/self.player.maxEnergy))+"%, Health: "+str((100*self.player.health/self.player.maxHealth)))
		"""
		
		self.updateIntro()
		
		if self.player.currentWeapon == AREA:
			modeImg = "mode-area"
		elif self.player.currentWeapon == NARROW:
			modeImg = "mode-narrow"
		
		energyLevel = self.calculateBarImage((100 * (self.player.energy / self.player.maxEnergy)) // 10)
		self.energyBarImage.setImage(GUI_PATH + "energy-bar-" + energyLevel + ".png")
		self.energyBarImage.setTransparency(1)
		
		self.attackModeImage.setImage(GUI_PATH + modeImg + ".png")
		self.attackModeImage.setTransparency(1)
		
		healthLevel = self.calculateBarImage((100 * (self.player.health / self.player.maxHealth)) // 10)
		self.healthBarImage.setImage(GUI_PATH + "health-bar-" + healthLevel + ".png")
		self.healthBarImage.setTransparency(1)
	
	def updateIntro(self):
		modifiedTime = self.globalTime/5
		
		if self.introText is None:
			pass
		elif modifiedTime>=14300 and self.introText is not None:
			self.iTextNodePath.removeNode()
			self.introText = None
		elif modifiedTime<300:		#0-300
			self.introText.setText("Hey are you receiving?")
		elif modifiedTime<800:	#300-800
			self.introText.setText("We recently uncovered the location of an old cruiser wreck from the war.")
		elif modifiedTime<1500:	#800-1500
			self.introText.setText("You're gonna go in there and get the little bits of it that are still worth salvaging.")
		elif modifiedTime<2900:	#1500-2900
			self.introText.setText("Be aware though, this job may not be quite as simple as a grab-and-run. The coordinates have been leaked to some of our old enemies.")
		elif modifiedTime<4200:	#2900-4200
			self.introText.setText("To give you an edge, we've made a few upgrades to your electromagnetic grapple.")
		elif modifiedTime<5300:	#4200-5300
			self.introText.setText("Pull enemies inwards with the right mouse button.")
			self.leftMousePath.hide()
			self.rightMousePath.show()
			self.middleMousePath.hide()
		elif modifiedTime<6400:	#5300-6400
			self.introText.setText("Push enemies away with the left mouse button.")
			self.leftMousePath.show()
			self.rightMousePath.hide()
			self.middleMousePath.hide()
		elif modifiedTime<8500:	#6400-8500
			self.introText.setText("Toggle between your range and narrow electromagnet with the middle mouse button (or spacebar).")
			self.leftMousePath.hide()
			self.rightMousePath.hide()
			self.middleMousePath.show()
		elif modifiedTime<13300:	#8500-13300
			self.introText.setText("You can give a solid kick to anything straight in front of you or just push everything around you away. Try and throw 'em into each other or other wreckage to finish 'em off for good.")
			self.leftMousePath.hide()
			self.rightMousePath.hide()
			self.middleMousePath.hide()
		elif modifiedTime<14300:	#13300-14300
			self.introText.setText("After all, the more salvage left over, the better. Out.")
	
	def loadLevelGeom(self, filename):
		filename = os.path.abspath(filename)
		if not os.path.isfile(filename):
			print "FILE DOES NOT EXIST:"
			exit(1)
		
		#get the lines from the file
		textFileList = open(filename, 'r').readlines()
		
		if len(textFileList) < 1:
			print "FATAL ERROR READING FILE"
			exit(1)
			
		#now split each line into lists
		
		
		for num, val in enumerate(textFileList):
			val = val.rstrip('\n')#strip the newlines
			val = val.strip()
			textFileList[num] = val.split(TEXT_DELIMITER)
		
		
		obstacle = None
		
		for list in textFileList: #go through the list
			if list[0] == TERRAIN_OUTER:#do all the things for the terrain
				#choose the model
				modelVal = list[1]
				modelVal = (MODELS_PATH + modelVal)
				
				self.environment = self.loader.loadModel(modelVal)
				
				self.environment.reparentTo(self.render)
				
				#get the collision geometry for the environment
				#and move it up a bit to allow the character to float above the crater
				self.craterCollision = self.environment.find("**/craterCollisionPlane")
				self.craterCollision.setZ(self.environment.getZ() + 0.15)
				self.environment.setCollideMask(BitMask32.allOff())
				self.craterCollision.setCollideMask(BitMask32(TERRAIN_RAY_MASK))
				
				#self.environment.find( #.find("craterCollisionPlane").setZ(self.environment.getZ() + 10)
				
				#set scale
				scaleVal = list[2].split(',')#split by commas
				self.environment.setScale(float(scaleVal[0]), float(scaleVal[1]), float(scaleVal[2]))
				#set location
				locVal = list[3].split(',')
				self.environment.setPos(float(locVal[0]), float(locVal[1]), float(locVal[2]))#then we have our terrain
				#set rotation
				hprVal = list[4].split(',')
				self.environment.setHpr(float(hprVal[0]), float(hprVal[1]), float(hprVal[2]))
				
				
			elif list[0] == TERRAIN_CUBE:
				#choose the model
				modelVal = list[1]
				modelVal = (MODELS_PATH + modelVal)
				#load the model
				obstacle = self.loader.loadModel(modelVal)
				
				obstacle.reparentTo(render)
				#set scale
				scaleVal = list[2].split(',')
				obstacle.setScale(float(scaleVal[0]), float(scaleVal[1]), float(scaleVal[2]))
				#set location
				locVal = list[3].split(',')
				obstacle.setPos(float(locVal[0]), float(locVal[1]), float(locVal[2]))#the we have our object
				hprVal = list[4].split(',')
				obstacle.setHpr(float(hprVal[0]), float(hprVal[1]), float(hprVal[2]))
				
				#set up collisions
				unitCollision = obstacle.find("**/CubeBlock")
				unitCollision.node().setName("cube")
				obstacle.setCollideMask(BitMask32.allOff())
				unitCollision.setCollideMask(BitMask32(PLAYER_ENEMY_OBJECTS))
				
				self.obstacles.append(obstacle)
				
			elif list[0] == TERRAIN_WING:
				modelVal = list[1]
				modelVal = (MODELS_PATH + modelVal)
				#load the model
				obstacle = self.loader.loadModel(modelVal)
				
				obstacle.reparentTo(render)
				#set scale
				scaleVal = list[2].split(',')
				obstacle.setScale(float(scaleVal[0]), float(scaleVal[1]), float(scaleVal[2]))
				#set location
				locVal = list[3].split(',')
				obstacle.setPos(float(locVal[0]), float(locVal[1]), float(locVal[2]))#the we have our object
				hprVal = list[4].split(',')
				obstacle.setHpr(float(hprVal[0]), float(hprVal[1]), float(hprVal[2]))
				
				#set up collisions
				unitCollision = obstacle.find("**/wingCollider")
				unitCollision.node().setName("wing")
				obstacle.setCollideMask(BitMask32.allOff())
				unitCollision.setCollideMask(BitMask32(PLAYER_ENEMY_OBJECTS))
				
				self.obstacles.append(obstacle)
				
			elif list[0] == TERRAIN_BAR:
				modelVal = list[1]
				modelVal = (MODELS_PATH + modelVal)
				#load the model
				obstacle = self.loader.loadModel(modelVal)
				
				obstacle.reparentTo(render)
				#set scale
				scaleVal = list[2].split(',')
				obstacle.setScale(float(scaleVal[0]), float(scaleVal[1]), float(scaleVal[2]))
				#set location
				locVal = list[3].split(',')
				obstacle.setPos(float(locVal[0]), float(locVal[1]), float(locVal[2]))#the we have our object
				hprVal = list[4].split(',')
				obstacle.setHpr(float(hprVal[0]), float(hprVal[1]), float(hprVal[2]))
				
				#set up collisions
				unitCollision = obstacle.find("**/metalBarCollisionCube")
				unitCollision.node().setName("bar")
				obstacle.setCollideMask(BitMask32.allOff())
				unitCollision.setCollideMask(BitMask32(PLAYER_ENEMY_OBJECTS))
				
			elif list[0] == TERRAIN_SHARDS:
				modelVal = list[1]
				modelVal = (MODELS_PATH + modelVal)
				#load the model
				obstacle = self.loader.loadModel(modelVal)
				
				obstacle.reparentTo(render)
				#set scale
				scaleVal = list[2].split(',')
				obstacle.setScale(float(scaleVal[0]), float(scaleVal[1]), float(scaleVal[2]))
				#set location
				locVal = list[3].split(',')
				obstacle.setPos(float(locVal[0]), float(locVal[1]), float(locVal[2]))#the we have our object
				hprVal = list[4].split(',')
				obstacle.setHpr(float(hprVal[0]), float(hprVal[1]), float(hprVal[2]))
				
				#set up collisions
				unitCollision = obstacle.find("**/metalShardCollisionCube")
				unitCollision.node().setName("shard")
				obstacle.setCollideMask(BitMask32.allOff())
				unitCollision.setCollideMask(BitMask32(PLAYER_ENEMY_OBJECTS))
				
			else:
				print "FATAL ERROR READING FILE"
				exit(1)
			
		pass
		
	def loadLevelEnemies(self, filename):
		filename = os.path.abspath(filename)
		if not os.path.isfile(filename):
			print "FILE DOES NOT EXIST:"
			exit(1)
		
		#get the lines from the file and split them
		textFileList = open(filename, 'r').readlines()
		if len(textFileList) < 1:
			print "FATAL ERROR READING FILE"
			exit(1)
		
		for num, val in enumerate(textFileList):
			val = val.rstrip('\n')#strip the newlines
			val = val.strip()
			textFileList[num] = val.split(TEXT_DELIMITER)
		
		currwave = dict()
		currwave["time"] = None
		currwave["enemies"] = []
		currEnem = dict()
		
		for val in textFileList:
			if val[0] == BEGIN_WAVE:
				currwave = dict()
				currwave["time"] = float(val[1])#set your time
				currwave["enemies"] = []
			elif val[0] == RUSH_ENEMY:
				currEnem = dict()
				pos = []
				pos = val[1].split(',')#get the three values for spawning, not floats
				currEnem["type"] = RUSH_ENEMY
				currEnem["xVal"] = float(pos[0])
				currEnem["yVal"] = float(pos[1])
				currEnem["zVal"] = float(pos[2])
				currwave["enemies"].append(dict(currEnem))#copy
			elif val[0] == DRONE_ENEMY:
				currEnem = dict()
				pos = []
				pos = val[1].split(',')#get the three values for spawning, not floats
				currEnem["type"] = DRONE_ENEMY
				currEnem["xVal"] = float(pos[0])
				currEnem["yVal"] = float(pos[1])
				currEnem["zVal"] = float(pos[2])
				currwave["enemies"].append(dict(currEnem))#copy
			elif val[0] == SHOOTING_ENEMY:
				currEnem = dict()
				pos = []
				pos = val[1].split(',')#get the three values for spawning, not floats
				currEnem["type"] = SHOOTING_ENEMY
				currEnem["xVal"] = float(pos[0])
				currEnem["yVal"] = float(pos[1])
				currEnem["zVal"] = float(pos[2])
				currwave["enemies"].append(dict(currEnem))#copy
			elif val[0] == END_WAVE:#then we are done with that wave
				self.eSpawnList.append(dict(currwave))#copy
			else:
				pass#then something was stupid
			
		#now sort your waves with lowest time first	
		self.eSpawnList.sort(key = lambda object: object["time"])
		#and you're done
	
	def updateGame(self, task):
		
		if not self.titleScreenIsActive:
			self.globalTime = self.globalTime + task.time
			elapsedTime = task.time - self.previousFrameTime
			#base.resetPrevTransform(render)#for our high intensity collision detection
		
		if self.controlScheme.keyDown(QUIT):
			exit(0)
		
		if not self.paused and not self.titleScreenIsActive:
			time = elapsedTime
			while time > 0.02:
				self.updateGameComponents(0.02)
				time -= 0.02
			self.updateGameComponents(time)
			
			self.cTrav.traverse(render)
			
			self.spawnEnemies()#globalTime is available
		if self.controlScheme.keyDown(PAUSE):
			if not self.pauseWasPressed:
				self.paused = not self.paused
				self.controlScheme.resetMouse()
				self.pauseWasPressed = True
		else:
			self.pauseWasPressed = False
		
		self.updateGUI()
		self.updateTitleScreen()
		
		self.previousFrameTime = task.time
		
		return task.cont
	
	def updateGameComponents(self, time):
		'''
		Updates the state of the world.
		@precondition: The game isn't paused. 
		'''
		self.updateCamera(time)
		for enemy in self.enemies:
			enemy.update(time)
		for projectile in self.projectiles:
			projectile.update(time)
			
		#check for basic terrain collisions
		self.player.terrainCollisionCheck()
		self.player.update(time)
		for enemy in self.enemies:
			enemy.terrainCollisionCheck()
		for projectile in self.projectiles:
			projectile.terrainCollisionCheck()
		
	def spawnEnemies(self):#now we spawn our enemies
		while((len(self.eSpawnList) > 0) and self.eSpawnList[0]["time"] < self.globalTime):
			for val in self.eSpawnList[0]["enemies"]:
				if val["type"] == RUSH_ENEMY:
					#add an enemy
					tempEnemy = RushEnemy(self, val["xVal"], val["yVal"], val["zVal"])
					self.configureEnemy(tempEnemy)
				elif val["type"] == DRONE_ENEMY:
					#add an enemy
					tempEnemy = DroneEnemy(self, self.player, val["xVal"], val["yVal"], val["zVal"])
					self.configureEnemy(tempEnemy)
				elif val["type"] == SHOOTING_ENEMY:
					#add an enemy
					tempEnemy = ShootingEnemy(self, val["xVal"], val["yVal"], val["zVal"])
					self.configureEnemy(tempEnemy)
				else: 
					pass
				
			del self.eSpawnList[0]#del
			
	
	def configureEnemy(self, tempEnemy):#after making an enemy configure it for the game
		numString = str(self.nextEnemy)
		tempEnemy.setName("enemy" + numString)
		tempEnemy.reparentTo(self.unitNodePath)
		tempEnemy.nodePath = self.render.find("enemy1")
		self.actors["enemy" + numString] = tempEnemy
		self.nextEnemy = self.nextEnemy + 1
		self.enemies.append(tempEnemy)
		
	
	def rotateCamera(self):
		if self.controlScheme.mouseX > self.winProps.getXSize():
			self.camera.setH(-(self.winProps.getXSize() - 20) * 0.5)
		else:
			self.camera.setH(-self.controlScheme.mouseX * 0.5)
	
	def updateCamera(self, elapsedTime):
		#update the camera's heading based on the mouse's x position
		if self.controlScheme.recheckMouse():
			self.camera.setH(-self.controlScheme.mouseX * 0.5)
		else:
			self.rotateCamera()
		
		#update the camera's pitch and vertical position based on the mouse's y position
		self.cameraVOffset = min(self.screenHeight, max(0, self.controlScheme.mouseY)) / self.screenHeight * 25 + 4
		self.cameraHOffset = self.cameraVOffset * 0.8 + 30
		self.camera.setP(atan2(-self.cameraVOffset * 0.7, self.cameraHOffset) \
							* 180 / pi)
		
		#update the camera to point at the player
		self.camera.setPos(self.player.getX() + self.cameraHOffset * sin(self.camera.getH() * pi / 180),
						   self.player.getY() - self.cameraHOffset * cos(self.camera.getH() * pi / 180),
						   self.player.getZ() + 0.3 + self.cameraVOffset)
	
	def selectTarget(self):
		"""Finds the closest shootable object and returns it"""

		#traverse all objects in render
		self.mPickerTraverser.traverse(self.unitNodePath)

		if (self.mCollisionQue.getNumEntries() > 0):
			self.mCollisionQue.sortEntries()
			for i in range(0, self.mCollisionQue.getNumEntries()):
				entry = self.mCollisionQue.getEntry(i)
				pickedObj = entry.getIntoNodePath()
				
				if not pickedObj.isEmpty():
				
					name = pickedObj.getParent().getName()
					
					if name == "render":
						return None
					
					#if the object is shootable, set it as the target
					try:
						if self.actors[name].shootable:
							return self.actors[name]
					except:
						continue
		
		return None
	
	def setupTargeting(self):
		"""Set up the collisions necessary to target enemies and other objects"""
		
		#Since we are using collision detection to do picking, we set it up 
		#any other collision detection system with a traverser and a handler
		self.mPickerTraverser = CollisionTraverser()            #Make a traverser
		#self.mPickerTraverser.showCollisions(self.unitNodePath)
		self.mCollisionQue = CollisionHandlerQueue()

		#create a collision solid ray to detect against
		self.mPickRay = CollisionRay()
		self.mPickRay.setOrigin(self.player.getPos(self.render))
		self.mPickRay.setDirection(self.render.getRelativeVector(self.player, Vec3(0, 1, 0)))
		self.mPickRay2 = CollisionRay()
		self.mPickRay2.setOrigin(self.player.getPos(self.render))
		self.mPickRay2.setDirection(self.render.getRelativeVector(self.player, Vec3(0.06, 1, 0)))
		self.mPickRay3 = CollisionRay()
		self.mPickRay3.setOrigin(self.player.getPos(self.render))
		self.mPickRay3.setDirection(self.render.getRelativeVector(self.player, Vec3(-0.06, 1, 0)))
		self.mPickRay4 = CollisionRay()
		self.mPickRay4.setOrigin(self.player.getPos(self.render))
		self.mPickRay4.setDirection(self.render.getRelativeVector(self.player, Vec3(0, 1, 0.06)))
		self.mPickRay5 = CollisionRay()
		self.mPickRay5.setOrigin(self.player.getPos(self.render))
		self.mPickRay5.setDirection(self.render.getRelativeVector(self.player, Vec3(0, 1, -0.06)))

		#create our collison Node to hold the ray
		self.mPickNode = CollisionNode('pickRay')
		self.mPickNode.setIntoCollideMask(BitMask32.allOff())
		self.mPickNode.addSolid(self.mPickRay)
		self.mPickNode2 = CollisionNode('pickRay2')
		self.mPickNode2.setIntoCollideMask(BitMask32.allOff())
		self.mPickNode2.addSolid(self.mPickRay2)
		self.mPickNode3 = CollisionNode('pickRay3')
		self.mPickNode3.setIntoCollideMask(BitMask32.allOff())
		self.mPickNode3.addSolid(self.mPickRay3)
		self.mPickNode4 = CollisionNode('pickRay4')
		self.mPickNode4.setIntoCollideMask(BitMask32.allOff())
		self.mPickNode4.addSolid(self.mPickRay4)
		self.mPickNode5 = CollisionNode('pickRay5')
		self.mPickNode5.setIntoCollideMask(BitMask32.allOff())
		self.mPickNode5.addSolid(self.mPickRay5)

		#Attach that node to the player since the ray will need to be positioned
		#relative to it, returns a new nodepath		
		#well use the default geometry mask
		#this is inefficent but its for mouse picking only

		self.mPickNP = self.player.attachNewNode(self.mPickNode)
		self.mPickNP2 = self.player.attachNewNode(self.mPickNode2)
		self.mPickNP3 = self.player.attachNewNode(self.mPickNode3)
		self.mPickNP4 = self.player.attachNewNode(self.mPickNode4)
		self.mPickNP5 = self.player.attachNewNode(self.mPickNode5)

		#well use what panda calls the "from" node.  This is really a silly convention
		#but from nodes are nodes that are active, while into nodes are usually passive environments
		#this isnt a hard rule, but following it usually reduces processing

		#Everything to be picked will use bit 1. This way if we were doing other
		#collision we could seperate it, we use bitmasks to determine what we check other objects against
		#if they dont have a bitmask for bit 1 well skip them!
		#self.mPickNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
		self.mPickNode.setFromCollideMask(PLAYER_ENEMY_OBJECTS)
		self.mPickNode2.setFromCollideMask(PLAYER_ENEMY_OBJECTS)
		self.mPickNode3.setFromCollideMask(PLAYER_ENEMY_OBJECTS)
		self.mPickNode4.setFromCollideMask(PLAYER_ENEMY_OBJECTS)
		self.mPickNode5.setFromCollideMask(PLAYER_ENEMY_OBJECTS)

		#Register the ray as something that can cause collisions
		self.mPickerTraverser.addCollider(self.mPickNP, self.mCollisionQue)
		self.mPickerTraverser.addCollider(self.mPickNP2, self.mCollisionQue)
		self.mPickerTraverser.addCollider(self.mPickNP3, self.mCollisionQue)
		self.mPickerTraverser.addCollider(self.mPickNP4, self.mCollisionQue)
		self.mPickerTraverser.addCollider(self.mPickNP5, self.mCollisionQue)
	
	def handleUnitIntoCollision(self, entry):
		try:
			fromName = entry.getFromNodePath().getParent().getName()
			intoName = entry.getIntoNodePath().getParent().getName()
			Unit.collideWithUnit(self.actors[intoName], self.actors[fromName])
			if (fromName == "player" or intoName == "player") and self.collisionSound.status() is not self.collisionSound.PLAYING:
				self.collisionSound.play()
		except:
			pass
	
	def handleUnitOutCollision(self, entry):
		pass
	
	def handleWingIntoCollision(self, entry):
		fromName = entry.getFromNodePath().getParent().getName()
		Unit.collideWithObstacle(self.actors[fromName])
		if fromName == "player" and self.collisionSound.status() is not self.collisionSound.PLAYING:
			self.collisionSound.play()
	
	def handleCubeIntoCollision(self, entry):
		try:
			fromName = entry.getFromNodePath().getParent().getName()
			Unit.collideWithObstacle(self.actors[fromName])
			if fromName == "player" and self.collisionSound.status() is not self.collisionSound.PLAYING:
				self.collisionSound.play()
		except:
			pass
	
	def handleBarIntoCollision(self, entry):
		fromName = entry.getFromNodePath().getParent().getName()
		Unit.collideWithObstacle(self.actors[fromName])
		if fromName == "player" and self.collisionSound.status() is not self.collisionSound.PLAYING:
			self.collisionSound.play()
	
	def gameOver(self):
		pass