#!/usr/bin/env python """ pygame.examples.aliens Shows a mini game where you have to defend against aliens. What does it show you about pygame? * pg.sprite, the difference between Sprite and Group. * dirty rectangle optimization for processing for speed. * music with pg.mixer.music, including fadeout * sound effects with pg.Sound * event processing, keyboard handling, QUIT handling. * a main loop frame limited with a game clock from pg.time.Clock * fullscreen switching. Controls -------- * Left and right arrows to move. * Space bar to shoot * f key to toggle between fullscreen. """ import os import random from typing import List # import basic pygame modules import pygame as pg # see if we can load more than standard BMP if not pg.image.get_extended(): raise SystemExit("Sorry, extended image module required") # game constants MAX_SHOTS = 2 # most player bullets onscreen ALIEN_ODDS = 22 # chances a new alien appears BOMB_ODDS = 60 # chances a new bomb will drop ALIEN_RELOAD = 12 # frames between new aliens SCREENRECT = pg.Rect(0, 0, 640, 480) SCORE = 0 main_dir = os.path.split(os.path.abspath(__file__))[0] def load_image(file): """loads an image, prepares it for play""" file = os.path.join(main_dir, "data", file) try: surface = pg.image.load(file) except pg.error: raise SystemExit(f'Could not load image "{file}" {pg.get_error()}') return surface.convert() def load_sound(file): """because pygame can be compiled without mixer.""" if not pg.mixer: return None file = os.path.join(main_dir, "data", file) try: sound = pg.mixer.Sound(file) return sound except pg.error: print(f"Warning, unable to load, {file}") return None # Each type of game object gets an init and an update function. # The update function is called once per frame, and it is when each object should # change its current position and state. # # The Player object actually gets a "move" function instead of update, # since it is passed extra information about the keyboard. class Player(pg.sprite.Sprite): """Representing the player as a moon buggy type car.""" speed = 10 bounce = 24 gun_offset = -11 images: List[pg.Surface] = [] def __init__(self, *groups): pg.sprite.Sprite.__init__(self, *groups) self.image = self.images[0] self.rect = self.image.get_rect(midbottom=SCREENRECT.midbottom) self.reloading = 0 self.origtop = self.rect.top self.facing = -1 def move(self, direction): if direction: self.facing = direction self.rect.move_ip(direction * self.speed, 0) self.rect = self.rect.clamp(SCREENRECT) if direction < 0: self.image = self.images[0] elif direction > 0: self.image = self.images[1] self.rect.top = self.origtop - (self.rect.left // self.bounce % 2) def gunpos(self): pos = self.facing * self.gun_offset + self.rect.centerx return pos, self.rect.top class Alien(pg.sprite.Sprite): """An alien space ship. That slowly moves down the screen.""" speed = 13 animcycle = 12 images: List[pg.Surface] = [] def __init__(self, *groups): pg.sprite.Sprite.__init__(self, *groups) self.image = self.images[0] self.rect = self.image.get_rect() self.facing = random.choice((-1, 1)) * Alien.speed self.frame = 0 if self.facing < 0: self.rect.right = SCREENRECT.right def update(self, *args, **kwargs): self.rect.move_ip(self.facing, 0) if not SCREENRECT.contains(self.rect): self.facing = -self.facing self.rect.top = self.rect.bottom + 1 self.rect = self.rect.clamp(SCREENRECT) self.frame = self.frame + 1 self.image = self.images[self.frame // self.animcycle % 3] class Explosion(pg.sprite.Sprite): """An explosion. Hopefully the Alien and not the player!""" defaultlife = 12 animcycle = 3 images: List[pg.Surface] = [] def __init__(self, actor, *groups): pg.sprite.Sprite.__init__(self, *groups) self.image = self.images[0] self.rect = self.image.get_rect(center=actor.rect.center) self.life = self.defaultlife def update(self, *args, **kwargs): """called every time around the game loop. Show the explosion surface for 'defaultlife'. Every game tick(update), we decrease the 'life'. Also we animate the explosion. """ self.life = self.life - 1 self.image = self.images[self.life // self.animcycle % 2] if self.life <= 0: self.kill() class Shot(pg.sprite.Sprite): """a bullet the Player sprite fires.""" speed = -11 images: List[pg.Surface] = [] def __init__(self, pos, *groups): pg.sprite.Sprite.__init__(self, *groups) self.image = self.images[0] self.rect = self.image.get_rect(midbottom=pos) def update(self, *args, **kwargs): """called every time around the game loop. Every tick we move the shot upwards. """ self.rect.move_ip(0, self.speed) if self.rect.top <= 0: self.kill() class Bomb(pg.sprite.Sprite): """A bomb the aliens drop.""" speed = 9 images: List[pg.Surface] = [] def __init__(self, alien, explosion_group, *groups): pg.sprite.Sprite.__init__(self, *groups) self.image = self.images[0] self.rect = self.image.get_rect(midbottom=alien.rect.move(0, 5).midbottom) self.explosion_group = explosion_group def update(self, *args, **kwargs): """called every time around the game loop. Every frame we move the sprite 'rect' down. When it reaches the bottom we: - make an explosion. - remove the Bomb. """ self.rect.move_ip(0, self.speed) if self.rect.bottom >= 470: Explosion(self, self.explosion_group) self.kill() class Score(pg.sprite.Sprite): """to keep track of the score.""" def __init__(self, *groups): pg.sprite.Sprite.__init__(self, *groups) self.font = pg.font.Font(None, 20) self.font.set_italic(1) self.color = "white" self.lastscore = -1 self.update() self.rect = self.image.get_rect().move(10, 450) def update(self, *args, **kwargs): """We only update the score in update() when it has changed.""" if SCORE != self.lastscore: self.lastscore = SCORE msg = f"Score: {SCORE}" self.image = self.font.render(msg, 0, self.color) def main(winstyle=0): # Initialize pygame if pg.get_sdl_version()[0] == 2: pg.mixer.pre_init(44100, 32, 2, 1024) pg.init() if pg.mixer and not pg.mixer.get_init(): print("Warning, no sound") pg.mixer = None fullscreen = False # Set the display mode winstyle = 0 # |FULLSCREEN bestdepth = pg.display.mode_ok(SCREENRECT.size, winstyle, 32) screen = pg.display.set_mode(SCREENRECT.size, winstyle, bestdepth) # Load images, assign to sprite classes # (do this before the classes are used, after screen setup) img = load_image("player1.gif") Player.images = [img, pg.transform.flip(img, 1, 0)] img = load_image("explosion1.gif") Explosion.images = [img, pg.transform.flip(img, 1, 1)] Alien.images = [load_image(im) for im in ("alien1.gif", "alien2.gif", "alien3.gif")] Bomb.images = [load_image("bomb.gif")] Shot.images = [load_image("shot.gif")] # decorate the game window icon = pg.transform.scale(Alien.images[0], (32, 32)) pg.display.set_icon(icon) pg.display.set_caption("Pygame Aliens") pg.mouse.set_visible(0) # create the background, tile the bgd image bgdtile = load_image("background.gif") background = pg.Surface(SCREENRECT.size) for x in range(0, SCREENRECT.width, bgdtile.get_width()): background.blit(bgdtile, (x, 0)) screen.blit(background, (0, 0)) pg.display.flip() # load the sound effects boom_sound = load_sound("boom.wav") shoot_sound = load_sound("car_door.wav") if pg.mixer: music = os.path.join(main_dir, "data", "house_lo.wav") pg.mixer.music.load(music) pg.mixer.music.play(-1) # Initialize Game Groups aliens = pg.sprite.Group() shots = pg.sprite.Group() bombs = pg.sprite.Group() all = pg.sprite.RenderUpdates() lastalien = pg.sprite.GroupSingle() # Create Some Starting Values alienreload = ALIEN_RELOAD clock = pg.time.Clock() # initialize our starting sprites global SCORE player = Player(all) Alien( aliens, all, lastalien ) # note, this 'lives' because it goes into a sprite group if pg.font: all.add(Score(all)) # Run our main loop whilst the player is alive. while player.alive(): # get input for event in pg.event.get(): if event.type == pg.QUIT: return if event.type == pg.KEYDOWN and event.key == pg.K_ESCAPE: return if event.type == pg.KEYDOWN: if event.key == pg.K_f: if not fullscreen: print("Changing to FULLSCREEN") screen_backup = screen.copy() screen = pg.display.set_mode( SCREENRECT.size, winstyle | pg.FULLSCREEN, bestdepth ) screen.blit(screen_backup, (0, 0)) else: print("Changing to windowed mode") screen_backup = screen.copy() screen = pg.display.set_mode( SCREENRECT.size, winstyle, bestdepth ) screen.blit(screen_backup, (0, 0)) pg.display.flip() fullscreen = not fullscreen keystate = pg.key.get_pressed() # clear/erase the last drawn sprites all.clear(screen, background) # update all the sprites all.update() # handle player input direction = keystate[pg.K_RIGHT] - keystate[pg.K_LEFT] player.move(direction) firing = keystate[pg.K_SPACE] if not player.reloading and firing and len(shots) < MAX_SHOTS: Shot(player.gunpos(), shots, all) if pg.mixer and shoot_sound is not None: shoot_sound.play() player.reloading = firing # Create new alien if alienreload: alienreload = alienreload - 1 elif not int(random.random() * ALIEN_ODDS): Alien(aliens, all, lastalien) alienreload = ALIEN_RELOAD # Drop bombs if lastalien and not int(random.random() * BOMB_ODDS): Bomb(lastalien.sprite, all, bombs, all) # Detect collisions between aliens and players. for alien in pg.sprite.spritecollide(player, aliens, 1): if pg.mixer and boom_sound is not None: boom_sound.play() Explosion(alien, all) Explosion(player, all) SCORE = SCORE + 1 player.kill() # See if shots hit the aliens. for alien in pg.sprite.groupcollide(aliens, shots, 1, 1).keys(): if pg.mixer and boom_sound is not None: boom_sound.play() Explosion(alien, all) SCORE = SCORE + 1 # See if alien bombs hit the player. for bomb in pg.sprite.spritecollide(player, bombs, 1): if pg.mixer and boom_sound is not None: boom_sound.play() Explosion(player, all) Explosion(bomb, all) player.kill() # draw the scene dirty = all.draw(screen) pg.display.update(dirty) # cap the framerate at 40fps. Also called 40HZ or 40 times per second. clock.tick(40) if pg.mixer: pg.mixer.music.fadeout(1000) pg.time.wait(1000) # call the "main" function if running this script if __name__ == "__main__": main() pg.quit()