class QuestGame(object):
    """ This class is a basic game.

    This class will load data, create a pyscroll group, a hero object.
    It also reads input and moves the Hero around the map.
    Finally, it uses a pyscroll group to render the map and Hero.
    """
    filename = get_map(MAP_FILENAME)

    def __init__(self):

        # true while running
        self.running = False

        # load data from pytmx
        tmx_data = pytmx.load_pygame(self.filename)

        # setup level geometry with simple pygame rects, loaded from pytmx
        self.walls = list()
        for object in tmx_data.objects:
            self.walls.append(pygame.Rect(
                object.x, object.y,
                object.width, object.height))

        # create new data source for pyscroll
        map_data = pyscroll.data.TiledMapData(tmx_data)

        w, h = screen.get_size()

        # create new renderer (camera)
        # clamp_camera is used to prevent the map from scrolling past the edge
        self.map_layer = pyscroll.BufferedRenderer(map_data,
                                                   (w / 2, h / 2),
                                                   clamp_camera=True)

        # pyscroll supports layered rendering.  our map has 3 'under' layers
        # layers begin with 0, so the layers are 0, 1, and 2.
        # since we want the sprite to be on top of layer 1, we set the default
        # layer for sprites as 1
        self.group = PyscrollGroup(map_layer=self.map_layer,
                                   default_layer=2)

        self.hero = Hero()

        # put the hero in the center of the map
        self.hero.position = self.map_layer.rect.center

        # add our hero to the group
        self.group.add(self.hero)

    def draw(self, surface):

        # center the map/screen on our Hero
        self.group.center(self.hero.rect.center)

        # draw the map and all sprites
        self.group.draw(surface)

    def handle_input(self):
        """ Handle pygame input events
        """
        event = pygame.event.poll()
        while event:
            if event.type == QUIT:
                self.running = False
                break

            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    self.running = False
                    break

            # this will be handled if the window is resized
            elif event.type == VIDEORESIZE:
                init_screen(event.w, event.h)
                self.map_layer.set_size((event.w / 2, event.h / 2))

            event = pygame.event.poll()

        # using get_pressed is slightly less accurate than testing for events
        # but is much easier to use.
        pressed = pygame.key.get_pressed()
        if pressed[K_UP]:
            self.hero.velocity[1] = -HERO_MOVE_SPEED
        elif pressed[K_DOWN]:
            self.hero.velocity[1] = HERO_MOVE_SPEED
        else:
            self.hero.velocity[1] = 0

        if pressed[K_LEFT]:
            self.hero.velocity[0] = -HERO_MOVE_SPEED
        elif pressed[K_RIGHT]:
            self.hero.velocity[0] = HERO_MOVE_SPEED
        else:
            self.hero.velocity[0] = 0

    def update(self, dt):
        """ Tasks that occur over time should be handled here
        """
        self.group.update(dt)

        # check if the sprite's feet are colliding with wall
        # sprite must have a rect called feet, and move_back method,
        # otherwise this will fail
        for sprite in self.group.sprites():
            if sprite.feet.collidelist(self.walls) > -1:
                sprite.move_back(dt)

    def run(self):
        """ Run the game loop
        """
        clock = pygame.time.Clock()
        fps = 60
        scale = pygame.transform.scale
        self.running = True

        try:
            while self.running:
                dt = clock.tick(fps) / 1000.

                self.handle_input()
                self.update(dt)
                self.draw(temp_surface)
                scale(temp_surface, screen.get_size(), screen)
                pygame.display.flip()

        except KeyboardInterrupt:
            self.running = False
Exemple #2
0
class Game(object):
	#game Main entry point. handles intialization of game and graphics.    
	filename = get_map('outdoor_main.tmx')
	done = False

	def __init__(self): 

		self.PLAYER_MOVE_SPEED = 200
		self.screen = init_screen(800, 600)

		#load data from pytmx
		self.tmx_data = pytmx.load_pygame(self.filename)

		w, h = self.screen.get_size()

		#create new data source for pyscroll
		map_data = pyscroll.data.TiledMapData(self.tmx_data)

		self.map_layer = pyscroll.BufferedRenderer(map_data, (w / 2, h / 2), clamp_camera=True)

		self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=0)

		#setup level with pygame rects
		self.blockers = list()
		#self.enemies = dict()
		#self.index = 0
		for object in self.tmx_data.objects:

			if "blockers" in object.properties:
				if object.properties["blockers"] == "1":
					self.blockers.append(pygame.Rect(object.x, object.y, object.width, object.height))
			if object.name == "playerStart":
				self.playerStart = pygame.Rect(object.x, object.y, object.width, object.height)
			if object.name == "enemy":
				self.group.add(Enemy((object.x, object.y)))
				#self.enemies[self.index] = pygame.Rect(object.x, object.y, object.width, object.height)
				#self.index = self.index + 1
				self.blockers.append(pygame.Rect(object.x, object.y, object.width, object.height))

		self.player = Player()

		# put the hero in the center of the map
		self.player.position = [self.playerStart.x, self.playerStart.y]
		# add our hero to the group
		self.group.add(self.player)

		self.temp_surface = pygame.Surface((w / 2, h / 2)).convert()

	def draw(self, surface):

		#center map / screen on player
		self.group.center(self.player.rect.center)

		#draw the map and all sprites
		self.group.draw(surface)

	def handle_events(self):
		#handles input events
		event = pygame.event.poll()

		while event:            
			if event.type == pygame.QUIT: 
				self.done = True
				break

			elif event.type == KEYDOWN:
			# exit on Escape
				if event.key == K_ESCAPE: 
					self.done = True
					break
			event = pygame.event.poll()

		pressed = pygame.key.get_pressed()
		if pressed[K_SPACE]:
			self.group.add(Magic(self.player.position, self.player.direction, self.blockers))
		if pressed[K_UP]:
			self.player.velocity[1] = -self.PLAYER_MOVE_SPEED
			self.player.direction = 1
		elif pressed[K_DOWN]:
			self.player.velocity[1] = self.PLAYER_MOVE_SPEED
			self.player.direction = 2
		else:
			self.player.velocity[1] = 0
			#print "self.player.velocity[1]: %s"%(self.player.velocity[1])

		if pressed[K_LEFT]:
			self.player.velocity[0] = -self.PLAYER_MOVE_SPEED
			self.player.direction = 3
		elif pressed[K_RIGHT]:
			self.player.velocity[0] = self.PLAYER_MOVE_SPEED
			self.player.direction = 4
		else:
			self.player.velocity[0] = 0



	def update(self, dt):
		self.group.update(dt)

		for sprite in self.group.sprites():
			if sprite.rect.collidelist(self.blockers) > -1:
				sprite.move_back(dt)

	def main_loop(self):
		#Game() main loop 
		clock = pygame.time.Clock()
		fps = 60
		scale = pygame.transform.scale  
		done  = False 
		try:  
			while not self.done:
				# get key input, move, draw.
				dt = clock.tick(fps) / 1000.
				
				self.handle_events()
				self.update(dt)
				self.draw(self.temp_surface)
				scale(self.temp_surface, self.screen.get_size(), self.screen)
				pygame.display.flip()

		except KeyboardInterrupt:
			self.done = True