Пример #1
0
 def __init__(self,
              skills = Skills(), attributes = Attributes(), health = Health()
              ):
     self.skills = skills
     self.attributes = attributes
     self.health = health
Пример #2
0
class Game:
    def __init__(self, screen, usealpha = True, noparticles = False, endless = False):
        self.screen = screen
        self.usealpha = usealpha
        self.noparticles = noparticles

        self.sharks = []
        self.shark_sprites = pygame.sprite.Group()

        self.player = Steamboat()
        self.player_sprite = pygame.sprite.Group()
        self.player_sprite.add(self.player)

        self.health = Health()
        self.health_sprite = pygame.sprite.Group()
        self.health_sprite.add(self.health)

        self.damage_count = 0

        self.t = 0

        self.water = Water.global_water #Water(self.usealpha)
        #Water.global_water = self.water
        self.water_sprite = pygame.sprite.Group()
        self.water_sprite.add(self.water)

        self.sky = util.load_image("taivas")
        self.sky = pygame.transform.scale(self.sky, (SCREEN_WIDTH, SCREEN_HEIGHT))

        self.pause_icon = util.load_image("pause")
        
        self.cannonballs = []
        self.cannonball_sprites = pygame.sprite.Group()

        self.pirates = []
        self.pirate_sprites = pygame.sprite.Group()

        self.titanic = None
        self.titanic_sprite = pygame.sprite.Group()

        self.seagulls = []
        self.seagull_sprites = pygame.sprite.Group()

        self.particles = Particles(self.usealpha)
        self.particle_sprite = pygame.sprite.Group()
        self.particle_sprite.add(self.particles)

        self.mines = []
        self.mine_sprites = pygame.sprite.Group()

        self.score = Score()
        self.score_sprite = pygame.sprite.Group()
        self.score_sprite.add(self.score)

        self.powerups = []
        self.powerup_sprites = pygame.sprite.Group()

        self.level = Level(endless)
        self.cheat_current = 0
        
        self.lastshot = MIN_FIRE_DELAY + 1

        self.gameover = False
        self.gameover_image = None
        self.gameover_rect = None
        self.done = False

        self.pause = False
        font = util.load_font("Cosmetica", 40) #pygame.font.Font(pygame.font.get_default_font(), 36)
        self.pause_image = font.render("Pause", True, (0,0,0))
        self.pause_rect = self.pause_image.get_rect()
        self.pause_rect.center = self.screen.get_rect().center

    def run(self):
        while not self.done:
            util.android_check_pause()
            if not self.pause:
                if not self.gameover:
                    self.spawn_enemies()

                self.update_enemies()
                self.player.update()
                self.health.update()
                cloud.update()
                for cb in self.cannonballs:
                    cb.update()
                    if (cb.rect.right < 0 and cb.vect[0] < 0) or (cb.rect.left > SCREEN_WIDTH and cb.vect[0] > 0):
                        self.cannonballs.remove(cb)
                        self.cannonball_sprites.remove(cb)
                self.score.update()

                # Add steam particles
                if not self.noparticles:
                    for i in range(STEAM_3):
                        particle_point = self.player.get_point((5.0 + random.random() * 9.0, 0))
                        particle_point[0] += self.player.rect.centerx
                        particle_point[1] += self.player.rect.centery
                        self.particles.add_steam_particle(particle_point)

                    for i in range(STEAM_3):
                        particle_point = self.player.get_point((19.0 + random.random() * 7.0, 5.0))
                        particle_point[0] += self.player.rect.centerx
                        particle_point[1] += self.player.rect.centery
                        self.particles.add_steam_particle(particle_point)

                    if self.titanic:
                        for j in range(4):
                            for i in range(STEAM_3):
                                particle_point = self.titanic.get_point((49 + random.random() * 9.0 + 28 * j, 25))
                                particle_point[0] += self.titanic.rect.centerx
                                particle_point[1] += self.titanic.rect.centery
                                self.particles.add_steam_particle(particle_point)

                    self.particles.update()

                self.water.update()

                if self.player.splash:
                    if not self.noparticles:
                        for i in range(SPLASH_30):
                            r = random.random()
                            x = int(r * self.player.rect.left + (1.0-r) * self.player.rect.right)
                            point = (x, self.water.get_water_level(x))
                            self.particles.add_water_particle(point)
    
                for powerup in self.powerups:
                    powerup.update()
                    if powerup.picked:
                        self.powerups.remove(powerup)
                        self.powerup_sprites.remove(powerup)

                if not self.gameover:
                    self.check_collisions()

                if self.health.hearts_left == 0 and not self.player.dying:
                    self.player.die()

                if self.player.dying and not self.player.dead:
                    if not self.noparticles:
                        for i in range(BLOOD_3):
                            self.particles.add_explosion_particle((self.player.rect.centerx, self.player.rect.centery))
                            self.particles.add_debris_particle((self.player.rect.centerx, self.player.rect.centery))

                if self.player.dead:
                    #self.done = True
                    self.set_gameover()

                if self.damage_count > 0:
                    self.damage_count -= 1
                self.lastshot += 1
                self.t += 1

            self.draw()

            self.handle_events()


        return self.score.get_score()

    def set_gameover(self, message = "Game Over"):
        self.gameover = True
        images = []
        font = util.load_font("Cosmetica", 40) #pygame.font.Font(pygame.font.get_default_font(), 36)
        height = 0
        width = 0
        for text in message.split("\n"):
            images.append(font.render(text, True, (0,0,0)))
            height += images[-1].get_height()
            if images[-1].get_width() > width:
                width = images[-1].get_width()
        self.gameover_image = pygame.Surface((width, height), SRCALPHA, 32)
        self.gameover_image.fill((0,0,0,0))
        for i in range(len(images)):
            rect = images[i].get_rect()
            rect.top = i * images[i].get_height()
            rect.centerx = width / 2
            self.gameover_image.blit(images[i], rect)

        self.gameover_rect = self.gameover_image.get_rect()
        self.gameover_rect.center = self.screen.get_rect().center
    
    def translate_mouse_event(self, event):
     if event.type in (MOUSEBUTTONDOWN, ):
       if event.pos[0] > SCREEN_WIDTH - 32 and event.pos[1] < 32:
          key = K_p
       else:
          rx = event.pos[0] / float(SCREEN_WIDTH)
          ry = event.pos[1] / float(SCREEN_HEIGHT)
          if rx < 0.0:
             key = K_LEFT
          elif rx > 1.0:
             key = K_RIGHT
          elif ry > 0.5:
             key = K_SPACE
          else:
             key = K_UP
       event = pygame.event.Event(KEYUP if event.type == MOUSEBUTTONUP else KEYDOWN, key=key)
     
     if util.android:
        self.player.move_left(False)
        self.player.move_right(False)
     return event
    
    def handle_events(self):
        nextframe = False
        framecount = 0
        while not nextframe:
          # wait until there's at least one event in the queue
          pygame.event.post(pygame.event.wait())
          for event in pygame.event.get():
            #event = pygame.event.wait()
            event = self.translate_mouse_event(event)
            if event.type == QUIT or \
               event.type == KEYDOWN and event.key == K_ESCAPE:
                self.done = True
                nextframe = True
            elif event.type == NEXTFRAME:
                nextframe = True
                framecount += 1
            elif self.gameover:
                if event.type == JOYBUTTONDOWN:
                    self.done = True
                    nextframe = True
                elif event.type == KEYDOWN:
                    self.done = True
                    nextframe = True
            elif event.type == MOUSEBUTTONDOWN:
                self.done = True
                nextframe = True
                continue
            elif event.type == JOYAXISMOTION:
                if event.axis == 0:
                    if event.value < -0.5:
                        self.player.move_left(True)
                    elif event.value > 0.5:
                        self.player.move_right(True)
                    else:
                        self.player.move_left(False)
                        self.player.move_right(False)
            elif event.type == JOYBUTTONDOWN:
                if event.button == 0:
                  if not self.pause:
                    self.player.jump()
                elif event.button == 1:
                  if not self.pause:
                    if self.lastshot > MIN_FIRE_DELAY and not self.player.dying:
                        cb = Cannonball(self.player.rect, self.player.angle)
                        self.cannonballs.append(cb)
                        self.cannonball_sprites.add(cb)
                        self.lastshot = 0
                elif event.button == 5:
                    pygame.image.save(self.screen, "sshot.tga")
                    print "Screenshot saved as sshot.tga"
                elif event.button == 8:
                    self.set_pause()
            elif event.type == KEYDOWN:
                if event.key == K_LEFT:
                    self.player.move_left(True)
                elif event.key == K_RIGHT:
                    self.player.move_right(True)
                elif event.key == K_SPACE:
                  if not self.pause:
                    # Only 3 cannonballs at once
                    # Maximum firing rate set at the top
                    if self.lastshot > MIN_FIRE_DELAY and not self.player.dying:
                        cb = Cannonball(self.player.rect, self.player.angle)
                        self.cannonballs.append(cb)
                        self.cannonball_sprites.add(cb)
                        self.lastshot = 0
                elif event.key == K_UP:
                    if not self.pause:
                        self.player.jump()
                elif event.key == K_s:
                    pygame.image.save(self.screen, "sshot.tga")
                    print "Screenshot saved as sshot.tga"
                elif event.key == K_p:
                    self.set_pause()
                elif event.key == cheat_seq[self.cheat_current]:
                    self.cheat_current += 1
                    print self.cheat_current
                    if len(cheat_seq) == self.cheat_current:
                        print 'Cheater!'
                        self.cheat_current = 0
                        self.level.phase = 5
                        self.level.t = 0
                        self.spawn_enemies()
            elif event.type == KEYUP:
                if event.key == K_LEFT:
                    self.player.move_left(False)
                elif event.key == K_RIGHT:
                    self.player.move_right(False)
        
        tiling = util.get_tiling()
        if tiling == -1:
            self.player.move_left(True)
        elif tiling == 1:
            self.player.move_right(True)
        #if framecount > 1:
        #    print "Missed " + str(framecount - 1) + " frames!"

    def set_pause(self):
        self.pause = not self.pause

    def draw(self):
        self.screen.blit(self.sky, self.screen.get_rect())
        self.screen.blit(self.pause_icon, (SCREEN_WIDTH - 32, 0))
        self.health_sprite.draw(self.screen)
        self.score_sprite.draw(self.screen)
        self.player_sprite.draw(self.screen)
        self.powerup_sprites.draw(self.screen)
        self.pirate_sprites.draw(self.screen)
        if self.titanic:
            self.titanic_sprite.draw(self.screen)
        self.seagull_sprites.draw(self.screen)
        cloud.draw(self.screen)
        self.shark_sprites.draw(self.screen)
        self.mine_sprites.draw(self.screen)
        self.cannonball_sprites.draw(self.screen)
        self.water_sprite.draw(self.screen)
        if not self.noparticles:
            self.particle_sprite.draw(self.screen)

        if self.pause:
            self.screen.blit(self.pause_image, self.pause_rect)

        if self.gameover:
            self.screen.blit(self.gameover_image, self.gameover_rect)

        if self.level.t < 120:
            font = util.load_font("Cosmetica", 16)
            image = None
            i = 0
            if self.level.phase < len(self.level.phase_messages):
              for text in self.level.phase_messages[self.level.phase].split("\n"):
                image = font.render(text, True, (0,0,0))
                rect = image.get_rect()
                rect.centerx = self.screen.get_rect().centerx
                rect.top = 100 + rect.height * i
                blit_image = pygame.Surface((image.get_width(), image.get_height()))
                blit_image.fill((166,183,250))
                blit_image.set_colorkey((166,183,250))
                blit_image.blit(image, image.get_rect())
                if self.level.t > 60:
                    blit_image.set_alpha(255 - (self.level.t - 60) * 255 / 60)
                self.screen.blit(blit_image, rect)
                i += 1

        pygame.display.flip()



    def check_collisions(self):
        collisions = PixelPerfect.spritecollide_pp(self.player, self.powerup_sprites, 0)
        for powerup in collisions:
            if not powerup.fading:
                if not self.player.dying:
                    self.health.add()
                    powerup.pickup()

        collisions = PixelPerfect.spritecollide_pp(self.player, self.mine_sprites, 0)

        for mine in collisions:
            if not mine.exploding:
                if not self.player.dying:
                    self.health.damage()
                    mine.explode()

        collisions = PixelPerfect.spritecollide_pp(self.player, self.shark_sprites, 0)

        for shark in collisions:
            if not shark.dying:
                if not self.player.dying:
                    self.health.damage()
                    shark.die()

        collisions = PixelPerfect.spritecollide_pp(self.player, self.cannonball_sprites, 0)

        for cb in collisions:
            if not self.player.dying:
                self.health.damage()
                self.cannonballs.remove(cb)
                self.cannonball_sprites.remove(cb)
                Mine.sound.play() # Umm... the mine has a nice explosion sound.

        collisions = PixelPerfect.groupcollide_pp(self.cannonball_sprites, self.shark_sprites, 0, 0)

        for cb in dict.keys(collisions):
            for shark in collisions[cb]:
                # The test on cb.vect is a rude hack preventing cannonballs from pirate ships from killing sharks.
                if not shark.dying and cb.vect[0] > 0:
                    self.score.add(15)
                    shark.die()
                    self.cannonballs.remove(cb)
                    self.cannonball_sprites.remove(cb)
                    break

        collisions = PixelPerfect.groupcollide_pp(self.cannonball_sprites, self.seagull_sprites, 0, 0)

        for cb in dict.keys(collisions):
            for seagull in collisions[cb]:
                # cb.vect test is a rude hack preventing pirates from killing seagulls
                if not seagull.dying and cb.vect[0] > 0:
                    self.score.add(75)
                    seagull.die()
                    self.cannonballs.remove(cb)
                    self.cannonball_sprites.remove(cb)
                    break

        collisions = PixelPerfect.groupcollide_pp(self.cannonball_sprites, self.pirate_sprites, 0, 0)

        for cb in dict.keys(collisions):
            for pirate in collisions[cb]:
                # cb.vect hack for preventing pirates from killing each other
                if not pirate.dying and cb.vect[0] > 0:
                    Mine.sound.play() # Umm... the mine has a nice sound.
                    self.score.add(25)
                    pirate.damage()
                    self.cannonballs.remove(cb)
                    self.cannonball_sprites.remove(cb)
                    break

        if self.titanic:
            collisions = PixelPerfect.spritecollide_pp(self.titanic, self.cannonball_sprites, 0)
            for cb in collisions:
                if not self.titanic.dying and cb.vect[0] > 0:
                    Mine.sound.play()
                    self.score.add(7)
                    self.titanic.damage()
                    self.cannonballs.remove(cb)
                    self.cannonball_sprites.remove(cb)
                    break

    def update_enemies(self):
        for mine in self.mines:
            mine.update()
            if mine.exploding:
                if mine.explode_frames == 0:
                    self.mines.remove(mine)
                    self.mine_sprites.remove(mine)
                # this should really be done in the Mine class, but oh well, here's some explosion effects:
                if not self.noparticles:
                    for i in range(3):
                        self.particles.add_explosion_particle((mine.rect.centerx, mine.rect.top + mine.image.get_rect().centerx))
                        self.particles.add_debris_particle((mine.rect.centerx, mine.rect.top + mine.image.get_rect().centerx))
            if mine.rect.right < self.screen.get_rect().left:
                self.mines.remove(mine)
                self.mine_sprites.remove(mine)

        for shark in self.sharks:
            shark.update()
            if shark.dying:
                if not self.noparticles:
                    self.particles.add_blood_particle(shark.rect.center)
            if shark.rect.right < self.screen.get_rect().left or shark.dead:
                self.sharks.remove(shark)
                self.shark_sprites.remove(shark)

        for pirate in self.pirates:
            pirate.update()
            if pirate.t % 50 == 0 and not pirate.dying:
                # Pirate shoots, this should probably be handled by the Pirateboat class
                cb = Cannonball(pirate.rect, pirate.angle, left = True)
                self.cannonballs.append(cb)
                self.cannonball_sprites.add(cb)
            if pirate.rect.right < self.screen.get_rect().left or pirate.dead:
                self.pirates.remove(pirate)
                self.pirate_sprites.remove(pirate)
            elif pirate.dying:
                if not self.noparticles:
                    for i in range(3):
                        self.particles.add_explosion_particle((pirate.rect.centerx, pirate.rect.centery))
                        self.particles.add_wood_particle((pirate.rect.centerx, pirate.rect.centery))

        if self.titanic:
            self.titanic.update()
            if self.titanic.t % 100 == 0 and not self.titanic.dying:
                for i in range(3):
                    cb = Cannonball(self.titanic.rect, self.titanic.angle + (i-1)*10 - 50, left = True)
                    self.cannonballs.append(cb)
                    self.cannonball_sprites.add(cb)
            elif self.titanic.t % 100 == 50 and not self.titanic.dying:
                for i in range(3):
                    cb = Cannonball(self.titanic.rect, self.titanic.angle + (i-1)*10 - 60, left = True)
                    self.cannonballs.append(cb)
                    self.cannonball_sprites.add(cb)
            if self.titanic.dead:
                self.set_gameover("Congratulations!\nYou sunk Titanic!")
                self.titanic = None

        for seagull in self.seagulls:
            seagull.update()
            if seagull.rect.right < 0 or seagull.dead:
                self.seagulls.remove(seagull)
                self.seagull_sprites.remove(seagull)

    def spawn_enemies(self):
        spawns = self.level.get_spawns()
        if spawns[Level.SHARKS]:
            # Make a new shark
            self.sharks.append(Shark())
            self.shark_sprites.add(self.sharks[-1])

        if spawns[Level.PIRATES]:
            # Make a new pirate ship
            self.pirates.append(Pirateboat())
            self.pirate_sprites.add(self.pirates[-1])

        if spawns[Level.MINES]:
            self.mines.append(Mine())
            self.mine_sprites.add(self.mines[-1])

        if spawns[Level.SEAGULLS]:
            self.seagulls.append(Seagull())
            self.seagull_sprites.add(self.seagulls[-1])

        if spawns[Level.TITANIC]:
            self.titanic = Titanic()
            self.titanic_sprite.add(self.titanic)

        if spawns[Level.POWERUPS]:
            self.powerups.append(Powerup())
            self.powerup_sprites.add(self.powerups[-1])
Пример #3
0
class Game:
    def __init__(self, player_number):
        self.__player_number = player_number
        # def classes objects
        self.__scenario_obj = Scenario()
        self.__professions_obj = Professions()
        self.__health_obj = Health()
        self.__bio_characteristic_obj = BIO()
        self.__additional_info_obj = AInfo()
        self.__personality_trains_obj = PTrains()
        self.__hobbies_obj = Hobbies()
        self.__phobias_obj = Phobias()
        self.__special_info_obj = SInfo()

        self.__load_data()
        self.__shuffle_data()
        self.__create_players()
        self.__make_players_files()

    def __load_data(self):
        print("Loading scenarios...")
        self.__scenario = self.__scenario_obj.get_scenarios()
        print("Loading scenarios - completed!")

        print("Loading professions...")
        self.__professions = self.__professions_obj.get_professions()
        print("Loading professions - completed!")

        print("Loading diseases (health)...")
        self.__diseases = self.__health_obj.get_diseases()
        print("Loading diseases (health) - completed!")

        print("Loading bio. characteristics...")
        self.__bio_characteristics = self.__bio_characteristic_obj.get_bio_info(
            self.__player_number)
        print("Loading bio. characteristics - completed!")

        print("Loading additional information...")
        self.__additional_info = self.__additional_info_obj.get_additional_info(
        )
        print("Loading additional information - completed!")

        print("Loading personality trains...")
        self.__personality_trains = self.__personality_trains_obj.get_peronality_trains(
        )
        print("Loading personality trains - completed!")

        print("Loading hobbies...")
        self.__hobbies = self.__hobbies_obj.get_hobbies()
        print("Loading hobbies - completed!")

        print("Loading phobias...")
        self.__phobias = self.__phobias_obj.get_phobias()
        print("Loading phobias - completed!")

        print("Loading special information...")
        self.__special_info = self.__special_info_obj.get_special_info()
        print("Loading special information - completed!")

    def __shuffle_data(self):
        # Scenarios
        keys = list(self.__scenario.keys())
        shuffle(keys)
        self.__shuffled_scenario = dict()
        for key in keys:
            self.__shuffled_scenario.update({key: self.__scenario[key]})

        # Profs
        keys = list(self.__professions.keys())
        shuffle(keys)
        self.__shuffled_professions = dict()
        for key in keys:
            self.__shuffled_professions.update({key: self.__professions[key]})

        # Diseases
        keys = list(self.__diseases.keys())
        shuffle(keys)
        self.__shuffled_diseases = dict()
        for key in keys:
            self.__shuffled_diseases.update({key: self.__diseases[key]})

        # Bio
        shuffle(self.__bio_characteristics)
        self.__shuffled_bio_characteristics = self.__bio_characteristics

        # Additional info
        shuffle(self.__additional_info)
        self.__shuffled_additional_info = self.__additional_info

        # Personality traits
        shuffle(self.__personality_trains)
        self.__shuffled_personality_trains = self.__personality_trains

        # Hobbies
        keys = list(self.__hobbies.keys())
        shuffle(keys)
        self.__shuffled_hobbies = dict()
        for key in keys:
            self.__shuffled_hobbies.update({key: self.__hobbies[key]})

        # Phobias
        shuffle(self.__phobias)
        self.__shuffled_phobias = self.__phobias

        # Special info
        shuffle(self.__special_info)
        self.__shuffled_special_info = self.__special_info

    def __create_players(self):
        try:
            self.__players = []
            for i in range(self.__player_number):
                player = {}
                # prof
                key = choice(list(self.__shuffled_professions))
                player["Profession"] = {key: self.__shuffled_professions[key]}
                del self.__shuffled_professions[key]
                # disease
                key = choice(list(self.__shuffled_diseases))
                player["Disease"] = key
                del self.__shuffled_diseases[key]
                # bio
                key = choice(self.__shuffled_bio_characteristics)
                player["Bio.Characteristic"] = key
                self.__shuffled_bio_characteristics.remove(key)
                # additional info
                key = choice(self.__shuffled_additional_info)
                player["Additional information"] = key
                self.__shuffled_additional_info.remove(key)
                # personality traits
                key = choice(self.__shuffled_personality_trains)
                player["Personality trait"] = key
                self.__shuffled_personality_trains.remove(key)
                # hobbies
                key = choice(list(self.__shuffled_hobbies))
                player["Hobby"] = {key: self.__shuffled_hobbies[key]}
                del self.__shuffled_hobbies[key]
                # phobias
                key = choice(self.__shuffled_phobias)
                player["Phobia"] = key
                self.__shuffled_phobias.remove(key)
                # Special information
                key = choice(self.__shuffled_special_info)
                player["Special information"] = key
                self.__shuffled_special_info.remove(key)

                self.__players.append(player)
        except ValueError as error:
            print("Error ", error)

    def __make_players_files(self):
        for i in range(self.__player_number):
            with open(f"players/{i}.txt", "w", encoding='utf-8') as file:
                for key in self.__players[i].keys():
                    if key == "Profession":
                        prof_key = list(
                            self.__players[i][key].keys())  # prof name
                        file.write(f"Ваша профессия - {prof_key[0]}\n")
                        file.write(
                            f"Описание вашей профессии - {self.__players[i][key][prof_key[0]]}\n"
                        )
                    if key == "Disease":
                        disease_key = self.__players[i][key]
                        file.write(
                            f"Ваше состояние здоровья - {disease_key}\n")
                    if key == "Bio.Characteristic":
                        bio_key = list(self.__players[i][key].keys())
                        file.write(f"Ваш пол - {bio_key[0]}\n")
                        file.write(
                            f"Ваш возраст - {self.__players[i][key][bio_key[0]]}\n"
                        )
                    if key == "Additional information":
                        file.write(
                            f"Ваша карта с доп. информацией под номером - {self.__players[i][key]}\n"
                        )
                    if key == "Personality trait":
                        file.write(
                            f"Ваша персональная четра - {self.__players[i][key]}\n"
                        )
                    if key == "Hobby":
                        hobby_key = list(self.__players[i][key].keys())
                        file.write(
                            f"Ваше хобби - {self.__players[i][key][hobby_key[0]]}(Номер хобби - {hobby_key[0]})\n"
                        )
                    if key == "Phobia":
                        file.write(
                            f"Ваша фобия - {self.__players[i][key].capitalize()}\n"
                        )
                    if key == "Special information":
                        file.write(
                            f"Ваша карта с спец. информацией под номером - {self.__players[i][key]}\n"
                        )
Пример #4
0
enemy16 = Asteroid(0,600,50,20,7,5)
enemy17 = Asteroid(400,400,760,700,5,5)
enemy18 = Asteroid(340,100,400,30,4,7)
enemy19 = Asteroid(100,0,500,180,2,1)
enemy20 = Asteroid(100,500,1000,500,5,7)



bumper = Planet(1000,100,50,50)
bumper2 = Planet(700,600,50,50)
bumper3 = Planet(600,0,50,50)
bumper4 = Planet(900,300,50,50)
bumper5 = Planet(400,600,50,50)


heart = Health(1000,0)

enemyGroup = pygame.sprite.Group()
enemyGroup.add(enemy2)
enemyGroup.add(enemy)
enemyGroup.add(enemy3)
enemyGroup.add(enemy4)
enemyGroup.add(enemy5)
enemyGroup.add(enemy6)
enemyGroup.add(enemy7)
enemyGroup.add(enemy8)
enemyGroup.add(enemy9)
enemyGroup.add(enemy10)
enemyGroup.add(enemy11)
enemyGroup.add(enemy12)
enemyGroup.add(enemy13)
Пример #5
0
enemyGroup.add(enemy2)
enemyGroup.add(enemy3)
enemyGroup.add(enemy4)
enemyGroup.add(enemy5)
enemyGroup.add(enemy6)
enemyGroup.add(enemy8)
enemyGroup.add(enemy9)
enemyGroup.add(enemy0)

background = pygame.image.load("space.png")
background = pygame.transform.smoothscale(background, (width, height))
rectb = background.get_rect()

Player = Ship('ship4.png')
Player2 = Ship('ufo2.png')
life = Health('heart2.png', 1200, 50)
life2 = Health('heart2.png', 100, 50)


#screen.blit(background,rectb)
def main():
    while True:
        Player.update(enemyGroup)
        Player2.update(enemyGroup)
        life.update(Player.health)
        life2.update(Player2.health)
        for en in enemyGroup:
            en.move()
        screen.fill(color)
        clock.tick(60)
        screen.blit(Player.image, Player.rect)
Пример #6
0
def multiplayer_screen():

    global current_state

    time_since_start_ms = 0
    for event in events:
        events[event]["count"] = 0

    stage_theme.play(loops=-1)
    player_sprites_list = pygame.sprite.Group()
    player2_sprites_list = pygame.sprite.Group()
    enemy_sprites_list = pygame.sprite.Group()
    bullet_sprites_list = pygame.sprite.Group()
    health_sprites_list = pygame.sprite.Group()
    dead_sprites_list = pygame.sprite.Group()

    num_health = 3
    num_health2 = 6
    hearts = []
    hearts2 = []

    for count in range(num_health):
        elem = Health(WHITE, 20, 20)
        health_sprites_list.add(elem)
        elem.rect.x = count * 64
        elem.rect.y = 0
        hearts.append(elem)

    for count in range(num_health2):
        elem = Health(WHITE, 20, 20)
        health_sprites_list.add(elem)
        elem.rect.x = 1280 - (count * 64)
        elem.rect.y = 0
        hearts2.append(elem)

    main_player = Player(RED, 64, 64, is_zombie=False)
    player2 = Player(RED, 80, 80, is_zombie=True)

    player_sprites_list.add(main_player)
    player2_sprites_list.add(player2)

    main_player.rect.x = 20
    main_player.rect.y = HEIGHT / 2

    player2.rect.x = 1280 - 40
    player2.rect.y = HEIGHT / 2

    invincible = False  # After-hit invincibility state
    running = True
    start_time = pygame.time.get_ticks()

    horizon = list(
        pygame.image.load(
            "Assets/Backgrounds/horizonfull.png").get_rect().size)
    borders = [WIDTH, HEIGHT, horizon[1]]
    bck_image_width = horizon[0]

    background = pygame.image.load(
        "Assets/Backgrounds/Background.png").convert_alpha()
    background_horizon = pygame.image.load(
        "Assets/Backgrounds/horizonfull.png").convert_alpha()

    offset = 0
    offset2 = -bck_image_width

    game_loop = True
    while game_loop:

        time_since_start_ms += clock.get_time()

        # Main event loop
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                game_loop = False
                current_state = screen_states['quit']
            elif event.type == INVINCIBILITY_END:
                invincible = False
                pygame.time.set_timer(INVINCIBILITY_END, 0)

            elif event.type == pygame.USEREVENT:
                if event.dict["subtype"] == PLAYERS_CAN_SHOOT:
                    for player in player_sprites_list:
                        player.can_shoot = True

                elif event.dict["subtype"] == BASIC_ZOMBIE_SPAWN:
                    new_enemy = BasicZombie(64, 64)
                    new_enemy.rect.x = WIDTH - 64
                    new_enemy.rect.y = random.randint(64, borders[1] - 64)
                    enemy_sprites_list.add(new_enemy)

                elif event.dict["subtype"] == FLYING_ZOMBIE_SPAWN:
                    new_enemy = FlyingZombie(64, 64)
                    new_enemy.rect.x = WIDTH - 64
                    new_enemy.rect.y = random.randint(0, borders[2] - 64)
                    enemy_sprites_list.add(new_enemy)

                elif event.dict["subtype"] == FLYING_ZOMBIES_CAN_SHOOT:
                    for enemy in enemy_sprites_list:
                        if isinstance(enemy, FlyingZombie):
                            enemy.can_shoot = True

        keys = pygame.key.get_pressed()
        # Movement event
        if keys[keybindings['left']]:
            player2.moveLeft()
        if keys[keybindings['right']]:
            player2.moveRight(borders)
        if keys[keybindings['up']]:
            player2.moveUp(borders)
        if keys[keybindings['down']]:
            player2.moveDown(borders)

        if keys[keybindings['left2']]:
            main_player.moveLeft()
        if keys[keybindings['right2']]:
            main_player.moveRight(borders)
        if keys[keybindings['up2']]:
            main_player.moveUp(borders)
        if keys[keybindings['down2']]:
            main_player.moveDown(borders)

        # Fire event
        if keys[keybindings['fire']]:
            bullet = main_player.shoot()
            if bullet:
                bullet.direction = main_player.last_direction
                bullet_sprites_list.add(bullet)

        counting_time = pygame.time.get_ticks() - start_time

        # change milliseconds into minutes, seconds, milliseconds
        counting_minutes = 3 - (counting_time / 60000)
        counting_seconds = int(60 - (counting_time % 60000) / 1000)

        counting_string = "%d:%d" % (counting_minutes, counting_seconds)

        # counting_rect = counting_text.get_rect(midtop=screen.get_rect().midtop)
        counting_text = debug_font.render(str(counting_string), 1,
                                          (255, 255, 255))
        counting_rect = counting_text.get_rect(midtop=screen.get_rect().midtop)

        screen.blit(counting_text, counting_rect)
        if int(counting_minutes) == 0 and counting_seconds == 0:
            current_state = screen_states['congrats']
            game_loop = False
        # screen.blit(counting_text, counting_rect)
        # pygame.display.update()

        # Game logic
        # Kills enemy when they collide with player
        for enemy in pygame.sprite.groupcollide(bullet_sprites_list,
                                                enemy_sprites_list, 1,
                                                0).values():
            bullet_hit_sound.play()
            zombie_hit_sound.play()
            dead_sprites_list.add(enemy[0])
            enemy[0].dead = True
            enemy_sprites_list.remove(enemy[0])

        for enemy in pygame.sprite.groupcollide(bullet_sprites_list,
                                                player2_sprites_list, 1, 0):
            if not invincible:
                current = hearts2[-1]
                current.kill()
                del hearts2[-1]
                invincible = True
                pygame.time.set_timer(INVINCIBILITY_END,
                                      INVINCIBILITY_DURATION)
        if not hearts2:
            #global current_state
            current_state = screen_states['game_over']
            game_loop = False

        for player in pygame.sprite.groupcollide(player_sprites_list,
                                                 enemy_sprites_list, 0, 0):
            if not invincible:
                zombie_attack_melee_sound.play()
                player_hit.play()
                current = hearts[-1]
                current.kill()
                del hearts[-1]
                invincible = True
                pygame.time.set_timer(INVINCIBILITY_END,
                                      INVINCIBILITY_DURATION)

        for player in pygame.sprite.groupcollide(player_sprites_list,
                                                 player2_sprites_list, 0, 0):
            if not invincible:
                zombie_attack_melee_sound.play()
                player_hit.play()
                current = hearts[-1]
                current.kill()
                del hearts[-1]
                invincible = True
                pygame.time.set_timer(INVINCIBILITY_END,
                                      INVINCIBILITY_DURATION)
        if not hearts:
            #global current_state
            current_state = screen_states['game_over']
            game_loop = False

        for player in pygame.sprite.groupcollide(player2_sprites_list,
                                                 player_sprites_list, 0, 0):
            if not invincible:
                bullet_hit_sound.play()
                zombie_hit_sound.play()
                current = hearts[-1]
                current.kill()
                del hearts[-1]
                invincible = True
                pygame.time.set_timer(INVINCIBILITY_END,
                                      INVINCIBILITY_DURATION)

        if not hearts:
            pygame.sprite.groupcollide(player_sprites_list, enemy_sprites_list,
                                       1, 0)

        if not hearts2:
            pygame.sprite.groupcollide(player2_sprites_list,
                                       player_sprites_list, 1, 0)

        player_sprites_list.update()
        player2_sprites_list.update()
        enemy_sprites_list.update()
        bullet_sprites_list.update()
        health_sprites_list.update()
        spit_sprites.update()
        dead_sprites_list.update()

        # Drawing logic
        offset += 1
        offset2 += 1
        screen.blit(background, (-offset, 0))
        screen.blit(background_horizon, (-offset, 0))

        screen.blit(background, (-offset2, 0))
        screen.blit(background_horizon, (-offset2, 0))

        if offset > bck_image_width:
            offset = -bck_image_width
        if offset2 > bck_image_width:
            offset2 = -bck_image_width

        # FPS counter
        fps_str = "".join(["FPS: ", str(int(clock.get_fps()))])
        fps = debug_font.render(fps_str, True, WHITE)
        screen.blit(fps, (50, 50))

        # Timer counter
        counting_text = timer_font.render(str(counting_string), True, WHITE)
        screen.blit(counting_text, (WIDTH / 2, 10))

        dead_sprites_list.draw(screen)
        player_sprites_list.draw(screen)
        player2_sprites_list.draw(screen)
        enemy_sprites_list.draw(screen)
        bullet_sprites_list.draw(screen)
        health_sprites_list.draw(screen)
        spit_sprites.draw(screen)

        # Screen update
        pygame.display.flip()
        clock.tick(60)

        # Timer updates
        generate_time_based_events(time_since_start_ms)
Пример #7
0
class Game:
    sky = None

    def __init__(self, screen, gamepad, endless=False):
        self.screen = screen
        self.gamepad = gamepad

        self.sharks = []
        self.shark_sprites = pygame.sprite.Group()

        self.player = Steamboat()
        self.player_sprite = pygame.sprite.Group()
        self.player_sprite.add(self.player)

        self.health = Health()
        self.health_sprite = pygame.sprite.Group()
        self.health_sprite.add(self.health)

        self.damage_count = 0

        self.t = 0

        self.water = Water.global_water
        #Water.global_water = self.water
        self.water_sprite = pygame.sprite.Group()
        self.water_sprite.add(self.water)

        if not Game.sky:
            Game.sky = util.load_image("taivas")
            Game.sky = pygame.transform.scale(self.sky,
                                              (SCREEN_WIDTH, SCREEN_HEIGHT))

        self.cannonballs = []
        self.cannonball_sprites = pygame.sprite.Group()

        self.pirates = []
        self.pirate_sprites = pygame.sprite.Group()

        self.titanic = None
        self.titanic_sprite = pygame.sprite.Group()

        self.seagulls = []
        self.seagull_sprites = pygame.sprite.Group()

        self.particles = Particles()
        self.particle_sprite = pygame.sprite.Group()
        self.particle_sprite.add(self.particles)

        self.mines = []
        self.mine_sprites = pygame.sprite.Group()

        self.score = Score()
        self.score_sprite = pygame.sprite.Group()
        self.score_sprite.add(self.score)

        self.powerups = []
        self.powerup_sprites = pygame.sprite.Group()

        self.level = Level(endless)

        self.lastshot = MIN_FIRE_DELAY + 1

        self.gameover = False
        self.gameover_image = None
        self.gameover_rect = None
        self.done = False

        self.pause = False
        self.pause_image = util.bigfont.render("Pause", Variables.alpha,
                                               (0, 0, 0))
        self.pause_rect = self.pause_image.get_rect()
        self.pause_rect.center = self.screen.get_rect().center

        self.spacepressed = None

    def run(self):
        while not self.done:
            if not self.pause:
                if not self.gameover:
                    self.spawn_enemies()

                self.update_enemies()
                self.player.update()
                self.health.update()
                cloud.update()
                for cb in self.cannonballs:
                    if not cb.underwater:
                        #~ particle_point=cb.rect.left, cb.rect.top
                        particle_point = cb.tail_point()
                        self.particles.add_trace_particle(particle_point)
                        particle_point = [
                            particle_point[i] + cb.vect[i] / 2 for i in (0, 1)
                        ]
                        self.particles.add_trace_particle(particle_point)
                    if cb.special and (not cb.underwater or rr() > 0.6):
                        particle_point = cb.tail_point()
                        self.particles.add_explosion_particle(particle_point)
                    und_old = cb.underwater
                    cb.update()
                    if cb.underwater and not und_old:
                        for i in xrange(5):
                            particle_point = cb.rect.right - 4.0 + rr(
                            ) * 8.0, cb.rect.top + rr() * 2.0
                            self.particles.add_water_particle(particle_point)
                    if (cb.rect.right < 0 and cb.vect[0] < 0) or (
                            cb.rect.left > SCREEN_WIDTH and
                            cb.vect[0] > 0) or (cb.rect.top > SCREEN_HEIGHT):
                        self.cannonballs.remove(cb)
                        self.cannonball_sprites.remove(cb)
                self.score.update()

                # Add steam particles
                if Variables.particles:
                    particle_point = self.player.get_point(
                        (5.0 + rr() * 9.0, 0))
                    particle_point[0] += self.player.rect.centerx
                    particle_point[1] += self.player.rect.centery
                    if self.spacepressed and self.t > self.spacepressed + FPS * 3:
                        pass
                        #~ self.particles.add_fire_steam_particle(particle_point)
                    else:
                        self.particles.add_steam_particle(particle_point)

                    particle_point = self.player.get_point(
                        (19.0 + rr() * 7.0, 5.0))
                    particle_point[0] += self.player.rect.centerx
                    particle_point[1] += self.player.rect.centery
                    if self.spacepressed and self.t > self.spacepressed + FPS * 3:
                        pass
                        #~ self.particles.add_fire_steam_particle(particle_point)
                    else:
                        self.particles.add_steam_particle(particle_point)

                    if self.titanic:
                        for j in xrange(4):
                            particle_point = self.titanic.get_point(
                                (49 + rr() * 9.0 + 28 * j, 25))
                            particle_point[0] += self.titanic.rect.centerx
                            particle_point[1] += self.titanic.rect.centery
                            self.particles.add_steam_particle(particle_point)

                    self.particles.update()

                self.water.update()

                if self.player.splash:
                    if Variables.particles:
                        for i in xrange(10):
                            r = rr()
                            x = int(r * self.player.rect.left +
                                    (1.0 - r) * self.player.rect.right)
                            point = (x, self.water.get_water_level(x))
                            self.particles.add_water_particle(point)

                for powerup in self.powerups:
                    powerup.update()
                    if powerup.picked:
                        self.powerups.remove(powerup)
                        self.powerup_sprites.remove(powerup)

                if not self.gameover:
                    self.check_collisions()

                if self.health.hearts_left == 0 and not self.player.dying:
                    self.player.die()

                if self.player.dying and not self.player.dead:
                    if Variables.particles:
                        self.particles.add_explosion_particle(
                            (self.player.rect.centerx,
                             self.player.rect.centery))
                        self.particles.add_debris_particle(
                            (self.player.rect.centerx,
                             self.player.rect.centery))

                if self.player.dead:
                    #self.done = True
                    self.set_gameover()

                if self.damage_count > 0:
                    self.damage_count -= 1
                self.lastshot += 1
                self.t += 1

            self.draw()

            self.handle_events()

        return self.score.get_score()

    def damage_player(self):
        self.health.damage()
        for i in xrange(10):
            particle_point = self.player.get_point((rr() * 26.0, rr() * 10.0))
            particle_point[0] += self.player.rect.centerx
            particle_point[1] += self.player.rect.centery
            self.particles.add_debris_particle(particle_point)
        self.player.blinks += 12

    def set_gameover(self, message="Game Over"):
        self.gameover = True
        images = []
        height = 0
        width = 0
        for text in message.split("\n"):
            images.append(util.bigfont.render(text, Variables.alpha,
                                              (0, 0, 0)))
            height += images[-1].get_height()
            if images[-1].get_width() > width:
                width = images[-1].get_width()
        self.gameover_image = pygame.Surface((width, height), SRCALPHA, 32)
        self.gameover_image.fill((0, 0, 0, 0))
        for i in xrange(len(images)):
            rect = images[i].get_rect()
            rect.top = i * images[i].get_height()
            rect.centerx = width / 2
            self.gameover_image.blit(images[i], rect)

        self.gameover_rect = self.gameover_image.get_rect()
        self.gameover_rect.center = self.screen.get_rect().center

    def take_screenshot(self):
        i = 1
        basedir = os.environ['HOME']
        if not basedir:
            basedir = '/home'
        filename = basedir + "/funnyboat-sshot.tga"
        while os.path.exists(filename):
            i += 1
            filename = basedir + "/funnyboat-sshot" + str(i) + ".tga"

        pygame.image.save(self.screen, filename)
        print "Screenshot saved as " + filename

    def handle_events(self):
        nextframe = False
        framecount = 0
        while not nextframe:
            # wait until there's at least one event in the queue
            #nextframe = True
            pygame.event.post(pygame.event.wait())
            for event in pygame.event.get():
                #event = pygame.event.wait()
                if event.type == QUIT or \
                   event.type == KEYDOWN and event.key == K_ESCAPE:
                    self.done = True
                    nextframe = True
                elif event.type == NEXTFRAME:
                    framecount += 1
                    nextframe = True
                elif self.gameover:
                    if event.type == JOYBUTTONDOWN:
                        self.done = True
                        nextframe = True
                    elif event.type == KEYDOWN:
                        self.done = True
                        nextframe = True
                    continue
                elif event.type == JOYAXISMOTION:
                    if event.axis == 0:
                        if event.value < -0.5:
                            self.player.move_left(True)
                        elif event.value > 0.5:
                            self.player.move_right(True)
                        else:
                            self.player.move_left(False)
                            self.player.move_right(False)
                elif event.type == JOYBUTTONDOWN:
                    if self.gamepad and self.gamepad.is_pressed(
                            'a',
                            event) or not self.gamepad and event.button == 0:
                        if not self.pause:
                            self.player.jump()
                    elif self.gamepad and self.gamepad.is_pressed(
                            'rightshoulder',
                            event) or not self.gamepad and event.button == 1:
                        if not self.pause:
                            if self.lastshot > MIN_FIRE_DELAY and not self.player.dying:
                                cb = Cannonball(self.player.rect,
                                                self.player.angle)
                                self.cannonballs.append(cb)
                                self.cannonball_sprites.add(cb)
                                particle_point = self.player.get_point(
                                    (42.0, 10.0))
                                particle_point[0] += self.player.rect.centerx
                                particle_point[1] += self.player.rect.centery
                                for i in xrange(4):
                                    self.particles.add_fire_steam_particle(
                                        particle_point)
                                self.lastshot = 0
                                self.spacepressed = self.t
                    elif self.gamepad and self.gamepad.is_pressed(
                            'leftshoulder',
                            event) or not self.gamepad and event.button == 5:
                        self.take_screenshot()
                    elif self.gamepad and self.gamepad.is_pressed(
                            'start',
                            event) or not self.gamepad and event.button == 8:
                        self.set_pause()
                    elif self.gamepad and self.gamepad.is_pressed(
                            'back', event):
                        self.done = True
                        nextframe = True
                elif event.type == KEYDOWN:
                    if event.key == K_LEFT:
                        self.player.move_left(True)
                    elif event.key == K_RIGHT:
                        self.player.move_right(True)
                    elif event.key == K_SPACE:
                        if not self.pause:
                            # Only 3 cannonballs at once
                            # Maximum firing rate set at the top
                            if self.lastshot > MIN_FIRE_DELAY and not self.player.dying:
                                cb = Cannonball(self.player.rect,
                                                self.player.angle)
                                self.cannonballs.append(cb)
                                self.cannonball_sprites.add(cb)
                                particle_point = self.player.get_point(
                                    (42.0, 10.0))
                                particle_point[0] += self.player.rect.centerx
                                particle_point[1] += self.player.rect.centery
                                for i in xrange(4):
                                    self.particles.add_fire_steam_particle(
                                        particle_point)
                                self.lastshot = 0
                                self.spacepressed = self.t
                    elif event.key == K_UP:
                        if not self.pause:
                            self.player.jump()
                    elif event.key == K_s:
                        self.take_screenshot()
                    elif event.key == K_p:
                        self.set_pause()
                elif event.type == KEYUP:
                    if event.key == K_LEFT:
                        self.player.move_left(False)
                    elif event.key == K_RIGHT:
                        self.player.move_right(False)
                    elif event.key == K_SPACE:
                        if not self.pause:
                            if self.spacepressed and self.t > self.spacepressed + FPS * 3 and not self.player.dying:
                                cb = Cannonball(self.player.rect,
                                                self.player.angle,
                                                special=True)
                                self.cannonballs.append(cb)
                                self.cannonball_sprites.add(cb)
                                particle_point = self.player.get_point(
                                    (42.0, 10.0))
                                particle_point[0] += self.player.rect.centerx
                                particle_point[1] += self.player.rect.centery
                                for i in xrange(30):
                                    self.particles.add_fire_steam_particle(
                                        (particle_point[0] + rrr(-4, 4),
                                         particle_point[1] + rrr(-3, 3)))
                                self.lastshot = 0
                            self.spacepressed = None
                elif event.type == JOYBUTTONUP:
                    if self.gamepad and self.gamepad.is_pressed(
                            'b',
                            event) or not self.gamepad and event.button == 1:
                        if not self.pause:
                            if self.spacepressed and self.t > self.spacepressed + FPS * 3 and not self.player.dying:
                                cb = Cannonball(self.player.rect,
                                                self.player.angle,
                                                special=True)
                                self.cannonballs.append(cb)
                                self.cannonball_sprites.add(cb)
                                particle_point = self.player.get_point(
                                    (42.0, 10.0))
                                particle_point[0] += self.player.rect.centerx
                                particle_point[1] += self.player.rect.centery
                                for i in xrange(30):
                                    self.particles.add_fire_steam_particle(
                                        (particle_point[0] + rrr(-4, 4),
                                         particle_point[1] + rrr(-3, 3)))
                                self.lastshot = 0
                            self.spacepressed = None

        #if framecount > 1:
        #    print str(self.t) + ": missed " + str(framecount - 1) + " frames!"

    def set_pause(self):
        self.pause = not self.pause

        #if framecount > 1:
        #    print str(self.t) + ": missed " + str(framecount - 1) + " frames!"

    def set_pause(self):
        self.pause = not self.pause

    def draw(self):
        self.screen.blit(Game.sky, self.screen.get_rect())
        self.health_sprite.draw(self.screen)
        self.score_sprite.draw(self.screen)
        self.player_sprite.draw(self.screen)
        self.powerup_sprites.draw(self.screen)
        self.pirate_sprites.draw(self.screen)
        if self.titanic:
            self.titanic_sprite.draw(self.screen)
        self.seagull_sprites.draw(self.screen)
        cloud.draw(self.screen)
        self.shark_sprites.draw(self.screen)
        self.mine_sprites.draw(self.screen)
        self.cannonball_sprites.draw(self.screen)
        self.water_sprite.draw(self.screen)
        if Variables.particles:
            self.particle_sprite.draw(self.screen)

        if self.pause:
            self.screen.blit(self.pause_image, self.pause_rect)

        if self.gameover:
            self.screen.blit(self.gameover_image, self.gameover_rect)

        if self.level.t < 120:
            image = None
            i = 0
            if self.level.phase < len(self.level.phase_messages):
                for text in self.level.phase_messages[self.level.phase].split(
                        "\n"):
                    image = util.smallfont.render(text, Variables.alpha,
                                                  (0, 0, 0))
                    rect = image.get_rect()
                    rect.centerx = self.screen.get_rect().centerx
                    rect.top = 100 + rect.height * i
                    blit_image = pygame.Surface(
                        (image.get_width(), image.get_height()))
                    blit_image.fill((166, 183, 250))
                    blit_image.set_colorkey((166, 183, 250))
                    blit_image.blit(image, image.get_rect())
                    if self.level.t > 60:
                        blit_image.set_alpha(255 -
                                             (self.level.t - 60) * 255 / 60)
                    self.screen.blit(blit_image, rect)
                    i += 1

        pygame.display.flip()

    def check_collisions(self):
        collisions = PixelPerfect.spritecollide_pp(self.player,
                                                   self.powerup_sprites, 0)
        for powerup in collisions:
            if not powerup.fading:
                if not self.player.dying:
                    self.health.add()
                    powerup.pickup()

        collisions = PixelPerfect.spritecollide_pp(self.player,
                                                   self.mine_sprites, 0)

        for mine in collisions:
            if not mine.exploding:
                if not self.player.dying:
                    self.damage_player()
                    mine.explode()

        collisions = PixelPerfect.spritecollide_pp(self.player,
                                                   self.shark_sprites, 0)

        for shark in collisions:
            if not shark.dying:
                if not self.player.dying:
                    self.damage_player()
                    shark.die()

        collisions = PixelPerfect.spritecollide_pp(self.player,
                                                   self.cannonball_sprites, 0)

        for cb in collisions:
            if not self.player.dying:
                self.damage_player()
                self.cannonballs.remove(cb)
                self.cannonball_sprites.remove(cb)
                if (Variables.sound):
                    Mine.sound.play(
                    )  # Umm... the mine has a nice explosion sound.

        collisions = PixelPerfect.groupcollide_pp(self.cannonball_sprites,
                                                  self.shark_sprites, 0, 0)

        for cb in dict.keys(collisions):
            for shark in collisions[cb]:
                # The test on cb.vect is a rude hack preventing cannonballs from pirate ships from killing sharks.
                if not shark.dying and cb.vect[0] > 0:
                    self.score.add(15)
                    shark.die()
                    # give her a part of ball's momentum:
                    shark.dx += cb.vect[0] * 0.6
                    shark.dy += cb.vect[1] * 0.4
                    if not cb.special:
                        self.cannonballs.remove(cb)
                        self.cannonball_sprites.remove(cb)
                    break

        collisions = PixelPerfect.groupcollide_pp(self.cannonball_sprites,
                                                  self.seagull_sprites, 0, 0)

        for cb in dict.keys(collisions):
            for seagull in collisions[cb]:
                # cb.vect test is a rude hack preventing pirates from killing seagulls
                if not seagull.dying and cb.vect[0] > 0:
                    self.score.add(75)
                    seagull.die()
                    # give her a part of ball's momentum:
                    seagull.vect[0] += cb.vect[0] * 0.4
                    seagull.vect[1] += cb.vect[1] * 0.4
                    if not cb.special:
                        self.cannonballs.remove(cb)
                        self.cannonball_sprites.remove(cb)
                    break

        collisions = PixelPerfect.groupcollide_pp(self.cannonball_sprites,
                                                  self.pirate_sprites, 0, 0)

        for cb in dict.keys(collisions):
            for pirate in collisions[cb]:
                # cb.vect hack for preventing pirates from killing each other
                if not pirate.dying and cb.vect[0] > 0:
                    if (Variables.sound):
                        Mine.sound.play()  # Umm... the mine has a nice sound.
                    self.score.add(25)
                    pirate.damage()
                    for i in range(6):
                        self.particles.add_wood_particle(
                            (pirate.rect.centerx + rrr(-0, 15),
                             pirate.rect.centery + rrr(-10, 20)))
                    if not cb.special:
                        self.cannonballs.remove(cb)
                        self.cannonball_sprites.remove(cb)
                    break

        if self.titanic:
            collisions = PixelPerfect.spritecollide_pp(self.titanic,
                                                       self.cannonball_sprites,
                                                       0)
            for cb in collisions:
                if not self.titanic.dying and cb.vect[0] > 0:
                    if (Variables.sound):
                        Mine.sound.play()
                    if cb.special:
                        #special round is hard to fire, so lets reward our crafty player
                        self.titanic.damage(12)
                        self.score.add(100)
                    else:
                        self.score.add(7)
                        self.titanic.damage()
                    self.cannonballs.remove(cb)
                    self.cannonball_sprites.remove(cb)
                    break

    def update_enemies(self):
        self.mine_sprites.update()
        for mine in self.mines:
            if mine.exploding:
                if mine.explode_frames == 0:
                    self.mines.remove(mine)
                    self.mine_sprites.remove(mine)
                # this should really be done in the Mine class, but oh well, here's some explosion effects:
                if Variables.particles:
                    self.particles.add_explosion_particle(
                        (mine.rect.centerx,
                         mine.rect.top + mine.image.get_rect().centerx))
                    self.particles.add_debris_particle(
                        (mine.rect.centerx,
                         mine.rect.top + mine.image.get_rect().centerx))
            if mine.rect.right < self.screen.get_rect().left:
                self.mines.remove(mine)
                self.mine_sprites.remove(mine)

        self.shark_sprites.update()
        for shark in self.sharks:
            if shark.dying:
                if Variables.particles:
                    self.particles.add_blood_particle(shark.rect.center)
            if shark.rect.right < self.screen.get_rect().left or shark.dead:
                self.sharks.remove(shark)
                self.shark_sprites.remove(shark)

        self.pirate_sprites.update()
        for pirate in self.pirates:
            if pirate.t % 50 == 0 and not pirate.dying:
                # Pirate shoots, this should probably be handled by the Pirateboat class
                cb = Cannonball(pirate.rect, pirate.angle, left=True)
                self.cannonballs.append(cb)
                self.cannonball_sprites.add(cb)
                particle_point = pirate.get_point((0.0, 10.0))
                particle_point[0] += pirate.rect.centerx
                particle_point[1] += pirate.rect.centery
                for i in xrange(4):
                    self.particles.add_fire_steam_particle(particle_point)

            if pirate.rect.right < self.screen.get_rect().left or pirate.dead:
                self.pirates.remove(pirate)
                self.pirate_sprites.remove(pirate)
            elif pirate.dying:
                if Variables.particles:
                    self.particles.add_explosion_particle(
                        (pirate.rect.centerx, pirate.rect.centery))
                    self.particles.add_wood_particle(
                        (pirate.rect.centerx, pirate.rect.centery))

        if self.titanic:
            self.titanic.update()
            if self.titanic.t % 100 == 0 and not self.titanic.dying:
                for i in xrange(3):
                    cb = Cannonball(self.titanic.rect,
                                    self.titanic.angle + (i - 1) * 10 - 50,
                                    left=True)
                    self.cannonballs.append(cb)
                    self.cannonball_sprites.add(cb)
            elif self.titanic.t % 100 == 50 and not self.titanic.dying:
                for i in xrange(3):
                    cb = Cannonball(self.titanic.rect,
                                    self.titanic.angle + (i - 1) * 10 - 52.5,
                                    left=True)
                    self.cannonballs.append(cb)
                    self.cannonball_sprites.add(cb)
            if self.titanic.dead:
                self.set_gameover("Congratulations!\nYou sunk Titanic!")
                self.titanic = None

        self.seagull_sprites.update()
        for seagull in self.seagulls:
            if seagull.rect.right < 0 or seagull.dead:
                self.seagulls.remove(seagull)
                self.seagull_sprites.remove(seagull)

    def spawn_enemies(self):
        spawns = self.level.get_spawns()
        if spawns[Level.SHARKS]:
            # Make a new shark
            self.sharks.append(Shark())
            self.shark_sprites.add(self.sharks[-1])

        if spawns[Level.PIRATES]:
            # Make a new pirate ship
            self.pirates.append(Pirateboat())
            self.pirate_sprites.add(self.pirates[-1])

        if spawns[Level.MINES]:
            self.mines.append(Mine())
            self.mine_sprites.add(self.mines[-1])

        if spawns[Level.SEAGULLS]:
            self.seagulls.append(Seagull())
            self.seagull_sprites.add(self.seagulls[-1])

        if spawns[Level.TITANIC]:
            self.titanic = Titanic()
            self.titanic_sprite.add(self.titanic)

        if spawns[Level.POWERUPS]:
            self.powerups.append(Powerup())
            self.powerup_sprites.add(self.powerups[-1])
Пример #8
0
class Game:
    sky = None
    
    
    
        

    def __init__(self, screen, endless = False):
        self.screen = screen

        self.sharks = []
        self.shark_sprites = pygame.sprite.Group()

        self.player = Steamboat()
        self.player_sprite = pygame.sprite.Group()
        self.player_sprite.add(self.player)

        self.health = Health()
        self.health_sprite = pygame.sprite.Group()
        self.health_sprite.add(self.health)

        self.damage_count = 0

        self.t = 0

        self.water = Water.global_water
        #Water.global_water = self.water
        self.water_sprite = pygame.sprite.Group()
        self.water_sprite.add(self.water)

        if not Game.sky:
            Game.sky = util.load_image("taivas")
            Game.sky = pygame.transform.scale(self.sky, (SCREEN_WIDTH, SCREEN_HEIGHT))

        self.cannonballs = []
        self.cannonball_sprites = pygame.sprite.Group()

        self.pirates = []
        self.pirate_sprites = pygame.sprite.Group()

        self.titanic = None
        self.titanic_sprite = pygame.sprite.Group()

        self.seagulls = []
        self.seagull_sprites = pygame.sprite.Group()

        self.particles = Particles()
        self.particle_sprite = pygame.sprite.Group()
        self.particle_sprite.add(self.particles)

        self.mines = []
        self.mine_sprites = pygame.sprite.Group()

        self.score = Score()
        self.score_sprite = pygame.sprite.Group()
        self.score_sprite.add(self.score)

        self.powerups = []
        self.powerup_sprites = pygame.sprite.Group()

        self.level = Level(endless)

        self.lastshot = MIN_FIRE_DELAY + 1

        self.gameover = False
        self.gameover_image = None
        self.gameover_rect = None
        self.done = False

        self.pause = False
        self.pause_image = util.bigfont.render("Pause", Variables.alpha, (0,0,0))
        self.pause_rect = self.pause_image.get_rect()
        self.pause_rect.center = self.screen.get_rect().center

        self.spacepressed = None

    def run(self):
        while not self.done:
            if not self.pause:
                if not self.gameover:
                    self.spawn_enemies()

                self.update_enemies()
                self.player.update()
                self.health.update()
                cloud.update()
                for cb in self.cannonballs:
                    if not cb.underwater:
                        #~ particle_point=cb.rect.left, cb.rect.top
                        particle_point = cb.tail_point()
                        self.particles.add_trace_particle(particle_point)
                        particle_point = [particle_point[i] + cb.vect[i]/2 for i in (0,1)]
                        self.particles.add_trace_particle(particle_point)
                    if cb.special and (not cb.underwater or rr()>0.6) :
                        particle_point = cb.tail_point()
                        self.particles.add_explosion_particle(particle_point)
                    und_old=cb.underwater
                    cb.update()
                    if cb.underwater and not und_old:
                        for i in xrange(5):
                            particle_point=cb.rect.right-4.0+rr()*8.0, cb.rect.top+rr()*2.0
                            self.particles.add_water_particle(particle_point)
                    if (cb.rect.right < 0 and cb.vect[0] < 0) or (cb.rect.left > SCREEN_WIDTH and cb.vect[0] > 0) or (cb.rect.top > SCREEN_HEIGHT):
                        self.cannonballs.remove(cb)
                        self.cannonball_sprites.remove(cb)
                self.score.update()

                # Add steam particles
                if Variables.particles:
                    particle_point = self.player.get_point((5.0 + rr() * 9.0, 0))
                    particle_point[0] += self.player.rect.centerx
                    particle_point[1] += self.player.rect.centery
                    if self.spacepressed and self.t > self.spacepressed + FPS * 3:
                        pass
                        #~ self.particles.add_fire_steam_particle(particle_point)
                    else:
                        self.particles.add_steam_particle(particle_point)

                    particle_point = self.player.get_point((19.0 + rr() * 7.0, 5.0))
                    particle_point[0] += self.player.rect.centerx
                    particle_point[1] += self.player.rect.centery
                    if self.spacepressed and self.t > self.spacepressed + FPS * 3:
                        pass
                        #~ self.particles.add_fire_steam_particle(particle_point)
                    else:
                        self.particles.add_steam_particle(particle_point)

                    if self.titanic:
                        for j in xrange(4):
                            particle_point = self.titanic.get_point((49 + rr() * 9.0 + 28 * j, 25))
                            particle_point[0] += self.titanic.rect.centerx
                            particle_point[1] += self.titanic.rect.centery
                            self.particles.add_steam_particle(particle_point)

                    self.particles.update()

                self.water.update()

                if self.player.splash:
                    if Variables.particles:
                        for i in xrange(10):
                            r = rr()
                            x = int(r * self.player.rect.left + (1.0-r) * self.player.rect.right)
                            point = (x, self.water.get_water_level(x))
                            self.particles.add_water_particle(point)
    
                for powerup in self.powerups:
                    powerup.update()
                    if powerup.picked:
                        self.powerups.remove(powerup)
                        self.powerup_sprites.remove(powerup)

                if not self.gameover:
                    self.check_collisions()

                if self.health.hearts_left == 0 and not self.player.dying:
                    self.player.die()

                if self.player.dying and not self.player.dead:
                    if Variables.particles:
                        self.particles.add_explosion_particle((self.player.rect.centerx, self.player.rect.centery))
                        self.particles.add_debris_particle((self.player.rect.centerx, self.player.rect.centery))

                if self.player.dead:
                    #self.done = True
                    self.set_gameover()

                if self.damage_count > 0:
                    self.damage_count -= 1
                self.lastshot += 1
                self.t += 1

            self.draw()

            self.handle_events()

        return self.score.get_score()

    def damage_player(self):
        self.health.damage()
        for i in xrange(10):
            particle_point = self.player.get_point((rr() * 26.0, rr() * 10.0))
            particle_point[0] += self.player.rect.centerx
            particle_point[1] += self.player.rect.centery
            self.particles.add_debris_particle(particle_point)
        self.player.blinks+=12


    def set_gameover(self, message = "Game Over"):
        self.gameover = True
        images = []
        height = 0
        width = 0
        for text in message.split("\n"):
            images.append(util.bigfont.render(text, Variables.alpha, (0,0,0)))
            height += images[-1].get_height()
            if images[-1].get_width() > width:
                width = images[-1].get_width()
        self.gameover_image = pygame.Surface((width, height), SRCALPHA, 32)
        self.gameover_image.fill((0,0,0,0))
        for i in xrange(len(images)):
            rect = images[i].get_rect()
            rect.top = i * images[i].get_height()
            rect.centerx = width / 2
            self.gameover_image.blit(images[i], rect)

        self.gameover_rect = self.gameover_image.get_rect()
        self.gameover_rect.center = self.screen.get_rect().center

    def take_screenshot(self):
        i = 1
        filename = "sshot.tga"
        while os.path.exists(filename):
            i += 1
            filename = "sshot" + str(i) + ".tga"
        
        pygame.image.save(self.screen, filename)
        print "Screenshot saved as " + filename

    def handle_events(self):
        nextframe = False
        framecount = 0
        while not nextframe:
          # wait until there's at least one event in the queue
          #nextframe = True
          pygame.event.post(pygame.event.wait())
          for event in pygame.event.get():
            #event = pygame.event.wait()
            if event.type == QUIT or \
               event.type == KEYDOWN and event.key == K_ESCAPE:
                self.done = True
                nextframe = True
            elif event.type == NEXTFRAME:
                framecount += 1
                nextframe = True
            elif self.gameover:
                if event.type == JOYBUTTONDOWN:
                    self.done = True
                    nextframe = True
                elif event.type == KEYDOWN:
                    self.done = True
                    nextframe = True
                continue
            elif event.type == JOYAXISMOTION:
                if event.axis == 0:
                    if event.value < -0.5:
                        self.player.move_left(True)
                    elif event.value > 0.5:
                        self.player.move_right(True)
                    else:
                        self.player.move_left(False)
                        self.player.move_right(False)
            elif event.type == JOYBUTTONDOWN:
                if event.button == 0:
                    if not self.pause:
                        self.player.jump()
                elif event.button == 1:
                    if not self.pause:
                        if self.lastshot > MIN_FIRE_DELAY and not self.player.dying:
                            cb = Cannonball(self.player.rect, self.player.angle)
                            self.cannonballs.append(cb)
                            self.cannonball_sprites.add(cb)
                            particle_point = self.player.get_point((42.0,10.0))
                            particle_point[0] += self.player.rect.centerx
                            particle_point[1] += self.player.rect.centery
                            for i in xrange(4):
                                self.particles.add_fire_steam_particle(particle_point)
                            self.lastshot = 0
                            self.spacepressed = self.t
                elif event.button == 5:
                    self.take_screenshot()
                elif event.button == 8:
                    self.set_pause()
            elif event.type == KEYDOWN:
                if event.key == K_LEFT:
                    self.player.move_left(True)
                elif event.key == K_RIGHT:
                    self.player.move_right(True)
                elif event.key == K_SPACE:
                    if not self.pause:
                    # Only 3 cannonballs at once
                    # Maximum firing rate set at the top
                        if self.lastshot > MIN_FIRE_DELAY and not self.player.dying:
                            cb = Cannonball(self.player.rect, self.player.angle)
                            self.cannonballs.append(cb)
                            self.cannonball_sprites.add(cb)
                            particle_point = self.player.get_point((42.0,10.0))
                            particle_point[0] += self.player.rect.centerx
                            particle_point[1] += self.player.rect.centery
                            for i in xrange(4):
                                self.particles.add_fire_steam_particle(particle_point)
                            self.lastshot = 0
                            self.spacepressed = self.t
                elif event.key == K_UP:
                    if not self.pause:
                        self.player.jump()
                elif event.key == K_s:
                    self.take_screenshot()
                elif event.key == K_p:
                    self.set_pause()
            elif event.type == KEYUP:
                if event.key == K_LEFT:
                    self.player.move_left(False)
                elif event.key == K_RIGHT:
                    self.player.move_right(False)
                elif event.key == K_SPACE:
                    if not self.pause:
                        if self.spacepressed and self.t > self.spacepressed + FPS * 3 and not self.player.dying:
                            cb = Cannonball(self.player.rect, self.player.angle, special=True)
                            self.cannonballs.append(cb)
                            self.cannonball_sprites.add(cb)
                            particle_point = self.player.get_point((42.0,10.0))
                            particle_point[0] += self.player.rect.centerx
                            particle_point[1] += self.player.rect.centery
                            for i in xrange(30):
                                self.particles.add_fire_steam_particle((particle_point[0]+rrr(-4,4),particle_point[1]+rrr(-3,3)))
                            self.lastshot = 0
                        self.spacepressed = None
            elif event.type == JOYBUTTONUP:
                if event.button == 1:
                    if not self.pause:
                        if self.spacepressed and self.t > self.spacepressed + FPS * 3 and not self.player.dying:
                            cb = Cannonball(self.player.rect, self.player.angle, special=True)
                            self.cannonballs.append(cb)
                            self.cannonball_sprites.add(cb)
                            particle_point = self.player.get_point((42.0,10.0))
                            particle_point[0] += self.player.rect.centerx
                            particle_point[1] += self.player.rect.centery
                            for i in xrange(30):
                                self.particles.add_fire_steam_particle((particle_point[0]+rrr(-4,4),particle_point[1]+rrr(-3,3)))
                            self.lastshot = 0
                        self.spacepressed = None

        #if framecount > 1:
        #    print str(self.t) + ": missed " + str(framecount - 1) + " frames!"

    def set_pause(self):
        self.pause = not self.pause

        #if framecount > 1:
        #    print str(self.t) + ": missed " + str(framecount - 1) + " frames!"

    def set_pause(self):
        self.pause = not self.pause

    def draw(self):
        self.screen.blit(Game.sky, self.screen.get_rect())
        self.health_sprite.draw(self.screen)
        self.score_sprite.draw(self.screen)
        self.player_sprite.draw(self.screen)
        self.powerup_sprites.draw(self.screen)
        self.pirate_sprites.draw(self.screen)
        if self.titanic:
            self.titanic_sprite.draw(self.screen)
        self.seagull_sprites.draw(self.screen)
        cloud.draw(self.screen)
        self.shark_sprites.draw(self.screen)
        self.mine_sprites.draw(self.screen)
        self.cannonball_sprites.draw(self.screen)
        self.water_sprite.draw(self.screen)
        if Variables.particles:
            self.particle_sprite.draw(self.screen)

        if self.pause:
            self.screen.blit(self.pause_image, self.pause_rect)

        if self.gameover:
            self.screen.blit(self.gameover_image, self.gameover_rect)

        if self.level.t < 120:
            image = None
            i = 0
            if self.level.phase < len(self.level.phase_messages):
              for text in self.level.phase_messages[self.level.phase].split("\n"):
                image = util.smallfont.render(text, Variables.alpha, (0,0,0))
                rect = image.get_rect()
                rect.centerx = self.screen.get_rect().centerx
                rect.top = 100 + rect.height * i
                blit_image = pygame.Surface((image.get_width(), image.get_height()))
                blit_image.fill((166,183,250))
                blit_image.set_colorkey((166,183,250))
                blit_image.blit(image, image.get_rect())
                if self.level.t > 60:
                    blit_image.set_alpha(255 - (self.level.t - 60) * 255 / 60)
                self.screen.blit(blit_image, rect)
                i += 1

        pygame.display.flip()



    def check_collisions(self):
        collisions = PixelPerfect.spritecollide_pp(self.player, self.powerup_sprites, 0)
        for powerup in collisions:
            if not powerup.fading:
                if not self.player.dying:
                    self.health.add()
                    powerup.pickup()

        collisions = PixelPerfect.spritecollide_pp(self.player, self.mine_sprites, 0)

        for mine in collisions:
            if not mine.exploding:
                if not self.player.dying:
                    self.damage_player()
                    mine.explode()

        collisions = PixelPerfect.spritecollide_pp(self.player, self.shark_sprites, 0)

        for shark in collisions:
            if not shark.dying:
                if not self.player.dying:
                    self.damage_player()
                    shark.die()

        collisions = PixelPerfect.spritecollide_pp(self.player, self.cannonball_sprites, 0)

        for cb in collisions:
            if not self.player.dying:
                self.damage_player()
                self.cannonballs.remove(cb)
                self.cannonball_sprites.remove(cb)
                if (Variables.sound):
                   Mine.sound.play() # Umm... the mine has a nice explosion sound.

        collisions = PixelPerfect.groupcollide_pp(self.cannonball_sprites, self.shark_sprites, 0, 0)

        for cb in dict.keys(collisions):
            for shark in collisions[cb]:
                # The test on cb.vect is a rude hack preventing cannonballs from pirate ships from killing sharks.
                if not shark.dying and cb.vect[0] > 0:
                    self.score.add(15)
                    shark.die()
                    # give her a part of ball's momentum:
                    shark.dx+=cb.vect[0]*0.6
                    shark.dy+=cb.vect[1]*0.4
                    if not cb.special:
                        self.cannonballs.remove(cb)
                        self.cannonball_sprites.remove(cb)
                    break

        collisions = PixelPerfect.groupcollide_pp(self.cannonball_sprites, self.seagull_sprites, 0, 0)

        for cb in dict.keys(collisions):
            for seagull in collisions[cb]:
                # cb.vect test is a rude hack preventing pirates from killing seagulls
                if not seagull.dying and cb.vect[0] > 0:
                    self.score.add(75)
                    seagull.die()
                    # give her a part of ball's momentum:
                    seagull.vect[0]+=cb.vect[0]*0.4
                    seagull.vect[1]+=cb.vect[1]*0.4
                    if not cb.special:
                        self.cannonballs.remove(cb)
                        self.cannonball_sprites.remove(cb)
                    break

        collisions = PixelPerfect.groupcollide_pp(self.cannonball_sprites, self.pirate_sprites, 0, 0)

        for cb in dict.keys(collisions):
            for pirate in collisions[cb]:
                # cb.vect hack for preventing pirates from killing each other
                if not pirate.dying and cb.vect[0] > 0:
                    if (Variables.sound):
                       Mine.sound.play() # Umm... the mine has a nice sound.
                    self.score.add(25)
                    pirate.damage()
                    for i in range(6):
                        self.particles.add_wood_particle((pirate.rect.centerx+rrr(-0,15), pirate.rect.centery+rrr(-10,20)))
                    if not cb.special:
                        self.cannonballs.remove(cb)
                        self.cannonball_sprites.remove(cb)
                    break

        if self.titanic:
            collisions = PixelPerfect.spritecollide_pp(self.titanic, self.cannonball_sprites, 0)
            for cb in collisions:
                if not self.titanic.dying and cb.vect[0] > 0:
                    if (Variables.sound):
                       Mine.sound.play()
                    if cb.special: 
                        #special round is hard to fire, so lets reward our crafty player
                        self.titanic.damage(12)
                        self.score.add(100)
                    else:
                        self.score.add(7)
                        self.titanic.damage()
                    self.cannonballs.remove(cb)
                    self.cannonball_sprites.remove(cb)
                    break

    def update_enemies(self):
        self.mine_sprites.update()
        for mine in self.mines:
            if mine.exploding:
                if mine.explode_frames == 0:
                    self.mines.remove(mine)
                    self.mine_sprites.remove(mine)
                # this should really be done in the Mine class, but oh well, here's some explosion effects:
                if Variables.particles:
                    self.particles.add_explosion_particle((mine.rect.centerx, mine.rect.top + mine.image.get_rect().centerx))
                    self.particles.add_debris_particle((mine.rect.centerx, mine.rect.top + mine.image.get_rect().centerx))
            if mine.rect.right < self.screen.get_rect().left:
                self.mines.remove(mine)
                self.mine_sprites.remove(mine)

        self.shark_sprites.update()
        for shark in self.sharks:
            if shark.dying:
                if Variables.particles:
                    self.particles.add_blood_particle(shark.rect.center)
            if shark.rect.right < self.screen.get_rect().left or shark.dead:
                self.sharks.remove(shark)
                self.shark_sprites.remove(shark)

        self.pirate_sprites.update()
        for pirate in self.pirates:
            if pirate.t % 50 == 0 and not pirate.dying:
                # Pirate shoots, this should probably be handled by the Pirateboat class
                cb = Cannonball(pirate.rect, pirate.angle, left = True)
                self.cannonballs.append(cb)
                self.cannonball_sprites.add(cb)
                particle_point = pirate.get_point((0.0,10.0))
                particle_point[0] += pirate.rect.centerx
                particle_point[1] += pirate.rect.centery
                for i in xrange(4):
                    self.particles.add_fire_steam_particle(particle_point)
                
            if pirate.rect.right < self.screen.get_rect().left or pirate.dead:
                self.pirates.remove(pirate)
                self.pirate_sprites.remove(pirate)
            elif pirate.dying:
                if Variables.particles:
                    self.particles.add_explosion_particle((pirate.rect.centerx, pirate.rect.centery))
                    self.particles.add_wood_particle((pirate.rect.centerx, pirate.rect.centery))

        if self.titanic:
            self.titanic.update()
            if self.titanic.t % 100 == 0 and not self.titanic.dying:
                for i in xrange(3):
                    cb = Cannonball(self.titanic.rect, self.titanic.angle + (i-1)*10 - 50, left = True)
                    self.cannonballs.append(cb)
                    self.cannonball_sprites.add(cb)
            elif self.titanic.t % 100 == 50 and not self.titanic.dying:
                for i in xrange(3):
                    cb = Cannonball(self.titanic.rect, self.titanic.angle + (i-1)*10 - 52.5, left = True)
                    self.cannonballs.append(cb)
                    self.cannonball_sprites.add(cb)
            if self.titanic.dead:
                self.set_gameover("Congratulations!\nYou sunk Titanic!")
                self.titanic = None

        self.seagull_sprites.update()
        for seagull in self.seagulls:
            if seagull.rect.right < 0 or seagull.dead:
                self.seagulls.remove(seagull)
                self.seagull_sprites.remove(seagull)

    def spawn_enemies(self):
        spawns = self.level.get_spawns()
        if spawns[Level.SHARKS]:
            # Make a new shark
            self.sharks.append(Shark())
            self.shark_sprites.add(self.sharks[-1])

        if spawns[Level.PIRATES]:
            # Make a new pirate ship
            self.pirates.append(Pirateboat())
            self.pirate_sprites.add(self.pirates[-1])

        if spawns[Level.MINES]:
            self.mines.append(Mine())
            self.mine_sprites.add(self.mines[-1])

        if spawns[Level.SEAGULLS]:
            self.seagulls.append(Seagull())
            self.seagull_sprites.add(self.seagulls[-1])

        if spawns[Level.TITANIC]:
            self.titanic = Titanic()
            self.titanic_sprite.add(self.titanic)

        if spawns[Level.POWERUPS]:
            self.powerups.append(Powerup())
            self.powerup_sprites.add(self.powerups[-1])
Пример #9
0
def new_tinker_player(game_state):
    player = new_player(game_state)
    player.set_child(Health(15))
    player.set_child(DataPoint(DataTypes.CLASS, Class.GUNSLINGER))
    return player
Пример #10
0
def new_knight_player(game_state):
    player = new_player(game_state)
    player.set_child(Health(25))
    player.set_child(DataPoint(DataTypes.CLASS, Class.KNIGHT))
    return player
Пример #11
0
def new_rogue_player(game_state):
    player = new_player(game_state)
    player.set_child(Health(20))
    player.set_child(DataPoint(DataTypes.CLASS, Class.ROGUE))
    return player
Пример #12
0
    def __init__(self,
                 screen,
                 usealpha=True,
                 noparticles=False,
                 endless=False):
        self.screen = screen
        self.usealpha = usealpha
        self.noparticles = noparticles

        self.sharks = []
        self.shark_sprites = pygame.sprite.Group()

        self.player = Steamboat()
        self.player_sprite = pygame.sprite.Group()
        self.player_sprite.add(self.player)

        self.health = Health()
        self.health_sprite = pygame.sprite.Group()
        self.health_sprite.add(self.health)

        self.damage_count = 0

        self.t = 0

        self.water = Water.global_water  #Water(self.usealpha)
        #Water.global_water = self.water
        self.water_sprite = pygame.sprite.Group()
        self.water_sprite.add(self.water)

        self.sky = util.load_image("taivas")
        self.sky = pygame.transform.scale(self.sky,
                                          (SCREEN_WIDTH, SCREEN_HEIGHT))

        self.cannonballs = []
        self.cannonball_sprites = pygame.sprite.Group()

        self.pirates = []
        self.pirate_sprites = pygame.sprite.Group()

        self.titanic = None
        self.titanic_sprite = pygame.sprite.Group()

        self.seagulls = []
        self.seagull_sprites = pygame.sprite.Group()

        self.particles = Particles(self.usealpha)
        self.particle_sprite = pygame.sprite.Group()
        self.particle_sprite.add(self.particles)

        self.mines = []
        self.mine_sprites = pygame.sprite.Group()

        self.score = Score()
        self.score_sprite = pygame.sprite.Group()
        self.score_sprite.add(self.score)

        self.powerups = []
        self.powerup_sprites = pygame.sprite.Group()

        self.level = Level(endless)

        self.lastshot = MIN_FIRE_DELAY + 1

        self.gameover = False
        self.gameover_image = None
        self.gameover_rect = None
        self.done = False

        self.pause = False
        font = util.load_font(
            "Cosmetica",
            40)  #pygame.font.Font(pygame.font.get_default_font(), 36)
        self.pause_image = font.render("Pause", True, (0, 0, 0))
        self.pause_rect = self.pause_image.get_rect()
        self.pause_rect.center = self.screen.get_rect().center
Пример #13
0
class Game:
    def __init__(self,
                 screen,
                 usealpha=True,
                 noparticles=False,
                 endless=False):
        self.screen = screen
        self.usealpha = usealpha
        self.noparticles = noparticles

        self.sharks = []
        self.shark_sprites = pygame.sprite.Group()

        self.player = Steamboat()
        self.player_sprite = pygame.sprite.Group()
        self.player_sprite.add(self.player)

        self.health = Health()
        self.health_sprite = pygame.sprite.Group()
        self.health_sprite.add(self.health)

        self.damage_count = 0

        self.t = 0

        self.water = Water.global_water  #Water(self.usealpha)
        #Water.global_water = self.water
        self.water_sprite = pygame.sprite.Group()
        self.water_sprite.add(self.water)

        self.sky = util.load_image("taivas")
        self.sky = pygame.transform.scale(self.sky,
                                          (SCREEN_WIDTH, SCREEN_HEIGHT))

        self.cannonballs = []
        self.cannonball_sprites = pygame.sprite.Group()

        self.pirates = []
        self.pirate_sprites = pygame.sprite.Group()

        self.titanic = None
        self.titanic_sprite = pygame.sprite.Group()

        self.seagulls = []
        self.seagull_sprites = pygame.sprite.Group()

        self.particles = Particles(self.usealpha)
        self.particle_sprite = pygame.sprite.Group()
        self.particle_sprite.add(self.particles)

        self.mines = []
        self.mine_sprites = pygame.sprite.Group()

        self.score = Score()
        self.score_sprite = pygame.sprite.Group()
        self.score_sprite.add(self.score)

        self.powerups = []
        self.powerup_sprites = pygame.sprite.Group()

        self.level = Level(endless)

        self.lastshot = MIN_FIRE_DELAY + 1

        self.gameover = False
        self.gameover_image = None
        self.gameover_rect = None
        self.done = False

        self.pause = False
        font = util.load_font(
            "Cosmetica",
            40)  #pygame.font.Font(pygame.font.get_default_font(), 36)
        self.pause_image = font.render("Pause", True, (0, 0, 0))
        self.pause_rect = self.pause_image.get_rect()
        self.pause_rect.center = self.screen.get_rect().center

    def run(self):
        while not self.done:
            if not self.pause:
                if not self.gameover:
                    self.spawn_enemies()

                self.update_enemies()
                self.player.update()
                self.health.update()
                cloud.update()
                for cb in self.cannonballs:
                    cb.update()
                    if (cb.rect.right < 0
                            and cb.vect[0] < 0) or (cb.rect.left > SCREEN_WIDTH
                                                    and cb.vect[0] > 0):
                        self.cannonballs.remove(cb)
                        self.cannonball_sprites.remove(cb)
                self.score.update()

                # Add steam particles
                if not self.noparticles:
                    for i in range(3):
                        particle_point = self.player.get_point(
                            (5.0 + random.random() * 9.0, 0))
                        particle_point[0] += self.player.rect.centerx
                        particle_point[1] += self.player.rect.centery
                        self.particles.add_steam_particle(particle_point)

                    for i in range(3):
                        particle_point = self.player.get_point(
                            (19.0 + random.random() * 7.0, 5.0))
                        particle_point[0] += self.player.rect.centerx
                        particle_point[1] += self.player.rect.centery
                        self.particles.add_steam_particle(particle_point)

                    if self.titanic:
                        for j in range(4):
                            for i in range(3):
                                particle_point = self.titanic.get_point(
                                    (49 + random.random() * 9.0 + 28 * j, 25))
                                particle_point[0] += self.titanic.rect.centerx
                                particle_point[1] += self.titanic.rect.centery
                                self.particles.add_steam_particle(
                                    particle_point)

                    self.particles.update()

                self.water.update()

                if self.player.splash:
                    if not self.noparticles:
                        for i in range(30):
                            r = random.random()
                            x = int(r * self.player.rect.left +
                                    (1.0 - r) * self.player.rect.right)
                            point = (x, self.water.get_water_level(x))
                            self.particles.add_water_particle(point)

                for powerup in self.powerups:
                    powerup.update()
                    if powerup.picked:
                        self.powerups.remove(powerup)
                        self.powerup_sprites.remove(powerup)

                if not self.gameover:
                    self.check_collisions()

                if self.health.hearts_left == 0 and not self.player.dying:
                    self.player.die()

                if self.player.dying and not self.player.dead:
                    if not self.noparticles:
                        for i in range(3):
                            self.particles.add_explosion_particle(
                                (self.player.rect.centerx,
                                 self.player.rect.centery))
                            self.particles.add_debris_particle(
                                (self.player.rect.centerx,
                                 self.player.rect.centery))

                if self.player.dead:
                    #self.done = True
                    self.set_gameover()

                if self.damage_count > 0:
                    self.damage_count -= 1
                self.lastshot += 1
                self.t += 1

            self.draw()

            self.handle_events()

        return self.score.get_score()

    def set_gameover(self, message="Game Over"):
        self.gameover = True
        images = []
        font = util.load_font(
            "Cosmetica",
            40)  #pygame.font.Font(pygame.font.get_default_font(), 36)
        height = 0
        width = 0
        for text in message.split("\n"):
            images.append(font.render(text, True, (0, 0, 0)))
            height += images[-1].get_height()
            if images[-1].get_width() > width:
                width = images[-1].get_width()
        self.gameover_image = pygame.Surface((width, height), SRCALPHA, 32)
        self.gameover_image.fill((0, 0, 0, 0))
        for i in range(len(images)):
            rect = images[i].get_rect()
            rect.top = i * images[i].get_height()
            rect.centerx = width / 2
            self.gameover_image.blit(images[i], rect)

        self.gameover_rect = self.gameover_image.get_rect()
        self.gameover_rect.center = self.screen.get_rect().center

    def handle_events(self):
        nextframe = False
        framecount = 0
        while not nextframe:
            # wait until there's at least one event in the queue
            pygame.event.post(pygame.event.wait())
            for event in pygame.event.get():
                #event = pygame.event.wait()
                if event.type == QUIT or \
                   event.type == KEYDOWN and event.key == K_ESCAPE:
                    self.done = True
                    nextframe = True
                elif event.type == NEXTFRAME:
                    nextframe = True
                    framecount += 1
                elif self.gameover:
                    if event.type == JOYBUTTONDOWN:
                        self.done = True
                        nextframe = True
                    elif event.type == KEYDOWN:
                        self.done = True
                        nextframe = True
                    continue
                elif event.type == JOYAXISMOTION:
                    if event.axis == 0:
                        if event.value < -0.5:
                            self.player.move_left(True)
                        elif event.value > 0.5:
                            self.player.move_right(True)
                        else:
                            self.player.move_left(False)
                            self.player.move_right(False)
                elif event.type == JOYBUTTONDOWN:
                    if event.button == 0:
                        if not self.pause:
                            self.player.jump()
                    elif event.button == 1:
                        if not self.pause:
                            if self.lastshot > MIN_FIRE_DELAY and not self.player.dying:
                                cb = Cannonball(self.player.rect,
                                                self.player.angle)
                                self.cannonballs.append(cb)
                                self.cannonball_sprites.add(cb)
                                self.lastshot = 0
                    elif event.button == 5:
                        pygame.image.save(self.screen, "sshot.tga")
                        print "Screenshot saved as sshot.tga"
                    elif event.button == 8:
                        self.set_pause()
                elif event.type == KEYDOWN:
                    if event.key == K_LEFT:
                        self.player.move_left(True)
                    elif event.key == K_RIGHT:
                        self.player.move_right(True)
                    elif event.key == K_SPACE:
                        if not self.pause:
                            # Only 3 cannonballs at once
                            # Maximum firing rate set at the top
                            if self.lastshot > MIN_FIRE_DELAY and not self.player.dying:
                                cb = Cannonball(self.player.rect,
                                                self.player.angle)
                                self.cannonballs.append(cb)
                                self.cannonball_sprites.add(cb)
                                self.lastshot = 0
                    elif event.key == K_UP:
                        if not self.pause:
                            self.player.jump()
                    elif event.key == K_s:
                        pygame.image.save(self.screen, "sshot.tga")
                        print "Screenshot saved as sshot.tga"
                    elif event.key == K_p:
                        self.set_pause()
                elif event.type == KEYUP:
                    if event.key == K_LEFT:
                        self.player.move_left(False)
                    elif event.key == K_RIGHT:
                        self.player.move_right(False)

        #if framecount > 1:
        #    print "Missed " + str(framecount - 1) + " frames!"

    def set_pause(self):
        self.pause = not self.pause

    def draw(self):
        self.screen.blit(self.sky, self.screen.get_rect())
        self.health_sprite.draw(self.screen)
        self.score_sprite.draw(self.screen)
        self.player_sprite.draw(self.screen)
        self.powerup_sprites.draw(self.screen)
        self.pirate_sprites.draw(self.screen)
        if self.titanic:
            self.titanic_sprite.draw(self.screen)
        self.seagull_sprites.draw(self.screen)
        cloud.draw(self.screen)
        self.shark_sprites.draw(self.screen)
        self.mine_sprites.draw(self.screen)
        self.cannonball_sprites.draw(self.screen)
        self.water_sprite.draw(self.screen)
        if not self.noparticles:
            self.particle_sprite.draw(self.screen)

        if self.pause:
            self.screen.blit(self.pause_image, self.pause_rect)

        if self.gameover:
            self.screen.blit(self.gameover_image, self.gameover_rect)

        if self.level.t < 120:
            font = util.load_font("Cosmetica", 16)
            image = None
            i = 0
            if self.level.phase < len(self.level.phase_messages):
                for text in self.level.phase_messages[self.level.phase].split(
                        "\n"):
                    image = font.render(text, True, (0, 0, 0))
                    rect = image.get_rect()
                    rect.centerx = self.screen.get_rect().centerx
                    rect.top = 100 + rect.height * i
                    blit_image = pygame.Surface(
                        (image.get_width(), image.get_height()))
                    blit_image.fill((166, 183, 250))
                    blit_image.set_colorkey((166, 183, 250))
                    blit_image.blit(image, image.get_rect())
                    if self.level.t > 60:
                        blit_image.set_alpha(255 -
                                             (self.level.t - 60) * 255 / 60)
                    self.screen.blit(blit_image, rect)
                    i += 1

        pygame.display.flip()

    def check_collisions(self):
        collisions = PixelPerfect.spritecollide_pp(self.player,
                                                   self.powerup_sprites, 0)
        for powerup in collisions:
            if not powerup.fading:
                if not self.player.dying:
                    self.health.add()
                    powerup.pickup()

        collisions = PixelPerfect.spritecollide_pp(self.player,
                                                   self.mine_sprites, 0)

        for mine in collisions:
            if not mine.exploding:
                if not self.player.dying:
                    self.health.damage()
                    mine.explode()

        collisions = PixelPerfect.spritecollide_pp(self.player,
                                                   self.shark_sprites, 0)

        for shark in collisions:
            if not shark.dying:
                if not self.player.dying:
                    self.health.damage()
                    shark.die()

        collisions = PixelPerfect.spritecollide_pp(self.player,
                                                   self.cannonball_sprites, 0)

        for cb in collisions:
            if not self.player.dying:
                self.health.damage()
                self.cannonballs.remove(cb)
                self.cannonball_sprites.remove(cb)
                Mine.sound.play(
                )  # Umm... the mine has a nice explosion sound.

        collisions = PixelPerfect.groupcollide_pp(self.cannonball_sprites,
                                                  self.shark_sprites, 0, 0)

        for cb in dict.keys(collisions):
            for shark in collisions[cb]:
                # The test on cb.vect is a rude hack preventing cannonballs from pirate ships from killing sharks.
                if not shark.dying and cb.vect[0] > 0:
                    self.score.add(15)
                    shark.die()
                    self.cannonballs.remove(cb)
                    self.cannonball_sprites.remove(cb)
                    break

        collisions = PixelPerfect.groupcollide_pp(self.cannonball_sprites,
                                                  self.seagull_sprites, 0, 0)

        for cb in dict.keys(collisions):
            for seagull in collisions[cb]:
                # cb.vect test is a rude hack preventing pirates from killing seagulls
                if not seagull.dying and cb.vect[0] > 0:
                    self.score.add(75)
                    seagull.die()
                    self.cannonballs.remove(cb)
                    self.cannonball_sprites.remove(cb)
                    break

        collisions = PixelPerfect.groupcollide_pp(self.cannonball_sprites,
                                                  self.pirate_sprites, 0, 0)

        for cb in dict.keys(collisions):
            for pirate in collisions[cb]:
                # cb.vect hack for preventing pirates from killing each other
                if not pirate.dying and cb.vect[0] > 0:
                    Mine.sound.play()  # Umm... the mine has a nice sound.
                    self.score.add(25)
                    pirate.damage()
                    self.cannonballs.remove(cb)
                    self.cannonball_sprites.remove(cb)
                    break

        if self.titanic:
            collisions = PixelPerfect.spritecollide_pp(self.titanic,
                                                       self.cannonball_sprites,
                                                       0)
            for cb in collisions:
                if not self.titanic.dying and cb.vect[0] > 0:
                    Mine.sound.play()
                    self.score.add(7)
                    self.titanic.damage()
                    self.cannonballs.remove(cb)
                    self.cannonball_sprites.remove(cb)
                    break

    def update_enemies(self):
        for mine in self.mines:
            mine.update()
            if mine.exploding:
                if mine.explode_frames == 0:
                    self.mines.remove(mine)
                    self.mine_sprites.remove(mine)
                # this should really be done in the Mine class, but oh well, here's some explosion effects:
                if not self.noparticles:
                    for i in range(3):
                        self.particles.add_explosion_particle(
                            (mine.rect.centerx,
                             mine.rect.top + mine.image.get_rect().centerx))
                        self.particles.add_debris_particle(
                            (mine.rect.centerx,
                             mine.rect.top + mine.image.get_rect().centerx))
            if mine.rect.right < self.screen.get_rect().left:
                self.mines.remove(mine)
                self.mine_sprites.remove(mine)

        for shark in self.sharks:
            shark.update()
            if shark.dying:
                if not self.noparticles:
                    self.particles.add_blood_particle(shark.rect.center)
            if shark.rect.right < self.screen.get_rect().left or shark.dead:
                self.sharks.remove(shark)
                self.shark_sprites.remove(shark)

        for pirate in self.pirates:
            pirate.update()
            if pirate.t % 50 == 0 and not pirate.dying:
                # Pirate shoots, this should probably be handled by the Pirateboat class
                cb = Cannonball(pirate.rect, pirate.angle, left=True)
                self.cannonballs.append(cb)
                self.cannonball_sprites.add(cb)
            if pirate.rect.right < self.screen.get_rect().left or pirate.dead:
                self.pirates.remove(pirate)
                self.pirate_sprites.remove(pirate)
            elif pirate.dying:
                if not self.noparticles:
                    for i in range(3):
                        self.particles.add_explosion_particle(
                            (pirate.rect.centerx, pirate.rect.centery))
                        self.particles.add_wood_particle(
                            (pirate.rect.centerx, pirate.rect.centery))

        if self.titanic:
            self.titanic.update()
            if self.titanic.t % 100 == 0 and not self.titanic.dying:
                for i in range(3):
                    cb = Cannonball(self.titanic.rect,
                                    self.titanic.angle + (i - 1) * 10 - 50,
                                    left=True)
                    self.cannonballs.append(cb)
                    self.cannonball_sprites.add(cb)
            elif self.titanic.t % 100 == 50 and not self.titanic.dying:
                for i in range(3):
                    cb = Cannonball(self.titanic.rect,
                                    self.titanic.angle + (i - 1) * 10 - 60,
                                    left=True)
                    self.cannonballs.append(cb)
                    self.cannonball_sprites.add(cb)
            if self.titanic.dead:
                self.set_gameover("Congratulations!\nYou sunk Titanic!")
                self.titanic = None

        for seagull in self.seagulls:
            seagull.update()
            if seagull.rect.right < 0 or seagull.dead:
                self.seagulls.remove(seagull)
                self.seagull_sprites.remove(seagull)

    def spawn_enemies(self):
        spawns = self.level.get_spawns()
        if spawns[Level.SHARKS]:
            # Make a new shark
            self.sharks.append(Shark())
            self.shark_sprites.add(self.sharks[-1])

        if spawns[Level.PIRATES]:
            # Make a new pirate ship
            self.pirates.append(Pirateboat())
            self.pirate_sprites.add(self.pirates[-1])

        if spawns[Level.MINES]:
            self.mines.append(Mine())
            self.mine_sprites.add(self.mines[-1])

        if spawns[Level.SEAGULLS]:
            self.seagulls.append(Seagull())
            self.seagull_sprites.add(self.seagulls[-1])

        if spawns[Level.TITANIC]:
            self.titanic = Titanic()
            self.titanic_sprite.add(self.titanic)

        if spawns[Level.POWERUPS]:
            self.powerups.append(Powerup())
            self.powerup_sprites.add(self.powerups[-1])
Пример #14
0
    def __init__(self, screen, usealpha = True, noparticles = False, endless = False):
        self.screen = screen
        self.usealpha = usealpha
        self.noparticles = noparticles

        self.sharks = []
        self.shark_sprites = pygame.sprite.Group()

        self.player = Steamboat()
        self.player_sprite = pygame.sprite.Group()
        self.player_sprite.add(self.player)

        self.health = Health()
        self.health_sprite = pygame.sprite.Group()
        self.health_sprite.add(self.health)

        self.damage_count = 0

        self.t = 0

        self.water = Water.global_water #Water(self.usealpha)
        #Water.global_water = self.water
        self.water_sprite = pygame.sprite.Group()
        self.water_sprite.add(self.water)

        self.sky = util.load_image("taivas")
        self.sky = pygame.transform.scale(self.sky, (SCREEN_WIDTH, SCREEN_HEIGHT))

        self.pause_icon = util.load_image("pause")
        
        self.cannonballs = []
        self.cannonball_sprites = pygame.sprite.Group()

        self.pirates = []
        self.pirate_sprites = pygame.sprite.Group()

        self.titanic = None
        self.titanic_sprite = pygame.sprite.Group()

        self.seagulls = []
        self.seagull_sprites = pygame.sprite.Group()

        self.particles = Particles(self.usealpha)
        self.particle_sprite = pygame.sprite.Group()
        self.particle_sprite.add(self.particles)

        self.mines = []
        self.mine_sprites = pygame.sprite.Group()

        self.score = Score()
        self.score_sprite = pygame.sprite.Group()
        self.score_sprite.add(self.score)

        self.powerups = []
        self.powerup_sprites = pygame.sprite.Group()

        self.level = Level(endless)
        self.cheat_current = 0
        
        self.lastshot = MIN_FIRE_DELAY + 1

        self.gameover = False
        self.gameover_image = None
        self.gameover_rect = None
        self.done = False

        self.pause = False
        font = util.load_font("Cosmetica", 40) #pygame.font.Font(pygame.font.get_default_font(), 36)
        self.pause_image = font.render("Pause", True, (0,0,0))
        self.pause_rect = self.pause_image.get_rect()
        self.pause_rect.center = self.screen.get_rect().center
Пример #15
0
    def __init__(self, screen, gamepad, endless=False):
        self.screen = screen
        self.gamepad = gamepad

        self.sharks = []
        self.shark_sprites = pygame.sprite.Group()

        self.player = Steamboat()
        self.player_sprite = pygame.sprite.Group()
        self.player_sprite.add(self.player)

        self.health = Health()
        self.health_sprite = pygame.sprite.Group()
        self.health_sprite.add(self.health)

        self.damage_count = 0

        self.t = 0

        self.water = Water.global_water
        #Water.global_water = self.water
        self.water_sprite = pygame.sprite.Group()
        self.water_sprite.add(self.water)

        if not Game.sky:
            Game.sky = util.load_image("taivas")
            Game.sky = pygame.transform.scale(self.sky,
                                              (SCREEN_WIDTH, SCREEN_HEIGHT))

        self.cannonballs = []
        self.cannonball_sprites = pygame.sprite.Group()

        self.pirates = []
        self.pirate_sprites = pygame.sprite.Group()

        self.titanic = None
        self.titanic_sprite = pygame.sprite.Group()

        self.seagulls = []
        self.seagull_sprites = pygame.sprite.Group()

        self.particles = Particles()
        self.particle_sprite = pygame.sprite.Group()
        self.particle_sprite.add(self.particles)

        self.mines = []
        self.mine_sprites = pygame.sprite.Group()

        self.score = Score()
        self.score_sprite = pygame.sprite.Group()
        self.score_sprite.add(self.score)

        self.powerups = []
        self.powerup_sprites = pygame.sprite.Group()

        self.level = Level(endless)

        self.lastshot = MIN_FIRE_DELAY + 1

        self.gameover = False
        self.gameover_image = None
        self.gameover_rect = None
        self.done = False

        self.pause = False
        self.pause_image = util.bigfont.render("Pause", Variables.alpha,
                                               (0, 0, 0))
        self.pause_rect = self.pause_image.get_rect()
        self.pause_rect.center = self.screen.get_rect().center

        self.spacepressed = None
Пример #16
0
 def __init__(self, position):
     Controllable.__init__(self, 0, position, 0)
     Collideable.__init__(self, Settings.PLAYER_SIZE)
     Health.__init__(self, Settings.PLAYER_HEALTH)
     self.score = 0
     self.ray_data = []
def game():

    background = "background.jpg"
    background = pygame.image.load(background).convert()

    screen.blit(background, (0, 0))

    """Create all Groups"""
    allSprites = pygame.sprite.OrderedUpdates()
    enemyGroup = pygame.sprite.Group()

    playerTank = PlayerTank(screen, (320, 480), allSprites, enemyGroup)
    PlayerTurret = playerTurret(screen, playerTank, allSprites, enemyGroup)
    scoreboard = Keeper()

    crate = Crate(screen, (200, 200), playerTank, scoreboard)
    enemyTankC = EnemyTank2(screen, (600, 900), crate, scoreboard)

    """Enemy Sprites"""
    EnemyTankA = enemyTankA(screen, (200, 200), playerTank, scoreboard)
    EnemyTurretA = enemyTurretA( screen, playerTank, EnemyTankA, scoreboard, allSprites)

    EnemyTankB = enemyTankA(screen, (560, 880), enemyTankC, scoreboard)
    EnemyTurretB = enemyTurretA( screen, playerTank, EnemyTankB, scoreboard, allSprites)

    EnemyTankD = enemyTankD(screen, (560, 880), playerTank, scoreboard)
    EnemyTurretD = enemyTurretD( screen, playerTank, EnemyTankD, scoreboard, allSprites)

    enemyGroup.add(EnemyTankA)
    #enemyGroup.add(EnemyTurretA)
    enemyGroup.add(EnemyTankB)
    #enemyGroup.add(EnemyTurretB)
    enemyGroup.add(enemyTankC)
    #enemyGroup.add(EnemyTurretD)
    enemyGroup.add(EnemyTankD)

    health = Health(screen, scoreboard, playerTank)

    """adds sprites to there groups"""
    allSprites.add(crate)
    allSprites.add(scoreboard)
    allSprites.add(health)

    allSprites.add(playerTank)
    allSprites.add(PlayerTurret)

    allSprites.add(EnemyTankA)
    allSprites.add(EnemyTurretA)
    allSprites.add(EnemyTankB)
    allSprites.add(EnemyTurretB)
    allSprites.add(enemyTankC)

    allSprites.add(EnemyTankD)
    allSprites.add(EnemyTurretD)

    clock = pygame.time.Clock()
    keepGoing = True
    while (keepGoing == True):
        clock.tick(30)

        keys = pygame.key.get_pressed()
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                keepGoing = False
                donePlaying = True
            if event.type == pygame.MOUSEBUTTONDOWN:
                if event.button==1:
                    if PlayerTurret.playerShellPower>=60:
                        FShell = fShell((PlayerTurret.x, PlayerTurret.y), PlayerTurret.dir, enemyGroup)
                        PlayerTurret.allSprites.add(FShell)
                        PlayerTurret.playerShellPower = 0
        PlayerTurret.playerShellPower+=1

        """update clear and draw all sprites"""
        allSprites.clear(screen, background)
        allSprites.update()
        allSprites.draw(screen)

        pygame.display.flip()
        pygame.display.update()
        if scoreboard.health <=0:
            keepGoing = False

    score = scoreboard.score
Пример #18
0
    def __init__(self, screen, endless = False):
        self.screen = screen

        self.sharks = []
        self.shark_sprites = pygame.sprite.Group()

        self.player = Steamboat()
        self.player_sprite = pygame.sprite.Group()
        self.player_sprite.add(self.player)

        self.health = Health()
        self.health_sprite = pygame.sprite.Group()
        self.health_sprite.add(self.health)

        self.damage_count = 0

        self.t = 0

        self.water = Water.global_water
        #Water.global_water = self.water
        self.water_sprite = pygame.sprite.Group()
        self.water_sprite.add(self.water)

        if not Game.sky:
            Game.sky = util.load_image("taivas")
            Game.sky = pygame.transform.scale(self.sky, (SCREEN_WIDTH, SCREEN_HEIGHT))

        self.cannonballs = []
        self.cannonball_sprites = pygame.sprite.Group()

        self.pirates = []
        self.pirate_sprites = pygame.sprite.Group()

        self.titanic = None
        self.titanic_sprite = pygame.sprite.Group()

        self.seagulls = []
        self.seagull_sprites = pygame.sprite.Group()

        self.particles = Particles()
        self.particle_sprite = pygame.sprite.Group()
        self.particle_sprite.add(self.particles)

        self.mines = []
        self.mine_sprites = pygame.sprite.Group()

        self.score = Score()
        self.score_sprite = pygame.sprite.Group()
        self.score_sprite.add(self.score)

        self.powerups = []
        self.powerup_sprites = pygame.sprite.Group()

        self.level = Level(endless)

        self.lastshot = MIN_FIRE_DELAY + 1

        self.gameover = False
        self.gameover_image = None
        self.gameover_rect = None
        self.done = False

        self.pause = False
        self.pause_image = util.bigfont.render("Pause", Variables.alpha, (0,0,0))
        self.pause_rect = self.pause_image.get_rect()
        self.pause_rect.center = self.screen.get_rect().center

        self.spacepressed = None
Пример #19
0
def health_bar(ai_settings,screen,stats,healths):
		for i in range(stats.health):
			heart = Health(ai_settings,screen,stats)
			heart.rect.x =heart.rect.width * (i+1)
			healths.add(heart)
Пример #20
0
                ],
                className='gx-2'
            )]
        )]
    )


# Default template from utils/template.py
pio.templates['dashboard'] = template
pio.templates.default = 'dashboard'

# Load config file an initialize Health API
env_var = os.getenv('FITNESS_CONFIG')
if env_var:
    config_path = env_var
else:
    config_path = os.path.dirname(os.path.abspath(__file__))

with open('config.json', 'rt') as f:
    health = Health(**json.load(f))

# Use Bootstrap 5 and initiatlize app
bootstrap = 'https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-alpha2/css/bootstrap.min.css'
open_sans = 'https://fonts.googleapis.com/css2?family=Open+Sans:wght@300;400&display=swap'
app = dash.Dash(__name__, external_stylesheets=[bootstrap, open_sans])
app.layout = layout


if __name__ == '__main__':
    app.run_server(host='0.0.0.0', port=8080, debug=False)
Пример #21
0
import pyautogui
from time import sleep

from health import Health
from mana import Mana


if __name__ == "__main__":
    health_obj = Health()
    mana_obj = Mana()
    while True:
        if health_obj.get_life() <= 80:
            pyautogui.keyDown('f2')
            sleep(1)
        if mana_obj.get_mana() == 90:
            pyautogui.keyDown('f2')
            sleep(1)
Пример #22
0
# === Create skeleton object ===

enemyGroup = pygame.sprite.Group()

for _ in range(1, 3):
    surface2 = pygame.Surface([10, 20], pygame.SRCALPHA)
    skeleton = Bones(surface2, False, False, random.randint(10, 20))
    skeleton.rect.x = random.randint(500, 1000)
    skeleton.rect.y = 407
    enemyGroup.add(skeleton)
    all_sprites_list.add(skeleton)

# === Create heart object ===
surface3 = pygame.Surface([1100, 650], pygame.SRCALPHA)
heart = Health(surface3)
heart.rect.x = 1100
heart.rect.y = 650
itemsGroup = pygame.sprite.Group(heart)
all_sprites_list.add(heart)

itemsGroup.update()
characterGroup.update()

Menu(screen, menuFont, Width)

# creating 2d array
grid = [[n] * 25 for n in range(15)]

# moon
grid[0][3] = -4
Пример #23
0
def gameScreen():
    #This code sets up the screen and fills the background with a color
    pygame.display.set_caption("Zombies")
    backDrop = pygame.Surface(screen.get_size())
    backDrop.fill((0, 0, 0))
    screen.blit(backDrop, (0, 0))

    #Shielded bool
    isShieldOn = False
    #Shield timer
    shieldTimer = 0

    #Necessary for gun collisions
    gunGRP = pygame.sprite.Group()

    #This assigns the car sprite to a variable (for ease of use)
    car = Vehicle(gunGRP)

    #This assigns the gun sprite to a variable (for ease of use)
    #gun = gunDefault(car) <---- this is obviously not being used rn

    #Sets the initial speed for later changing of the zombies
    speed = 0

    #This is necessary for collisions later on
    spriteGRP = pygame.sprite.Group(car)

    #Obstacle car
    obstacle1 = obstacleOne()
    obstacleGRP = pygame.sprite.Group(obstacle1)

    #This list will store the zombie sprites that are on the screen (for multiples)
    ZombieOneList = []
    for z in range(7):
        speed = random.randrange(5, 15)
        zombieOne = ZombieOne(car, speed, obstacle1)
        ZombieOneList.append(zombieOne)

    #Coins
    coinList = []

    #Necessary for collisions with zombie
    zombieGRP = pygame.sprite.Group(ZombieOneList)

    #Keeps track of time, duh.
    clock = pygame.time.Clock()

    #Variable to keep game running if person doesn't quit.
    donePlaying = False

    #Necessary for respawning enemies
    respawn = 0

    #Counts seconds in the game (for doing stuff with time, who knows)
    seconds = 0

    #Timer for the gun
    fireRate = 6

    #Variable for Double Guns
    dGuns = False

    #Coin counter
    coinCt = Coins()
    coinCtGRP = pygame.sprite.Group(coinCt)

    #Background
    road = BackGround()
    roadGRP = pygame.sprite.Group(road)

    #Scoreboard
    score = Score()
    scoreGRP = pygame.sprite.Group(score)

    #Health bar
    health = Health()
    healthGRP = pygame.sprite.Group(health)

    all_sprites = pygame.sprite.Group()

    #Necessary so you don't buy 35 upgrades when you press a button
    upgradeDelay = False
    upgradeDelayTimer = 0

    #Coin costs
    healthCost = "x10 Coins"
    fireRateCost = "x30 Coins"
    shieldCost = "x30 Coins"
    doubleCost = "x40 Coins"
    speedCost = "x20 Coins"
    coinFont = pygame.font.SysFont("Comic Sans MS", 20)
    screen.blit(coinFont.render(healthCost, True, (0, 255, 0)), (1210, 90))
    screen.blit(coinFont.render(fireRateCost, True, (0, 255, 0)), (1210, 210))
    screen.blit(coinFont.render(shieldCost, True, (0, 255, 0)), (1210, 320))
    screen.blit(coinFont.render(doubleCost, True, (0, 255, 0)), (1210, 430))
    screen.blit(coinFont.render(speedCost, True, (0, 255, 0)), (1210, 540))

    #set background music play to loops
    pygame.mixer.music.play(loops=-1)

    #Game loop!
    while donePlaying == False:
        #keep loop running at right speed
        clock.tick(30)
        respawn += 1
        seconds += 1
        mouse = pygame.mouse.get_pos()
        pygame.mouse.set_visible(True)
        pygame.mouse.set_cursor(*pygame.cursors.broken_x)

        #Upgrade display
        healthUpIcon = HealthIcon(coinCt.coins)
        speedUpIcon = SpeedIcon(coinCt.coins)
        shieldUpIcon = ShieldIcon(coinCt.coins)
        doubleGunUpIcon = DoubleGunIcon(coinCt.coins)
        fireRateUpIcon = FireRateIcon(coinCt.coins)
        upgradeGRP = pygame.sprite.Group(healthUpIcon, speedUpIcon,
                                         shieldUpIcon, doubleGunUpIcon,
                                         fireRateUpIcon)

        for event in pygame.event.get():
            if (event.type == pygame.QUIT):
                donePlaying = True

        #update
        all_sprites.update()
        car.particleEmitter.update()

        #This identifies what key is being presses and associates some action
        # with it.
        key = pygame.key.get_pressed()

        #Car Controls (movement)
        if key[pygame.K_LEFT] and key[pygame.K_UP]:
            if isShieldOn == False and dGuns == False:
                car.leftUP()
            elif dGuns == True and isShieldOn == True:
                car.leftUPShieldDG()
            elif dGuns == True:
                car.leftUPDG()
            elif isShieldOn == True:
                car.leftUPShielded()
        elif key[pygame.K_LEFT] and key[pygame.K_DOWN]:
            if isShieldOn == False and dGuns == False:
                car.leftDOWN()
            elif dGuns == True and isShieldOn == True:
                car.leftDOWNShieldDG()
            elif dGuns == True:
                car.leftDOWNDG()
            elif isShieldOn == True:
                car.leftDOWNShielded()
        elif key[pygame.K_RIGHT] and key[pygame.K_UP]:
            if isShieldOn == False and dGuns == False:
                car.rUP()
            elif dGuns == True and isShieldOn == True:
                car.rUPShieldDG()
            elif dGuns == True:
                car.rUPDG()
            elif isShieldOn == True:
                car.rUPShielded()
        elif key[pygame.K_RIGHT] and key[pygame.K_DOWN]:
            if isShieldOn == False and dGuns == False:
                car.rDOWN()
            elif dGuns == True and isShieldOn == True:
                car.rDOWNShieldDG()
            elif dGuns == True:
                car.rDOWNDG()
            elif isShieldOn == True:
                car.rDOWNShielded()
        elif key[pygame.K_LEFT]:
            if isShieldOn == False and dGuns == False:
                car.left()
            elif dGuns == True and isShieldOn == True:
                car.leftShieldDG()
            elif dGuns == True:
                car.leftDG()
            elif isShieldOn == True:
                car.leftShielded()
        elif key[pygame.K_RIGHT]:
            if isShieldOn == False and dGuns == False:
                car.right()
            elif dGuns == True and isShieldOn == True:
                car.rightShieldDG()
            elif dGuns == True:
                car.rightDG()
            elif isShieldOn == True:
                car.rightShielded()
        elif key[pygame.K_UP]:
            if isShieldOn == False and dGuns == False:
                car.up()
            elif dGuns == True and isShieldOn == True:
                car.upShieldDG()
            elif dGuns == True:
                car.upDG()
            elif isShieldOn == True:
                car.upShielded()
        elif key[pygame.K_DOWN]:
            if isShieldOn == False and dGuns == False:
                car.down()
            elif dGuns == True and isShieldOn == True:
                car.downShieldDG()
            elif dGuns == True:
                car.downDG()
            elif isShieldOn == True:
                car.downShielded()

        elif key[pygame.K_1] and coinCt.coins >= 10 and upgradeDelay == False:
            #Health
            upgrade_success_Snd.play()
            upgradeDelay = True
            health.health = 100
            coinCt.coins -= 10
            healthUpSnd.play()
        elif key[
                pygame.
                K_2] and coinCt.coins >= 30 and fireRate > 1 and upgradeDelay == False:
            #Fire Rate Up
            upgrade_success_Snd.play()
            upgradeDelay = True
            if fireRate != 2:
                fireRate -= 1
            coinCt.coins -= 30
        elif key[pygame.K_3] and coinCt.coins >= 30 and upgradeDelay == False:
            #Shield Activate
            upgrade_success_Snd.play()
            upgradeDelay = True
            isShieldOn = True
            coinCt.coins -= 45
        elif key[pygame.K_4] and coinCt.coins >= 40 and upgradeDelay == False:
            #Double Guns
            upgrade_success_Snd.play()
            upgradeDelay = True
            dGuns = True
            coinCt.coins -= 60
        elif key[pygame.K_5] and coinCt.coins >= 20 and upgradeDelay == False:
            #Speed Up
            upgrade_success_Snd.play()
            upgradeDelay = True
            car.dx += 3
            car.dy += 3
            coinCt.coins -= 20

        if isShieldOn == True:
            shieldTimer += 1
        if shieldTimer >= 250:
            isShieldOn = False
            shieldTimer = 0

        if upgradeDelay == True:
            upgradeDelayTimer += 1
        if upgradeDelayTimer >= 100:
            upgradeDelay = False

        car.particleEmitter.x = car.rect.x + car.rect.width / 2
        car.particleEmitter.y = car.rect.y + car.rect.height - 10

        ###################################################
        ##################Respawns timers##################
        ###################################################

        if seconds % 1500 == 0:
            for z in range(5):
                speed = random.randrange(5, 15)
                zombieOne = ZombieOne(car, speed, obstacle1)
                ZombieOneList.append(zombieOne)
            zombieGRP = pygame.sprite.Group(ZombieOneList)

        #Car shooting gun
        if key[pygame.K_SPACE] and dGuns == True:
            if seconds % fireRate == 0:
                car.shootBoth()
                gunSnd.play()
        elif key[pygame.K_SPACE]:
            if seconds % fireRate == 0:
                car.shootGun()
                gunSnd.play()

        #Pause
        if key[pygame.K_ESCAPE]:
            donePlaying = pauseScreen()
            if donePlaying == True:
                pygame.quit()

        #These x,y variables will store a dead zombie's position.
        #This will be used for coins dropping at that location.
        currX = 0
        currY = 0
        #collision handling for shooting zombies
        gunCollided = pygame.sprite.groupcollide(zombieGRP, gunGRP, False,
                                                 True)
        if gunCollided:

            score.score += 10
            for z in gunCollided:

                currX = z.getX()
                currY = z.getY()
                bloodSpread = bloodExp(currX, currY, 'zombie')
                all_sprites.add(bloodSpread)
                if seconds % 3 == 0:
                    coinList.append(coinDrop(currX, currY))
                z.reset()
        coinGRP = pygame.sprite.Group(coinList)

        #collision handling for coins, coin number 1 or 5, play pick up coin sound
        coinCollide = pygame.sprite.groupcollide(coinGRP, spriteGRP, True,
                                                 False)
        if coinCollide:
            pickCoinSnd.play()
            coinCt.coins += random.randrange(1, 5)
            for c in coinCollide:
                c.reset()

        #collision handling for zombie attacking player
        carCollided = pygame.sprite.groupcollide(zombieGRP, spriteGRP, False,
                                                 False)
        if carCollided:
            if isShieldOn == False:
                health.health -= random.randrange(1, 10)
            if health.health <= 0:
                seconds = 0
                donePlaying = True
        for z in carCollided:
            z.reset()

        #Collision for obstacles
        carCrash = pygame.sprite.groupcollide(obstacleGRP, spriteGRP, False,
                                              False,
                                              pygame.sprite.collide_mask)
        if carCrash:
            if isShieldOn == False:
                health.health /= 101
            if health.health <= 0:
                crashSnd.play()
                seconds = 0
                donePlaying = True
        for c in carCrash:
            c.reset()

        #Zombie and obstacle collision handling
        zombieObst = pygame.sprite.groupcollide(zombieGRP, obstacleGRP, False,
                                                False)
        if zombieObst:
            for z in zombieObst:
                z.updateObst(obstacle1)

        #Draws the sprites to the screen
        roadGRP.clear(screen, backDrop)
        spriteGRP.clear(screen, backDrop)
        gunGRP.clear(screen, backDrop)
        coinGRP.clear(screen, backDrop)
        coinCtGRP.clear(screen, backDrop)
        obstacleGRP.clear(screen, backDrop)
        zombieGRP.clear(screen, backDrop)
        scoreGRP.clear(screen, backDrop)
        healthGRP.clear(screen, backDrop)
        upgradeGRP.clear(screen, backDrop)

        roadGRP.update()
        spriteGRP.update()
        gunGRP.update()
        coinGRP.update()
        coinCtGRP.update()
        obstacleGRP.update()
        zombieGRP.update(car)
        scoreGRP.update()
        healthGRP.update()
        upgradeGRP.update(coinCt.coins)

        roadGRP.draw(screen)
        obstacleGRP.draw(screen)
        zombieGRP.draw(screen)
        coinGRP.draw(screen)
        coinCtGRP.draw(screen)
        car.particleEmitter.draw(screen)
        spriteGRP.draw(screen)
        gunGRP.draw(screen)
        scoreGRP.draw(screen)
        healthGRP.draw(screen)
        upgradeGRP.draw(screen)

        all_sprites.draw(screen)

        #see dirty rect animation
        pygame.display.flip()

    pygame.mouse.set_visible(True)
    return score.score