Exemplo n.º 1
0
class SpaceHogs(pyglet.window.Window):
    def __init__(self):
        super(SpaceHogs, self).__init__(caption='Space Hogs', width=settings.WINDOW_WIDTH, height=settings.WINDOW_HEIGHT)
        
        pyglet.resource.path.append('data')
        pyglet.resource.reindex()
        
        self.batch = pyglet.graphics.Batch()
        
        self.player = Player(batch=self.batch)
        self.push_handlers(self.player)
        
        pyglet.clock.schedule_interval(self.update, float(1)/60)
    
    def run(self):
        pyglet.app.run()
    
    def update(self, dt):
        self.player.update(dt)
        for bullet in BULLETS[:]:
            bullet.update(dt)
    
    def on_draw(self):
        self.clear()
        self.batch.draw()
Exemplo n.º 2
0
    def __init__(self, view):
        self.clock = pg.time.Clock()
        self.view = view
        glEnable(GL_DEPTH_TEST)

        self.ADDENEMY = pg.USEREVENT + 1  # pylint: disable=no-member
        pg.time.set_timer(self.ADDENEMY, randint(500, 750))
        self.NEWTORNADO = pg.USEREVENT + 2  # pylint: disable=no-member
        pg.time.set_timer(self.NEWTORNADO, randint(5000, 20000))

        self.enemies = []
        self.splats = []
        self.splats_collect = []
        self.bullets = []
        self.tornados = []
        self.all_sprites = []
        self.player = Player()
        self.splat_count = [0]

        self.background = Background(desert_road_png)
        self.loot_button = Hud_Button(treasure_png, (-.85, -.8))
        self.loot = ui.Window('Loot', self.splat_count, self.view, self.player)
        self.loot.paint_select[0].active = True
        self.loot.paint_select[0].owned = True

        self.isRunning = True
Exemplo n.º 3
0
 def new(self):
     # initialize all variables and do all the setup for a new game
     self.all_sprites = pg.sprite.Group()
     self.walls = pg.sprite.Group()
     self.player = Player(self, 10, 10)
     for x in range(10,20):
     	Wall(self,x,5)
Exemplo n.º 4
0
 def __init__(self):
     pg.init()  # initialize pygame module
     pg.font.init()
     print(
         "Tic-tac-toe Mini-max algorithm project @ weronikaolejniczak.github.com \n"
     )
     self.font = pg.font.Font("resources/fonts/{}".format(settings.FONT),
                              50)
     self.WIDTH = settings.WIDTH
     self.HEIGHT = settings.HEIGHT
     self.size = (self.WIDTH, self.HEIGHT)
     self.TILEMAP = [[0 for x in range(3)] for y in range(3)]
     self.screen = pg.display.set_mode(
         self.size)  # create an instance of the pygame.Surface class
     pg.display.set_icon(favicon)
     pg.display.set_caption("Tic-tac-toe")  # set the caption of our window
     self.clock = pg.time.Clock()  # create an instance of Clock class
     self.FPS = settings.FPS
     self.start_time = 0
     self.end_time = 0
     self.all_sprites = pg.sprite.Group()
     self.playing = True
     self.dt = 0
     self.turn = "AI"
     self.human = Player(self, "human")
     self.AI = Player(self, "AI")
     self.is_human_turn = False
     self.winner = ""
     self.start = None
     self.end = None
     self.orientation = ""
Exemplo n.º 5
0
 def start_game(self):
     self.all_sprites = pygame.sprite.Group()
     self.fruits = pygame.sprite.Group()
     self.player = Player(self, 10, 10)
     self.fruit = Fruit(self)
     self.score = 0
     self.run()
Exemplo n.º 6
0
    def new(self):
        """Start a new game.
        """

        # keeping track of missions
        self.vaccines_collected = 0
        self.enemies_killed = 0
        self.n_bullets = 20  # initial number of bullets for the player

        self.failed = False

        # used for checking if player completed game
        self.platforms_crossed = 0

        # initialize sprite groups
        self.all_sprites = pygame.sprite.LayeredUpdates()
        self.platforms = pygame.sprite.Group()
        self.powerups = pygame.sprite.Group()
        self.enemies = pygame.sprite.Group()
        self.viruses = pygame.sprite.Group()
        self.bullets = pygame.sprite.Group()
        self.clouds = pygame.sprite.Group()

        # load bg image
        self.bg_image = BackGround(self)

        if self.level > 1:  # needed for scrolling background
            self.bg_image_2 = BackGround(self)
            self.bg_image_2.rect.left = self.bg_image.rect.right

        # create new instance of player
        self.player = Player(self)

        # timer for spawning enemies
        self.slime_timer = 0
        self.bat_timer = 0

        # creating base
        self.bases = []
        base = Base(self, 0)
        self.bases.append(base)
        while base.rect.right < s.WIDTH:
            base = Base(self, base.rect.right)
            self.bases.append(base)

        # creating starting platforms
        for plat in s.PLATFORM_START_LIST:
            Platform(self, *plat)

        # create clouds/other images
        if self.level == 1:
            for i in range(5):
                c = Cloud(self)
                c.rect.x -= random.randrange(200, 400, 50)

        # load music
        pygame.mixer.music.load(os.path.join(self.sound_dir, "background.ogg"))

        self.run()
Exemplo n.º 7
0
    def __init__(self):
        pygame.init()
        pygame.display.set_caption(GAME_TITLE)
        self.screen = pygame.display.set_mode([WIDTH, HEIGHT])
        self.clock = pygame.time.Clock()
        self.playing = False
        self.load_data()

        self.player = Player(self, self.map.player_entry_point)
Exemplo n.º 8
0
    def load_data(self):
        self.all_sprites = pygame.sprite.Group()
        self.walls = pygame.sprite.Group()

        self.map = Map()
        self.map.load_from_file('map.txt')
        self.map.create_sprites_from_map_data(self)

        self.player = Player(self, self.map.player_entry_point)
Exemplo n.º 9
0
    def create_sprites(self):
        self.entities = pygame.sprite.Group()

        self.bg = pygame.image.load(self.bg_path).convert()
        self.bg = pygame.transform.smoothscale(self.bg, self.MAP_SIZE)
        self.bg_rect = self.bg.get_rect()

        self.player = Player(self)
        self.entities.add(self.player)
Exemplo n.º 10
0
def init_round():
    events.players.append(Player('p1', 400, 100, 10))
    events.players.append(Player('p2', 430, 300, 10))
    events.p1_group.add(events.players[0])
    events.p2_group.add(events.players[1])
    all_sprites.add(events.players)
    events.running = True
    events.bars.append(HPBar(200, 886))
    events.bars.append(HPBar(570, 886))
    all_sprites.add(events.bars)
Exemplo n.º 11
0
 def new(self):
     self.all_sprites = pg.sprite.Group()
     self.platforms = pg.sprite.Group()
     self.player = Player(self)
     self.all_sprites.add(self.player)
     for plat in PLATFORM_LIST:
         p = Platform(*plat)
         self.all_sprites.add(p)
         self.platforms.add(p)
     self.run()
Exemplo n.º 12
0
 def new(self):
     # Initialisieren und/oder Zurücksetzen
     self.all_sprites = pg.sprite.Group()
     self.blocks = pg.sprite.Group()
     self.player = Player(w)
     self.all_sprites.add(self.player)
     for block in s.BLOCKS_LIST:
         b = Block(*block)
         self.all_sprites.add(b)
         self.blocks.add(b)
     self.run()
Exemplo n.º 13
0
class GameScene:

    def __init__(self):
        self.player1 = Player(color=(255, 255, 255), x=random.randint(0, cfg.board_size), y=random.randint(0, cfg.board_size))
        self.player2 = Player(color=(0, 0, 0), x=random.randint(0, cfg.board_size), y=random.randint(0, cfg.board_size))

        self.tiles = {}
        for x, y in itertools.product(range(0, cfg.board_size), range(0, cfg.board_size)):
            self.tiles[x, y] = Tile(x=x, y=y, color=random.choice(cfg.themes))

        self.keyboard_inputs = {
            K_ESCAPE: (pygame.quit,),
            K_UP: (self.player1.move, 0, -1),
            K_DOWN: (self.player1.move, 0, 1),
            K_LEFT: (self.player1.move, -1, 0),
            K_RIGHT: (self.player1.move, 1, 0),
            K_RSHIFT: (self.player1.bomb, self.tiles, self.player2),
            K_w: (self.player2.move, 0, -1),
            K_s: (self.player2.move, 0, 1),
            K_a: (self.player2.move, -1, 0),
            K_d: (self.player2.move, 1, 0),
            K_LSHIFT: (self.player2.bomb, self.tiles, self.player1),
        }

    def draw(self, screen):
        # Draw the player to the screen
        screen.fill((0, 200, 0))

        for tile in self.tiles.values():
            tile.draw(screen)
        self.player1.draw(screen)
        self.player2.draw(screen)

        pygame.display.flip()

    def run(self, screen):
        while True:
            # for loop through the event queue
            for event in pygame.event.get():

                if event.type == KEYDOWN:
                    try:
                        action, *args = self.keyboard_inputs[event.key]
                        action(*args)
                    except KeyError:
                        pass
                elif event.type == QUIT:
                    pygame.quit()

            for num, player in enumerate([self.player1, self.player2]):
                if player.check_if_won():
                    return

            self.draw(screen)
Exemplo n.º 14
0
	def __init__(self, title, splat_count, view, player):
		self.clock = pg.time.Clock()
		self.view = view
		self.splat_count = splat_count

		self.background = Ui_Color((21 / 256, 26 / 256, 27 / 256, 1))
		self.background.translate(0, 0, .9)

		self.title_bar = Ui_Color((.25, .25, .25, 1))
		self.title_bar.scale(1, 1 / 15, 1)
		self.title_bar.translate(0, 1 - self.title_bar.box.uy, 0)

		self.title_text = Text(title, 'center')
		self.title_text.scale(1, .1, 1)
		self.title_text.scale(.66, .66, 1)
		self.title_text.translate(0, 1 - self.title_text.box.uy, -.1)

		self.close_button = Close_Button()

		self.paint_select = []
		for args in [
			(-.95, .78, 1, 0, 0, 1), # red
			(-.95, .64, 0, .449, 0, 1), # green
			(-.85, .78, .7245, .7245, .7245, 1), # silver
			(-.85, .64, .977, .977, 0, 1), # yellow
			(-.85, .50, 1, 0.078125, 0.703125, 1) # pink
		]:
			self.paint_select.append(Color_Button(args[:2], args[2:]))

		for args in [
			(-.95, .50, blue_squares_png),
			(-.95, .36, red_gloop_png),
			(-.85, .36, pink_bubbles_png),
			(-.95, .22, depot_png),
			(-.85, .22, fractal_png)
		]:
			self.paint_select.append(Texture_Button(*args))

		self.splat_icon = objloader.Obj(square_obj, object_vs, object_fs, splat_png)
		self.splat_icon.generate()
		self.splat_icon.set_texture(1)
		self.splat_icon.scale(.04, .06, 1)
		self.splat_icon.translate(-.9, -.9, 0)

		self.splats_number = Splats_Number(str(splat_count[0]))

		self.player = player

		self.car = Player()
		self.car.generate()
		self.car.scale(5, 3, 5)
		self.car.rotate(pi / 3, 1, 0, 0)
Exemplo n.º 15
0
 def __init__(self, game, x, y):
     pg.sprite.Sprite.__init__(self)
     Player.__init__(self, game, x, y)
     self.path = []
     self.game = game
     self.skill = 1
     self.directions = [[-1, 0], [1, 0], [0, -1], [0, 1]]
     self.random_direction = random.choice(self.directions)
     self.last_direction = [2, 2]
     self.max_steps = int(SCREEN_WIDTH / 2)
     self.steps_to_take = random.randint(TILESIZE, self.max_steps)
     self.steps_taken = 0
     self.current_state = self.explore
Exemplo n.º 16
0
    def setup(self):
        """Get game ready to play"""

        self.player_list = arcade.SpriteList()
        self.coin_list = arcade.SpriteList()
        self.bomb_list = arcade.SpriteList()
        # Set up the player
        self.player_sprite = Player(
            PLAYER_SPRITE_IMAGE,
            SPRITE_SCALING_PLAYER,
        )
        self.player_sprite.center_x = 50
        self.player_sprite.center_y = 50
        self.player_list.append(self.player_sprite)

        # Create the coins
        for i in range(COIN_COUNT):
            coin = LeftMovingCoin(COIN_SPRITE_IMAGE, COIN_SPRITE_SCALING)
            # position of each coin
            coin.center_x = random.randrange(SCREEN_WIDTH)
            coin.center_y = random.randrange(SCREEN_HEIGHT)
            # add coin to coin list
            self.coin_list.append(coin)

        # Create the bombs
        for i in range(BOMB_COUNT):
            bomb = Bomb(BOMB_SPRITE_IMAGE, BOMB_SPRITE_SCALING)
            # position of each bomb
            bomb.center_x = random.randrange(SCREEN_WIDTH)
            bomb.center_y = random.randrange(SCREEN_HEIGHT)
            # add bomb to bomb list
            self.bomb_list.append(bomb)
Exemplo n.º 17
0
    def __init__(self):
        # Init Display
        self.screen = pg.display.set_mode(
            [params.screen_width, params.screen_height], params.screen_mode)
        # Init Font
        self.font = pg.font.SysFont('Calibri', 25, True, False)

        # Init Sprite Lists
        self.block_list = pg.sprite.Group()
        self.bullet_list = pg.sprite.Group()
        self.all_sprites_list = pg.sprite.Group()
        self.ball_list = pg.sprite.Group()

        # Add Blocks and ball
        self.level = 0
        self.energy = params.energy
        self.energy_max = params.energy_max
        self.energy_reg = params.energy_reg
        self.shoot_speed = params.shoot_speed
        self.reset(50)

        # Add Player
        self.player = Player()
        self.all_sprites_list.add(self.player)
        self.player.rect.y = params.screen_height - self.player.height - 5
Exemplo n.º 18
0
    def create_player(self):
        self.tests = []
        try:
            self.debug("Creating party..")

            # spawn player
            self.player = Player(self, self.name)
            self.player.block_id = "player"
            self.entities.add( self.player )

            # choose ally bots
            bot_options = ["crystal","nathan","jack"]
            bot_options.remove(self.name.lower())

            # spawn bots
            self.bots = []
            for bot_name in bot_options:
                self.debug("Creating bot: "+bot_name)

                if bot_name == "crystal": bot = CrystalBot(self, bot_name)
                elif bot_name == "jack": bot = JackBot(self, bot_name)
                else: bot = NathanBot(self, bot_name)

                bot.rect.x = self.player.rect.x + 50
                bot.rect.y = self.player.rect.y - 50

                self.bots.append( bot )
                self.entities.add( bot )

        except Exception as e:
            self.debug("Party Creation Error: " + str(e))
Exemplo n.º 19
0
 def spawn_all_sprites(self):
     """
     Create all sprites (player and enemy) based on their initial number
     """
     self.player = Player.spawn(self)
     for _ in range(self.enemies_initial_number):
         Enemy.spawn(self)
     logging.debug('All enemies spawned')
Exemplo n.º 20
0
class Game:
    def __init__(self):
        pygame.init()
        pygame.display.set_caption(GAME_TITLE)
        self.screen = pygame.display.set_mode([WIDTH, HEIGHT])
        self.clock = pygame.time.Clock()
        self.playing = False
        self.load_data()

        self.start_game()

    def load_data(self):
        self.all_sprites = pygame.sprite.Group()
        self.walls = pygame.sprite.Group()

        self.map = Map()
        self.map.load_from_file('map.txt')
        self.map.create_sprites_from_map_data(self)

        self.player = Player(self, self.map.player_entry_point)

    def start_game(self):
        self.run()

    def run(self):
        self.playing = True
        while self.playing:
            self.dt = self.clock.tick(FPS) / 1000
            self.events()
            self.update()
            self.draw()

    def events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()

    def update(self):
        self.player.update()

    def draw(self):
        self.screen.fill(BLACK)
        self.all_sprites.draw(self.screen)
        pygame.display.flip()
Exemplo n.º 21
0
    def create_sprites(self):
        self.entities = pygame.sprite.Group()

        self.bg = pygame.image.load(self.bg_path).convert()
        self.bg = pygame.transform.smoothscale(self.bg, self.MAP_SIZE)
        self.bg_rect = self.bg.get_rect()

        self.player = Player(self)
        self.entities.add( self.player )
Exemplo n.º 22
0
    def __init__(self):
        pygame.init()
        self.screen = pygame.display.set_mode([WIDTH,HEIGHT])
        pygame.display.set_caption(TITLE)
        self.clock = pygame.time.Clock()

        self.all_sprites = pygame.sprite.Group()
        for _ in range(32):
            Player(self, 10, 10)
Exemplo n.º 23
0
    def __init__(self):
        pygame.init()

        #SCREEN
        self.screen = pygame.display.set_mode([WIDTH, HEIGHT])
        pygame.display.set_caption("Snakipy")
        self.clock = pygame.time.Clock()

        self.all_sprites = pygame.sprite.Group()
        self.fruits = pygame.sprite.Group()

        self.player = Player(self, 10, 10)
        self.fruit = Fruit(self)

        self.large_font = pygame.font.SysFont("chicken_pie", 80)
        self.small_font = pygame.font.SysFont("chicken_pie", 32)

        self.score = 0
        self.font = pygame.font.SysFont("chicken_pie", 24)
Exemplo n.º 24
0
 def __init__(self, width, height):
     self.width = width
     self.height = height
     self.buffer_width = 200
     self.player = Player(x=width // 2, y=height // 2)
     self.bg_batch = pyglet.graphics.Batch()
     self.fg_batch = pyglet.graphics.Batch()
     self.random_pool = RandomPool(batch=self.bg_batch)
     pyglet.resource.path = ['.', 'data']
     pyglet.resource.reindex()
     self._sprites = []
     self._scenery = []
     self._blockers = []
     self._bullets = []
     self._labels = []
     self._npcs = []
     self._collections = [
         self._sprites, self._scenery, self._blockers, self._bullets,
         self._labels, self._npcs
     ]
Exemplo n.º 25
0
 def new(self):
     # start a new game
     self.all_sprites = pg.sprite.Group()
     self.field_sprites = pg.sprite.Group()
     self.all_bullets = pg.sprite.Group()
     self.all_villain = pg.sprite.Group()
     self.platforms = pg.sprite.Group()
     self.player = Player()
     self.villain = Villain()
     self.field = Field(500, 500, 50, 50)
     self.all_sprites.add(self.player, self.villain)
     self.field_sprites.add(self.field)
Exemplo n.º 26
0
    def __init__(self):
        self.player1 = Player(color=(255, 255, 255), x=random.randint(0, cfg.board_size), y=random.randint(0, cfg.board_size))
        self.player2 = Player(color=(0, 0, 0), x=random.randint(0, cfg.board_size), y=random.randint(0, cfg.board_size))

        self.tiles = {}
        for x, y in itertools.product(range(0, cfg.board_size), range(0, cfg.board_size)):
            self.tiles[x, y] = Tile(x=x, y=y, color=random.choice(cfg.themes))

        self.keyboard_inputs = {
            K_ESCAPE: (pygame.quit,),
            K_UP: (self.player1.move, 0, -1),
            K_DOWN: (self.player1.move, 0, 1),
            K_LEFT: (self.player1.move, -1, 0),
            K_RIGHT: (self.player1.move, 1, 0),
            K_RSHIFT: (self.player1.bomb, self.tiles, self.player2),
            K_w: (self.player2.move, 0, -1),
            K_s: (self.player2.move, 0, 1),
            K_a: (self.player2.move, -1, 0),
            K_d: (self.player2.move, 1, 0),
            K_LSHIFT: (self.player2.bomb, self.tiles, self.player1),
        }
Exemplo n.º 27
0
    def __init__(self, sw: int, sh: int):
        self.player = Player(0, 0, "./images/person1.png",
                             "./images/person2.png")
        self.setMainSprite(self.player)

        self.loadFromFile()

        self.rooms["loft"].addSprite(self.mainSprite)
        self.rooms["loft"].addController(KeyboardController(self.player))

        self.sw = sw
        self.sh = sh
Exemplo n.º 28
0
 def __init__(self):
     super(SpaceHogs, self).__init__(caption='Space Hogs', width=settings.WINDOW_WIDTH, height=settings.WINDOW_HEIGHT)
     
     pyglet.resource.path.append('data')
     pyglet.resource.reindex()
     
     self.batch = pyglet.graphics.Batch()
     
     self.player = Player(batch=self.batch)
     self.push_handlers(self.player)
     
     pyglet.clock.schedule_interval(self.update, float(1)/60)
Exemplo n.º 29
0
 def start(self):
     self.mobs = pygame.sprite.Group()
     self.walls = pygame.sprite.Group()
     self.current_map = Map()
     self.current_map.load_map_from_file("map.txt")
     self.current_map.create_sprites_from_data(self)
     self.player = Player(
         self,
         self.current_map.entry_point.x,
         self.current_map.entry_point.y
     )
     self.run()
Exemplo n.º 30
0
 def new(self):
     # Initialisieren und/oder Zurücksetzen
     self.all_sprites = pg.sprite.Group()
     self.blocks = pg.sprite.Group()
     self.player = Player()
     self.all_sprites.add(self.player)
     self.block1 = Block(0, s.HEIGHT - 64, s.WIDTH, 32)
     self.all_sprites.add(self.block1)
     self.blocks.add(self.block1)
     self.block2 = Block(s.WIDTH/2 - 64, s.HEIGHT - 192, 128, 32)
     self.all_sprites.add(self.block2)
     self.blocks.add(self.block2)
     self.run()
Exemplo n.º 31
0
 def __init__(self, level, character):
     self.effects = Effects()
     self.score = 1
     self.all_sprites = pygame.sprite.Group()
     self.platforms = pygame.sprite.Group()
     self.baddies = pygame.sprite.Group()
     self.powerups = pygame.sprite.Group()
     self.player = Player(character)
     self.all_sprites.add(self.player)
     for platform in level:
         plat = Platform(platform[0], platform[1], platform[2], platform[3])
         self.all_sprites.add(plat)
         self.platforms.add(plat)
Exemplo n.º 32
0
    def new(self, level):
        # start a new game
        if level == 5:
            self.playing = False
            g.show_go_screen()

        self.score = 0
        self.all_sprites = pg.sprite.LayeredUpdates()
        self.platforms = pg.sprite.Group()
        self.powerups = pg.sprite.Group()
        self.mobs = pg.sprite.Group()
        self.clouds = pg.sprite.Group()
        self.portal = pg.sprite.Group()
        self.shortcut = pg.sprite.Group()
        self.player = Player(self)

        pg.mixer.music.load(path.join(self.snd_dir, 'gameplay.mp3'))
        pg.mixer.music.set_volume(.3)
        pg.mixer.music.play(loops=-1)

        if level == 1:
            for plat in PLATFORM_LIST_1:
                Platform(self, *plat)
        if level == 2:
            for plat in PLATFORM_LIST_2:
                Platform(self, *plat)
        if level == 3:
            for plat in PLATFORM_LIST_3:
                Platform(self, *plat)

        Portal(self)
        Shortcut(self)

        self.mob_timer = 0

        for i in range(8):
            c = Cloud(self)
            c.rect.y += 500
        self.run(level)
Exemplo n.º 33
0
    def new(self):
        # initialize all variables and do all the setup for a new game
        self.draw_debug = False
        self.paused = False
        self.night = True

        # Sprite groups
        self.all_sprites = pg.sprite.LayeredUpdates()
        self.obstacles = pg.sprite.Group()
        self.mobs = pg.sprite.Group()
        self.bullets = pg.sprite.Group()
        self.items = pg.sprite.Group()

        # Map
        self.map = TiledMap(path.join(self.map_folder, '01.tmx'))
        self.map_img = self.map.make_map()
        self.map_rect = self.map_img.get_rect()

        # Map Objects
        for tile_object in self.map.tmxdata.objects:
            # For spawning in center of tiled object
            obj_center = vec(tile_object.x + tile_object.width / 2,
                             tile_object.y + tile_object.height / 2)
            if tile_object.name == 'player':
                self.player = Player(self, obj_center.x, obj_center.y)
            if tile_object.name == 'zombie':
                Mob(self, obj_center.x, obj_center.y)
            if tile_object.name == 'wall':
                Obstacle(self, tile_object.x, tile_object.y, tile_object.width,
                         tile_object.height)
            if tile_object.name in ['health', 'shotgun']:
                Item(self, obj_center, tile_object.name)

        # Camera object
        self.camera = Camera(self.map.width, self.map.height)

        # Start a new level sound
        self.effects_sounds['level_start'].play()
Exemplo n.º 34
0
 def new(self):
     # initialize all variables and do all the setup for a new game
     self.all_sprites = pg.sprite.Group()
     self.walls = pg.sprite.Group()
     for row, tiles in enumerate(self.map_data):
         for col, tile in enumerate(tiles):
             if tile == '1':
                 colour = BLACK
                 Wall(self, col, row, colour)
             elif tile == '2':
                 colour = YELLOW
                 Path(self, col, row, colour)
             elif tile == '3':
                 colour = PINK
                 Path(self, col, row, colour)
             elif tile == '4':
                 colour = GREEN
                 Path(self, col, row, colour)
             elif tile == '5':
                 colour = BROWN
                 Path(self, col, row, colour)
             elif tile == '6':
                 colour = VIOLET
                 Path(self, col, row, colour)
             elif tile == '7':
                 colour = ORANGE
                 Path(self, col, row, colour)
             elif tile == '8':
                 colour = BLUE
                 Path(self, col, row, colour)
             elif tile == '9':
                 colour = LIGHTGREY
                 Path(self, col, row, colour)
             # elif tile == '.':
             #     colour = WHITE
             #     Path(self, col, row, colour)
             elif tile == 'P':
                 self.player = Player(self, col, row)
Exemplo n.º 35
0
 def __init__(self, width, height):
     self.width = width
     self.height = height
     self.buffer_width = 200
     self.player = Player(x = width // 2, y = height // 2)
     self.bg_batch = pyglet.graphics.Batch()
     self.fg_batch = pyglet.graphics.Batch()
     self.random_pool = RandomPool(batch = self.bg_batch)
     pyglet.resource.path = ['.', 'data']
     pyglet.resource.reindex()
     self._sprites = []
     self._scenery = []
     self._blockers = []
     self._bullets = []
     self._labels = []
     self._npcs = []
     self._collections = [self._sprites, self._scenery, self._blockers,
             self._bullets, self._labels, self._npcs]
Exemplo n.º 36
0
def main():
    # Initialize
    pygame.init()

    map = Map(selectedmap)
    player = Player(map.start_position)
    particles = pygame.sprite.Group([])
    goombas = pygame.sprite.Group(map.enemies)
    all_sprites = pygame.sprite.Group(map.enemies + [player])

    screen_cols, screen_rows = screen_width / BLOCK_SIZE, screen_height / BLOCK_SIZE
    screen = pygame.display.set_mode((screen_width, screen_height))
    pygame.display.set_caption('Platformer '+VERSION)

    clock = pygame.time.Clock()
    font = pygame.font.SysFont(None, 30)

    invopen = 0 # True if the inventory is open, false if not.
    dragging = 0 # True if dragging an item, false if not.

    # Event loop
    right_down, left_down = False, False

    while 1:
        for event in pygame.event.get():
            if invopen == 0: # If inventory isn't opened do this:
                if event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE: # Quit the game
                    return
                elif event.type == KEYDOWN: # Handle pushed keys
                    if event.key in (K_LEFT, K_a):
                        left_down = True
                        player.move_left()
                    elif event.key in (K_RIGHT, K_d):
                        right_down = True
                        player.move_right()
                    elif event.key in (K_SPACE, K_w):
                        player.jump()
                    elif event.key == K_i:
                        invopen = 1
                elif event.type == KEYUP: # Handle released keys
                    if event.key in (K_LEFT, K_a):
                        player.move_right() if right_down else player.stop_x()
                        left_down = False
                    elif event.key in (K_RIGHT, K_d):
                        player.move_left() if left_down else player.stop_x()
                        right_down = False
                elif event.type == MOUSEBUTTONDOWN: # Handle mouse clicks
                    pos = pygame.mouse.get_pos()
                    bullet = player.shoot((pos[0] + screen_x, pos[1] + screen_y))
                    particles.add(bullet)
                    all_sprites.add(bullet)
            elif invopen== 1: # If inventory is open do this:
                if dragging == 0:
                    if event.type == QUIT:
                        return
                    elif event.type == KEYDOWN:
                        if event.key == K_ESCAPE or event.key == K_i:
                            invopen = 0
                    elif event.type == MOUSEBUTTONDOWN:
                        pos = pygame.mouse.get_pos()
                        if pos[0] in range(invframe.right-30, invframe.right) and pos[1] in range(invframe.top, invframe.top+30):
                            invopen = 0
                        for slot in range(50):
                            if pos[0] in range(SLOTCORD[slot][0], SLOTCORD[slot][0]+20) and pos[1] in range(SLOTCORD[slot][1], SLOTCORD[slot][1]+20):
                                #Drag the item if the selected slot is not empty
                                if inventory.content[slot][0] != 0:
                                    dragItem = slot
                                    dragging = 1
                elif dragging:
                    if event.type == KEYDOWN:
                        if event.key == K_ESCAPE or event.key == K_i:
                            dragging = 0
                            # Drop the item in previous slot
                    elif event.type == MOUSEBUTTONDOWN:
                        pos = pygame.mouse.get_pos()
                        for slot in range(50):
                            # Test if there is a slot where the player clicked
                            if pos[0] in range(SLOTCORD[slot][0], SLOTCORD[slot][0]+20) and pos[1] in range(SLOTCORD[slot][1], SLOTCORD[slot][1]+20):
                                dragging = 0
                                inventory.content[slot], inventory.content[dragItem]  = inventory.content[dragItem], inventory.content[slot]
                            else:
                                dragging = 0
                                # Return item to previous slot
        '''
        TODO: Add an inventory so we don't have to disable this entirely.
        Add or remove land blocks from the selected square

        pos = pygame.mouse.get_pos()
        x, y = int(pos[0] + screen_x) / BLOCK_SIZE, int(pos[1] + screen_y) / BLOCK_SIZE
         tile = map.grid[y][x]
        if event.button == 1 and tile.color == LAND:
            map.walls.remove(tile.rect)
            tile.color = SKY
        elif event.button == 3 and tile.color == SKY:
            map.walls.append(tile)
            tile.color = LAND
        '''
        elapsed_time = clock.tick()

        # If player's healty drops beyond 0, end the game
        if player.health <= 0:
            # Player is death
            pygame.quit()
            print "[-] You have died!"
            sys.exit()

        # If all enemies were killed, quit game and display win message
        if len(goombas) == 0:
            # Player has won
            pygame.quit()
            print "[+] You have won!"
            sys.exit()

        # Update all creatures. O(v*N), N: number of sprites, v: size of sprite
        for sprite in all_sprites:
            sprite.update(elapsed_time, map)

        # O(N^2)
        collided_enemies = pygame.sprite.spritecollide(player, goombas, True)
        for enemy in collided_enemies:
            player.damage(10/Player.DEFENSE)
            # Display damage and health message
            if DEBUG:
                print "[-] 10 Damage recieved from "+str(enemy)
                print "[*] Player has now "+str(player.health)+" life points"

        # O(N^2)
        shot_enemies = pygame.sprite.groupcollide(goombas, particles, True, True) # KILL EM ALL

        # Position screen
        screen_x, screen_y = max(player.rect.x - 250, 0), max(player.rect.y - 250, 0)
        screen_x = min(screen_x, map.width - screen_width)
        screen_y = min(screen_y, map.height - screen_height)

        # Draw the visible map
        grid_x, grid_y = int(screen_x) / BLOCK_SIZE, int(screen_y) / BLOCK_SIZE
        for row in map.grid[grid_y : grid_y + screen_rows + 1]:
            for square in row[grid_x : grid_x + screen_cols + 1]:
                # Select the correct block and blit it to the screen
                screen.blit(BLOCKGRAPHICS[square.type], square.rect.move(-screen_x, -screen_y))
        # Draw health bar
        pygame.draw.rect(screen, (250, 0, 0), pygame.Rect(screen_width - 100, 5, player.health, 20), 0)
        # Draw sprites (Creatures, bullets, etc)
        for sprites in all_sprites:
            screen.blit(SPRITEGRAPHICS[sprites.type], sprites.rect.move(-screen_x, -screen_y))
        # Draw the inventory if necessary
        if invopen:
            invframe = pygame.Rect(200, 200, 330, 400)
            invframe.center = screen_width/2, screen_height/2
            innerframe = pygame.Rect(200, 200, 310, 160)
            innerframe.bottomleft = invframe.left+10, invframe.bottom-10
            left = innerframe.left+10
            top = innerframe.top+10
            objectframe = pygame.Rect(0, 0, 20, 20)
            pygame.draw.rect(screen, (44, 44, 44), invframe)
            pygame.draw.rect(screen, (88, 88, 88), innerframe)
            objectframe = pygame.Rect(0, 0, 20, 20)
            for raw in range(5):
                for slot in range(10):
                    objectframe.topleft = left, top
                    pygame.draw.rect(screen, (100, 100, 100), objectframe)
                    # object[1] is the itemID, OBJIMG is a dictonary of loaded images
                    object = inventory.content[slot+(10*(raw-5))]
                    screen.blit(OBJIMG[str(object[0])], objectframe)
                    left += 30
                left = innerframe.left+10
                top += 30
            statsrect = pygame.Rect(200, 200, 200, 200)
            statsrect.top, statsrect.right = invframe.top+10, invframe.right-10
            pygame.draw.rect(screen, (22, 22, 22), statsrect)
            statsx, statsy = statsrect.left+10, statsrect.top+10
            stats = font.render('Max. HP: '+str(Player.MAXHEALTH), True, (250, 250, 250), (22, 22, 22))
            screen.blit(stats, (statsx, statsy))
            statsy += 25
            stats = font.render('Attack: '+str(Player.ATTACK), True, (250, 250, 250), (22, 22, 22))
            screen.blit(stats, (statsx, statsy))
            statsy += 25
            stats = font.render('Defense: '+str(Player.DEFENSE), True, (250, 250, 250), (22, 22, 22))
            screen.blit(stats, (statsx, statsy))
            statsy += 25
            stats = font.render('Speed: '+str(Player.SPEED), True, (250, 250, 250), (22, 22, 22))
            screen.blit(stats, (statsx, statsy))
            if dragging:
                pos = pygame.mouse.get_pos()
                objectframe.topleft = pos[0] , pos[1]
                dobject = inventory.content[dragItem]
                screen.blit(OBJIMG[str(dobject[0])], objectframe)
        # Draw FPS if necessary
        if DEBUG:
            text = font.render('FPS: ' + str(1000 / elapsed_time), True, (0, 0, 0), (250, 250, 250))
            screen.blit(text, text.get_rect())

        # Update the screen
        pygame.display.update()
Exemplo n.º 37
0
class Game:
    WIDTH      = 720
    HEIGHT     = WIDTH / 12 * 9 #16:9 Aspect ratio
    SIZE       = (WIDTH, HEIGHT)

    MAP_WIDTH  = 1920
    MAP_HEIGHT = 1080
    MAP_SIZE   = (MAP_WIDTH, MAP_HEIGHT)

    FPS        = 60
    TIME_LIMIT = 60
    GAME_OVER  = False
    HAS_WON    = False
    HAS_LAST   = False

    BALL_ADD   = 3
    BALL_SPAWN = 10

    def __init__(self):
        self.running  = True
        self.lasted   = 0
        self.last_num = None

        pygame.init()

        self.screen = pygame.display.set_mode(self.SIZE)
        pygame.display.set_caption("Can You Live?")

        self.clock  = pygame.time.Clock()
        self.camera = camera.Camera(self.SIZE, self.MAP_SIZE)

        self.create_resources()
        self.create_sprites()
        self.create_text()

    """ Creation Functions """

    # cache resources once to not re-use
    def create_resources(self):
        # set image paths
        self.bg_path = os.path.join("images","background.jpg")
        self.dragon_path = os.path.join("images","dragon_red.png")
        self.fire_path = os.path.join("images","fire.png")

        # transparent color for sprite sheets
        ckey = colors.BLACK

        # create dragon frames from sprite sheet
        ss = spritesheet( self.dragon_path )
        self.dragon_frames = []
        self.dragon_frames.append(ss.image_at((0, 160, 280, 240),colorkey=ckey))
        self.dragon_frames.append(ss.image_at((280, 160, 280, 240),colorkey=ckey))
        self.dragon_frames.append(ss.image_at((590, 140, 280, 260),colorkey=ckey))
        self.dragon_frames.append(ss.image_at((880, 180, 280, 240),colorkey=ckey))
        self.dragon_frames.append(ss.image_at((1160, 180, 280, 240),colorkey=ckey))
        self.dragon_frames.append(ss.image_at((1440, 180, 280, 240),colorkey=ckey))
        self.dragon_frames.append(ss.image_at((1760, 180, 280, 240),colorkey=ckey))
        self.dragon_frames.append(ss.image_at((2050, 180, 280, 240),colorkey=ckey))
        self.dragon_frames_flipped = self.generate_flipped_frames(self.dragon_frames)

        # create fire frames from sprite sheet
        ss = spritesheet( self.fire_path )
        self.fire_frames = []
        self.fire_frames.append(ss.image_at((130, 0, 75, 45),colorkey=ckey))
        self.fire_frames.append(ss.image_at((130, 45, 75, 45),colorkey=ckey))
        self.fire_frames.append(ss.image_at((130, 90, 75, 45),colorkey=ckey))
        self.fire_frames.append(ss.image_at((130, 130, 75, 45),colorkey=ckey))
        self.fire_frames_flipped = self.generate_flipped_frames(self.fire_frames)

    # create sprites for game
    def create_sprites(self):
        self.entities = pygame.sprite.Group()

        self.bg = pygame.image.load(self.bg_path).convert()
        self.bg = pygame.transform.smoothscale(self.bg, self.MAP_SIZE)
        self.bg_rect = self.bg.get_rect()

        self.player = Player(self)
        self.entities.add( self.player )

    # Render text only once
    def create_text(self):
        self.time_font      = pygame.font.Font(None, 30)
        self.gameover_font  = pygame.font.Font(None, 120)
        self.last_font      =  pygame.font.Font(None, 90)

        # generate rendered numbers so don't have to re-render
        self.numbers = {}
        for x in range(self.TIME_LIMIT + 1):
            self.numbers[str(x)] = self.time_font.render(str(x), 1, colors._BLACK)

        # generate cached text
        self.over_text = self.gameover_font.render("Game Over!", 1, colors._BLACK)
        self.win_text  = self.gameover_font.render("You Win!", 1, colors._BLACK)

        self.won_bg, self.lost_bg = pygame.Surface(self.SIZE), pygame.Surface(self.SIZE)
        self.won_bg.fill((10, 185, 13))
        self.lost_bg.fill((155, 0, 0))

    # generate animation flipped frames
    def generate_flipped_frames(self, frames):
        return [pygame.transform.flip(frame, True, False) for frame in frames]

    # generate random fireball
    def gen_rand_fireball(self, damage=None):
        coords = [0, 0]
        coords[0] = random.randint( self.WIDTH/2 ,self.MAP_WIDTH)
        coords[1] = random.randint(0 ,self.MAP_HEIGHT)
        self.spawn_fireball( coords, damage)

    # add more fireballs
    def add_fireballs(self):
        print "adding {} fireballs".format(self.BALL_ADD)
        for x in range( self.BALL_ADD ):
            self.gen_rand_fireball()

        self.BALL_ADD += int(self.BALL_ADD/3)

    # create a new fireball
    def spawn_fireball(self, coords, damage=None):
        fireball = FireBall(self)
        fireball.set_pos(coords)
        self.entities.add( fireball )

    # kill a fireball object
    def kill_ball(self, fireball):
        self.entities.remove( fireball )
        fireball.kill()
        del fireball

    # check fireball collisions and deal damage
    def check_collisions(self):
        fireballs = [e for e in self.entities.sprites() if e.block_id != "player"]
        fire_rects = [e.rect for e in fireballs]

        collision = self.player.rect.collidelist( fire_rects )
        if collision > -1:
            fireball = fireballs[ collision ]
            self.player.HP -= fireball.damage
            self.kill_ball( fireball )

    # clear left over memory because game is over :)
    def clear_all(self):
        for e in self.entities.sprites():
            self.kill_ball( e )

        del self.bg
        del self.bg_rect
        del self.entities
        del self.camera
        del self.player
        del self.numbers
        del self.time_font

    """ Drawing Functions """

    # Lose screen
    def draw_game_over(self):
        if not self.HAS_LAST:
            self.last_text = self.last_font.render("Lasted {} secs".format(self.lasted), 1, colors._BLACK)
            self.HAS_LAST = True

        self.screen.blit(self.lost_bg, (0,0))
        self.screen.blit(self.over_text, (self.WIDTH/2-240, self.HEIGHT/2-120))
        self.screen.blit(self.last_text, (self.WIDTH/2-240, self.HEIGHT/2))

    # Win screen
    def draw_win(self):
        self.screen.blit(self.won_bg, (0,0))
        self.screen.blit(self.win_text, (self.WIDTH/2-180, self.HEIGHT/2-120))

    # Health Bar
    def draw_health(self):
        # calculate color
        if self.player.HP > 60:
            color = colors.H_GREEN
        elif self.player.HP > 30:
            color = colors.H_YELLOW
        else:
            color = colors.H_RED

        # calculate bar size
        bar_width = 200.0
        percent_left = (self.player.HP * bar_width) / (self.player.MAX_HP*1.0)
        percent_lost = ((self.player.MAX_HP-self.player.HP) * bar_width) / (self.player.MAX_HP*1.0)

        # draw remaining health
        pygame.draw.rect(self.screen, color, (5, 5, percent_left, 20))

        # draw lost health
        pygame.draw.rect(self.screen, colors.BLACK,
            (5+percent_left, 5, percent_lost, 20))

    """ Game Functions """

    def run(self):
        start = time.time() # start timer

        while self.running:
            # handle events
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False
                    break
                if not self.GAME_OVER: self.player.update_stop(event)

            if not self.GAME_OVER:
                # update objects and screen
                self.camera.update(self.player)
                self.entities.update()
                self.check_collisions()

                # draw images
                self.screen.fill(colors.BLACK)
                self.screen.blit(self.bg, self.camera.apply(self.bg_rect))
                for e in self.entities.sprites():
                    if e.block_id != "player":
                        self.screen.blit(e.image, self.camera.apply(e.rect))
                
                self.screen.blit(self.player.image, self.camera.apply(self.player.rect))
                self.draw_health()

                # spawn fireballs
                if self.last_num != self.lasted:
                    self.last_num = self.lasted
                    if self.lasted % self.BALL_SPAWN == 0:
                        self.add_fireballs()

                # keep constant amount of fireballs on screen
                sprite_num = len(self.entities.sprites())
                if sprite_num < self.BALL_ADD:
                    to_add = self.BALL_ADD - sprite_num
                    for x in range(to_add):
                        self.gen_rand_fireball()

                # calculate & draw time
                elapsed = round(time.time() - start, 1)
                self.lasted = int(elapsed)
                if self.lasted >= self.TIME_LIMIT:
                    self.GAME_OVER = True
                    self.HAS_WON   = True
                    self.clear_all()

                if not self.GAME_OVER:
                    self.screen.blit( self.numbers[str(self.lasted)], (self.WIDTH-80, 10))

                # handle game over
                if not self.GAME_OVER:
                    if self.player.HP <= 0:
                        self.GAME_OVER = True
                        self.clear_all()

            else:
                if self.HAS_WON:
                    self.draw_win()
                else:
                    self.draw_game_over()

            # update pygame
            self.clock.tick( self.FPS )
            pygame.display.flip()

        self.exit()

    def exit(self):
        pygame.quit()
        sys.exit()
Exemplo n.º 38
0
def game_state(mapSize, aiSpeed, aiDifficulty):

    global maze
    global endpoint
    global startpoint
    global score

    # Set an FPS limit so PyGame doesn't destroy the CPU and create a singularity
    FPS = 60
    clock = pygame.time.Clock()

    # Start with no score
    score = 0


    # Running flag
    running = True

    # Setup the PyGame window
    pygame.init()
    screen = pygame.display.set_mode((32*mapSize, 32*mapSize))
    pygame.display.set_caption('aMAZE - The best game ever')

    # Generate an initial set of conditions
    new_round(screen, mapSize, aiDifficulty)

    # Setup the User and the AI
    user = Player(startpoint[0], startpoint[1] , (0,255,0), 4)
    enemy = Player(startpoint[0], startpoint[1], (255,0,0), aiSpeed)
    enemy.setNodes(aiPath)

    # Load the maze
    maze_spr = pygame.image.load("maze.png")

    # Update the console with score information
    update_console()

    # main game loop
    while running:

        # Python Window events
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
                sys.exit()

        # Update keystates
        keys = pygame.key.get_pressed()

        # Update the users position
        if (  keys[K_LEFT] or keys[K_RIGHT] or \
              keys[K_UP]   or keys[K_DOWN]  ) and user.isMoving() == False:

            # Get the users location in the graph and its neighbors
            node = user.getNode()
            neighbors = maze.graph()[user.getNode()]

            dx = 0
            dy = 0

            # Determine what node the user will end up on
            if keys[K_LEFT]:
                dx = -1
            elif keys[K_RIGHT]:
                dx = 1
            elif keys[K_UP]:
                dy = -1
            elif keys[K_DOWN]:
                dy = 1

            nextNode = (node[0]+dx, node[1]+dy)

            # Determine if this is an acceptable node
            if nextNode in neighbors:
                user.setNodes([nextNode])

        # Move the user and the AI
        user.move()
        enemy.move()


        # Render the scene
        screen.blit(maze_spr,(0,0))
        pygame.draw.rect(screen, (0, 255, 255), (endpoint[0]*32+8,endpoint[1]*32+8,16,16), 0)

        # Render the user and the AI
        enemy.render(screen)
        user.render(screen)

        # Flip the display buffer
        pygame.display.update()
        # Check to see if the user beat the AI to the end
        if user.atNode(endpoint) and not enemy.atNode(endpoint):

            # Don't increment the Difficulty if its maxed out or a special
            # Variant
            if aiDifficulty in [101, -1, -2]:
                pass
            else:

                # Up the difficulty
                aiDifficulty += 1

            # Increase the users score depending on the difficulty
            score += int(aiDifficulty/100)*aiSpeed + mapSize/4

            # Update the console with this new score
            update_console(score)

            # Generate a new set of conditions
            new_round(screen, mapSize, aiDifficulty)

            # Move the User and player back to the start and update the
            # AI path
            user.jump(startpoint)
            enemy.clearPath()
            enemy.setNodes(aiPath)
            enemy.jump(startpoint)

            # Update the maze
            maze_spr = pygame.image.load("maze.png")

                # Check to see if the AI Beat the user to the end
        elif enemy.atNode(endpoint) and not user.atNode(endpoint):
            # Quit the game and run the gameover State
            pygame.quit()
            os.system("clear")
            running = False
            aMAZE.game_over(score)

        # Limit the framerate
        clock.tick(FPS)

        # Quit the application if the user presses q
        if keys[K_q]:
            pygame.quit()
            os.system("clear")
            running = False
            aMAZE.game_over(score)

    return '0'
Exemplo n.º 39
0
def runGame():
    """Initialize new game."""
    pygame.display.set_caption('Escape from Wikipedia - Loading')
    fpsclock = pygame.time.Clock()
    camx = 0
    camy = 0
    section = 0
    player = Player(PLAYER_START)
    loading = Word("LOADING", (camx - 205, camy - 55),
            attr=BOLD, size=2, color=PURPLE)
    rabbyt.clear(WHITE)
    loading.render()     # Loading screen
    pygame.display.flip()
    # Short, simple page
    #page = Page("http://en.wikipedia.org/wiki/Solariellidae")
    # Longest page in Wikipedia
    #page = Page("http://en.wikipedia.org/wiki/Character_mask")
    # Random page
    page = Page("http://en.wikipedia.org/wiki/Special:Random")
    pygame.display.set_caption('Escape from...   ' + page.title)
    # xkcd
    #page = Page("http://en.wikipedia.org/wiki/Xkcd")
    #print len(page.words)

    # Main loop
    while True:

        for event in pygame.event.get():
            if event.type == QUIT:
                terminate()
            elif event.type == KEYDOWN:
                if event.key in QUIT_KEYS:
                    terminate()
                elif event.key in RESTART_KEYS:
                    glutils.scroll(-camx, -camy) # Reset glMatrix
                    return
                elif event.key in LEFT_KEYS:
                    player.goingleft = True
                    player.goingright = False
                    player.image.tex_shape = (1, 1, 0, 0)
                elif event.key in RIGHT_KEYS:
                    player.goingright = True
                    player.goingleft = False
                    player.image.tex_shape = (0, 1, 1, 0)
                elif event.key in UP_KEYS:
                    player.jump()
                elif event.key in DOWN_KEYS and player.plat is not None:
                    # Enter hyperlink
                    if not player.plat.hyperlink == "":
                        pygame.display.set_caption(
                                'Escape from Wikipedia - Loading')
                        loading = Word("LOADING", (camx - 205, camy - 55),
                                attr=BOLD, size=2, color=PURPLE)
                        rabbyt.clear(WHITE)
                        loading.render()   # Display load screen
                        pygame.display.flip()
                        page = Page(player.plat.hyperlink)
                        pygame.display.set_caption(page.title)
                        pygame.display.set_caption('Escape from...   '
                                + page.title)
                        #print len(page.words)
                        player.reset(page)
            elif event.type == KEYUP:
                if event.key in LEFT_KEYS:
                    player.goingleft = False
                elif event.key in RIGHT_KEYS:
                    player.goingright = False
                elif event.key in UP_KEYS and player.velocity[1] > 0:
                    player.velocity[1] *= 0.5   # Control jump height

        # Update position
        player.update()

        # Check for player-platform collisions
        collisions = rabbyt.collisions.aabb_collide_single(player,
                page.visible_words)
        # Player forced out of platforms by most direct route, more or less;
        for plat in collisions:
            if (player.right / 3 + 2 * player.left / 3 < plat.left
            and player.velocity[0] > 0):
                player.right = plat.left - 1
            elif (player.left / 3 + 2 * player.right / 3 > plat.right
            and player.velocity[0] < 0):
                player.left = plat.right + 1
            # More sensitive about the top, to compensate for high fall veloc
            elif player.top > plat.top and player.velocity[1] < 0:
                player.bottom = plat.top + 1
                player.plat = plat
                player.velocity[1] = 0   # Stop falling
                player.jumps = 0         # Reset jumps
                if plat.hyperlink != "":
                    player.hl_landed(TIMEOUT)
            elif (2 * player.top / 3 + player.bottom / 3 < plat.bottom
            and player.velocity[1] > 0):
                player.top = plat.bottom - 1
                player.velocity[1] = 0   # Jump stops

        prev_section = section
        prev_y = camy
        # adjust camera if beyond the "camera slack"
        if camx - player.x > CAMERASLACK:
            glutils.scroll(player.x + CAMERASLACK - camx, 0)
            camx = player.x + CAMERASLACK
        elif player.x - camx > CAMERASLACK:
            glutils.scroll(player.x - CAMERASLACK - camx, 0)
            camx = player.x - CAMERASLACK
        if camy - player.y > CAMERASLACK:
            glutils.scroll(0, player.y + CAMERASLACK - camy)
            camy = player.y + CAMERASLACK
        elif player.y - camy > CAMERASLACK:
            glutils.scroll(0, player.y - CAMERASLACK - camy)
            camy = player.y - CAMERASLACK

        # Keep track of viewing section
        section += int(prev_y / WINHEIGHT) - int(camy / WINHEIGHT)
        if not section == prev_section:
            if section > len(page.sections) + 1:
                glutils.scroll(-camx, -camy) # Reset glMatrix
                return
            page.visible_words = page.words[
                    page.sections[min(len(page.sections) - 1, max(0, section - 1))]:
                    page.sections[max(0, min(len(page.sections) - 1, section + 1))]]

        # Slow to FPS
        fpsclock.tick(FPS)
        # Need to tell Rabbyt what time it is every frame
        rabbyt.set_time(pygame.time.get_ticks() / TIME_FACTOR)

        # Draw screen
        rabbyt.clear(WHITE)
        rabbyt.render_unsorted(page.visible_words)
        rabbyt.render_unsorted(page.lines)
        player.render()
        pygame.display.flip()
Exemplo n.º 40
0
class Scene(object):
    def __init__(self, width, height):
        self.width = width
        self.height = height
        self.buffer_width = 200
        self.player = Player(x = width // 2, y = height // 2)
        self.bg_batch = pyglet.graphics.Batch()
        self.fg_batch = pyglet.graphics.Batch()
        self.random_pool = RandomPool(batch = self.bg_batch)
        pyglet.resource.path = ['.', 'data']
        pyglet.resource.reindex()
        self._sprites = []
        self._scenery = []
        self._blockers = []
        self._bullets = []
        self._labels = []
        self._npcs = []
        self._collections = [self._sprites, self._scenery, self._blockers,
                self._bullets, self._labels, self._npcs]

    def add_sprite(self, sprite):
        self._sprites.append(sprite)
        sprite.batch = self.bg_batch
        try:
            if sprite.sprite_type == "bullet":
                self._bullets.append(sprite)
                sprite.batch = self.fg_batch
            elif sprite.sprite_type == "blocker":
                self._blockers.append(sprite)
            elif sprite.sprite_type == "npc":
                self._npcs.append(sprite)
            elif sprite.sprite_type == "text":
                self._labels.append(sprite)
            else: # scenery
                self._scenery.append(sprite)
        except:
            self._scenery.append(sprite)

    def remove_sprite(self, sprite):
        for collection in self._collections:
            if sprite in collection:
                collection.remove(sprite)
        try:
            sprite.delete()
        except AttributeError as e:
            print "Warning:", e

    def action(self, action):
        state, action = action.split()
        self.player.action(state, action)
        if state == "+" and action == "blink":
            self.Bullet()

    def draw(self):
        self.bg_batch.draw()
        self.player.draw()
        self.fg_batch.draw()
    def update(self, dt):
        self.player.update(dt)
        bw = self.buffer_width
        dx = self.player.vx * dt
        dy = self.player.vy * dt

        for sprite in self._sprites:
            sprite.x -= dx
            sprite.y -= dy

        for sprite in self._sprites:
            if (sprite.x < - bw or sprite.y < - bw or
                sprite.x > self.width + bw or sprite.y > self.height + bw):
                if sprite in self._scenery or sprite in self._bullets:
                    self.remove_sprite(sprite)
                else: # wrap
                    if sprite.x < -bw:
                        sprite.x += self.width + 2 * bw
                        sprite.y += bw
                    if sprite.x > self.width + bw:
                        sprite.x -= self.width + 2 * bw
                        sprite.y -= bw
                    if sprite.y < -bw:
                        sprite.y += self.height + 2 * bw
                        sprite.x += bw
                    if sprite.y > self.height + bw:
                        sprite.y -= self.height + 2 * bw
                        sprite.x -= bw


        for bullet in self._bullets:
            bullet.update(dt)
            #if collision(bullet, self.player):
                #self.remove_sprite(bullet)
                #self.game_over()
            for npc in self._npcs:
                if collision(npc, bullet):
                    self.remove_sprite(npc)
                    self.remove_sprite(bullet)
                    npc.on_death()
        for npc in self._npcs:
            npc.update(self.get_state(), dt)
            if collision(npc, self.player):
                self.game_over()

        for text in self._labels:
            if collision(self.player, text):
                text.on_select()

    def get_state(self):
        return {"player": (self.player.x, self.player.y),
                "bullets": ((b.x, b.y) for b in self._bullets)}

    def random_event(self, dt):
        for obj in next(self.random_pool):
            (obj.x, obj.y) = self.random_offscreen_point()
            obj.batch = self.bg_batch
            self.add_sprite(obj)

    def random_offscreen_point(self):
        bw = self.buffer_width
        side = random.randint(0,3)
        if side == 0: # north
            x = random.randint(0, self.width)
            y = random.randint(self.height, self.height + bw)
        elif side == 1: # east
            x = random.randint(-bw, 0)
            y = random.randint(0, self.height)
        elif side == 2: # south
            x = random.randint(0, self.width)
            y = random.randint(-bw, 0)
        else: # west
            x = random.randint(self.width, self.width + bw)
            y = random.randint(0, self.height)
        return x, y

    def random_onscreen_point(self):
        x = random.randint(0, self.width)
        y = random.randint(0, self.height)
        return x, y

    def random_point(self, on_screen = True):
        if on_screen:
            return self.random_onscreen_point()
        else:
            return self.random_offscreen_point()

    def resize(self, width, height):
        h = self.height
        w = self.width
        self.height = height
        self.width = width
        self.player.set_position(width // 2, height // 2)

        dy = (self.height - h) // 2
        dx = (self.width - w) // 2

        for sprite in self._sprites:
            sprite.x += dx
            sprite.y += dy

    def fade_text(self):
        for text in self._labels:
            text.color = (0, 0, 0, 128)
        self._scenery.extend(self._labels)
        self._labels = []

    def Title(self, text, on_screen = True):
        (x, y) = self.random_point(on_screen=on_screen)
        self.add_sprite(Text(text, 34, (0, 0, 0, 255),
                x=self.width * 0.5, y=self.height * 0.75,
                batch=self.bg_batch))


    def Narration(self, text, size=24, on_screen = False):
        (x, y) = self.random_point(on_screen=on_screen)
        self.add_sprite(Text(text, size, (0, 0, 0, 255),
                x=x, y=y, batch=self.bg_batch))

    def Choice(self, text, size=24, on_select = do_nothing, on_screen = False):
        (x, y) = self.random_point(on_screen=on_screen)
        t = Text(text, size, (0, 0, 255, 255),
                x = x, y = y,
                batch=self.bg_batch, on_select = None)
        def on_select_wrapper():
            t.color = (255, 0, 0, 255)
            self.fade_text()
            on_select()
        t.on_select = on_select_wrapper
        self.add_sprite(t)

    def Troll(self, on_death = do_nothing):
        (x, y) = self.random_point(on_screen=False)
        self.add_sprite(Troll(x, y, on_death = on_death))

    def Villager(self, on_death = do_nothing):
        (x, y) = self.random_point(on_screen=False)
        self.add_sprite(HaplessVillager(x, y, on_death = on_death))

    def House(self):
        (x, y) = self.random_point(on_screen=False)
        img = pyglet.resource.image("house.png")
        house = pyglet.sprite.Sprite(img, x=x, y=y)
        house.sprite_type = "scenery"
        self.add_sprite(house)

    def fade_out(self):
        pass

    def Bullet(self):
        x = self.player.x
        y = self.player.y
        vx = self.player.vx + self.player.last_vx * 0.5
        vy = self.player.vy + self.player.last_vy * 0.5
        self.add_sprite(Bullet(x, y, vx, vy))

    def game_over(self):
        self.Narration("And this is how it ends.", on_screen = True)
Exemplo n.º 41
0
class Game:
    WIDTH    = 720
    HEIGHT   = WIDTH/12*9
    SIZE     = (WIDTH, HEIGHT)

    MAP_WIDTH  = 1980
    MAP_HEIGHT = 1080
    MAP_SIZE   = (MAP_WIDTH, MAP_HEIGHT)

    FPS        = 60
    LOG_FILE   = "gamelog.log"
    SAVE_FILE  = "save.json"

    HAS_MAP    = False
    HAS_HEALTH = True

    MAX_SCALES = 100

    def __init__(self):
        self.create_logger()

        try:
            self.debug("Initializing pygame")
            pygame.init()
        except Exception as e:
            self.debug("Init Error: "+str(e))

        self.music  = None
        self.bg_vol = 0.4
        self.name   = None

        self.entities   = None
        self.map_layer  = None
        self.collisions = []
        self.transport_rects = {}

        try:
            self.shop = Shop(self)
            self.manager = LevelManager(self)
            self.rsc     = resources.ResourceManager(self)
            self.scenes = CutScenes(self)
        except Exception as e:
            self.debug("Manager Error: "+str(e))

    def init(self, classname="Crystal"):
        # Create window
        os.environ['SDL_VIDEO_CENTERED'] = '1' # center screen
        self.screen = pygame.display.set_mode(self.SIZE)
        pygame.display.set_caption("Dragon TakeOver")

        # Load levels
        try:
            self.debug("Loading levels...")
            self.manager.load_all_levels()
        except Exception as e:
            self.debug("Level.All Error: " + str(e))

        # Add icon
        ico_path = os.path.join("resources","images","icon.png")
        ico_surf = self.rsc.load_image(ico_path,(32,32),colors.WHITE)
        pygame.display.set_icon(ico_surf)

        # create camera, fps, and game var
        self.clock = pygame.time.Clock()
        self.running = True
        self.game_dead = False
        self.camera = Camera(self.SIZE, self.MAP_SIZE)


        self.name = str(classname).lower()

        # load game
        try:
            self.debug("loading resources")
            font =  pygame.font.Font(None, 48)
            self.load_text = font.render("Loading...",1,colors.WHITE)
            self.load_rect = self.load_text.get_rect()
            self.load_rect.centerx = self.screen.get_rect().centerx
            self.load_rect.centery = self.screen.get_rect().centery
            self.IS_LOADING = True
            load_thread = self.create_thread(self.loading_screen)

            self.rsc.load_resources()
            self.IS_LOADING = False
            self.debug("waiting for loading thread to stop...")
            load_thread.join()
            self.debug("loading thread killed")

        except Exception as e:
            self.debug("Resource error: " + str(e))

        try:
            self.debug("loading shop resources")
            self.shop.init()
        except Exception as e:
            self.debug("Shop.init Error: " + str(e))

        self.create_sprites()
        self.load_save()

    ### Load Game Save file
    def load_save(self):
        save_data = None

        try:
            self.debug("loading save data")
            if os.path.exists(self.SAVE_FILE):
                with open(self.SAVE_FILE, 'r') as f:
                    save_data = json.loads(f.read())

                self.name = save_data['player']
                self.scenes.reset_scenes()

            self.create_player()

            if os.path.exists(self.SAVE_FILE):
                self.manager.load_level(save_data['level'])
                self.load_player_info(save_data)

        except Exception as e:
            self.debug("Save data Error: " + str(e))

    ### Create/Overwrite Game save file
    def write_save(self):
        self.debug("writing save")
        save = {}
        save['level']      = self.manager.level
        save['player']     = self.name
        save['max_hp']     = self.player.MAX_HP
        save['max_ap']     = self.player.MAX_AP
        save['attack']     = self.player.attack
        save['scales']     = self.player.scales
        save['boss_scales']= self.player.boss_scales
        save['party_hp']   = self.player.party_health
        save['party_atk']  = self.player.party_attack


        with open(self.SAVE_FILE, 'w') as f:
            f.write(json.dumps(save, indent=4, sort_keys=True))

    ### Create Debug/Game log
    def create_logger(self):
        # delete existing log file
        if os.path.exists(self.LOG_FILE):
            os.remove(self.LOG_FILE)

        # create logger
        logging.basicConfig(filename=self.LOG_FILE, level=logging.DEBUG)

    ### Create game sprites
    def create_sprites(self):
        self.debug("creating sprites")
        self.background = Block(self.MAP_SIZE)
        self.background.block_id = "bg"

        self.entities = pygame.sprite.Group()
        self.entities.add( self.background )

    def create_player(self):
        self.tests = []
        try:
            self.debug("Creating party..")

            # spawn player
            self.player = Player(self, self.name)
            self.player.block_id = "player"
            self.entities.add( self.player )

            # choose ally bots
            bot_options = ["crystal","nathan","jack"]
            bot_options.remove(self.name.lower())

            # spawn bots
            self.bots = []
            for bot_name in bot_options:
                self.debug("Creating bot: "+bot_name)

                if bot_name == "crystal": bot = CrystalBot(self, bot_name)
                elif bot_name == "jack": bot = JackBot(self, bot_name)
                else: bot = NathanBot(self, bot_name)

                bot.rect.x = self.player.rect.x + 50
                bot.rect.y = self.player.rect.y - 50

                self.bots.append( bot )
                self.entities.add( bot )

        except Exception as e:
            self.debug("Party Creation Error: " + str(e))

    ### Load player info from save file
    def load_player_info(self, info):
        self.player.MAX_HP = info['max_hp']
        self.player.MAX_AP = info['max_ap']
        self.player.attack = info['attack']
        self.player.scales = info['scales']

        self.player.boss_scales  = info['boss_scales']
        self.player.party_attack = info['party_atk']
        self.player.party_health = info['party_hp']

    """ EVENT LOOP FUNCTIONS """

    def draw(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                self.running = False
            self.player.update_stop(event)

        self.clock.tick(self.FPS)
        self.screen.fill(colors.BLACK)

        self.draw_sprites()
        self.draw_player_info()
        self.entities.update()
        pygame.display.flip()

    def draw_sprites(self, isScene=False):
        self.camera.update(self.player)
        for e in self.entities.sprites():
            if e.block_id not in ["player","bot"]:
                self.screen.blit(e.image, self.camera.apply(e.rect))

        # prioritize drawing of player and bots
        for bot in self.bots:
            self.screen.blit(bot.image, self.camera.apply(bot.rect))
        self.screen.blit(self.player.image, self.camera.apply(self.player.rect))

        # do collision
        for sprite in self.entities.sprites():
            if sprite.block_id in ["player","bot"]:
                if sprite.rect.collidelist(self.collisions) > -1:
                    sprite.move_back()

        # check transport
        if not isScene:
            for name in self.transport_rects:
                rect = self.transport_rects[name]
                if self.player.rect.colliderect(rect):
                    print str(name)
                    if name == "void":
                        if self.player.boss_scales < 3:
                            self.player.rect.y -= 30
                            self.player.h_decel, self.player.v_decel = True, True
                            self.scenes.load_scene(3)
                            spawn = self.manager.levels["village"]["spawn"]
                            self.player.set_pos(spawn[0], spawn[1])
                            break
                    else:
                        self.manager.load_level(name)
                        break
        else:
            pass

        for x in self.tests:
            self.screen.blit(x[1], self.camera.apply(x[0]))

    def draw_bars(self, sprite):
        _mid = (sprite.MAX_HP*60/100)
        _low = (sprite.MAX_HP*30/100)

        bar_width = sprite.bar_width

        # get length of health
        percent_left = (sprite.HP * bar_width) / (sprite.MAX_HP * 1.0)
        percent_lost = ((sprite.MAX_HP - sprite.HP) * bar_width) / (sprite.MAX_HP * 1.0)

        # get length of ap
        ap_left = (sprite.AP * bar_width) / (sprite.MAX_AP * 1.0)
        ap_lost = ((sprite.MAX_AP - sprite.AP) * bar_width) / (sprite.MAX_AP * 1.0)

        # calculate color
        if sprite.HP > _mid:
            color = colors.H_GREEN
        elif sprite.HP > _low:
            color = colors.H_YELLOW
        else:
            color = colors.H_RED

        # draw player health
        if sprite.block_id == "player":
            bar_x, bar_y = 40, 10
            bar_height = 15

            # draw HP
            left = (bar_x+3,bar_y+3, percent_left, bar_height)
            lost = (bar_x+percent_left+3, bar_y+3, percent_lost, bar_height)
            pygame.draw.rect(self.screen, color, left)
            pygame.draw.rect(self.screen, (10, 10, 10), lost)

            # draw ap
            left = (bar_x + 3, bar_y + 30, ap_left, bar_height)
            lost = (bar_x + ap_left+3, bar_y + 30, ap_lost, bar_height)
            pygame.draw.rect(self.screen, colors.AP_COLOR, left)
            pygame.draw.rect(self.screen, (10, 10, 10), lost)

        # draw boss health
        elif sprite.block_id == "boss":
            pass

        # draw mob health
        else:
            hp_rect = self.camera.apply(sprite.rect)
            x, y = hp_rect.x, hp_rect.y
            start_x = x + (sprite.WIDTH/2)
            start_y = y - sprite.hp_evel
            bar_height = 5

            left = (start_x, start_y, percent_left, bar_height)
            lost = (start_x+percent_left, start_y, percent_lost, bar_height)

            pygame.draw.rect(self.screen, color, left)
            pygame.draw.rect(self.screen, (10,10,10), lost)

    def draw_player_info(self):
        # draw face
        face = self.player.face
        self.screen.blit(face, (5,5))

        # draw scales
        scale_text = self.rsc.scale_nums[str(self.player.scales)]
        boss_text  = self.rsc.scale_nums[str(self.player.boss_scales)]
        self.screen.blit(self.rsc.scale, (5, 65))
        self.screen.blit(self.rsc.boss_scale, (105, 65))
        self.screen.blit(scale_text, (35, 65))
        self.screen.blit(boss_text, (135, 65))

        # draw all entity health bars
        for e in self.entities.sprites():
            if e.IS_ALIVE:
                self.draw_bars(e)

    #### Other

    def draw_loading(self):
        self.clock.tick(self.FPS)
        self.screen.fill(colors.BLACK)
        self.screen.blit(self.load_text, self.load_rect)
        pygame.display.flip()

    def run(self):

        while self.running:
            self.draw()

        self.exit()

    def exit(self):
        self.write_save()
        pygame.quit()
        sys.exit()

    def loading_screen(self):
        while self.IS_LOADING:
            self.draw_loading()

    def create_thread(self, func, *args):
        t = threading.Thread(target=func, args=args)
        t.daemon = True
        t.start()
        return t

    def debug(self, text, debug=True):
        _log    = text
        starter = "> "
        if not isinstance(text, basestring): _log = repr(text)

        if debug:
            logging.debug(starter + _log)
        else:
            logging.info(starter + _log)
        print _log