API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 20th, 2019
128
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 24.81 KB | None | 0 0
raw download clone embed print report
  1. #!/usr/bin/env python
  2.  
  3. # Space Invaders
  4. # Created by Lee Robinson
  5.  
  6. from pygame import *
  7. import sys
  8. from os.path import abspath, dirname
  9. from random import choice
  10.  
  11. BASE_PATH = abspath(dirname(__file__))
  12. FONT_PATH = BASE_PATH + '/fonts/'
  13. IMAGE_PATH = BASE_PATH + '/images/'
  14. SOUND_PATH = BASE_PATH + '/sounds/'
  15.  
  16. # Colors (R, G, B)
  17. WHITE = (255, 255, 255)
  18. GREEN = (78, 255, 87)
  19. YELLOW = (241, 255, 0)
  20. BLUE = (80, 255, 239)
  21. PURPLE = (203, 0, 255)
  22. RED = (237, 28, 36)
  23.  
  24. SCREEN = display.set_mode((800, 600))
  25. FONT = FONT_PATH + 'space_invaders.ttf'
  26. IMG_NAMES = ['ship', 'mystery',
  27.              'enemy1_1', 'enemy1_2',
  28.              'enemy2_1', 'enemy2_2',
  29.              'enemy3_1', 'enemy3_2',
  30.              'explosionblue', 'explosiongreen', 'explosionpurple',
  31.              'laser', 'enemylaser']
  32. IMAGES = {name: image.load(IMAGE_PATH + '{}.png'.format(name)).convert_alpha()
  33.           for name in IMG_NAMES}
  34.  
  35. BLOCKERS_POSITION = 450
  36. ENEMY_DEFAULT_POSITION = 65  # Initial value for a new game
  37. ENEMY_MOVE_DOWN = 35
  38.  
  39.  
  40. class Ship(sprite.Sprite):
  41.     def __init__(self):
  42.         sprite.Sprite.__init__(self)
  43.         self.image = IMAGES['ship']
  44.         self.rect = self.image.get_rect(topleft=(375, 540))
  45.         self.speed = 5
  46.  
  47.     def update(self, keys, *args):
  48.         if keys[K_LEFT] and self.rect.x > 10:
  49.             self.rect.x -= self.speed
  50.         if keys[K_RIGHT] and self.rect.x < 740:
  51.             self.rect.x += self.speed
  52.         game.screen.blit(self.image, self.rect)
  53.  
  54.  
  55. class Bullet(sprite.Sprite):
  56.     def __init__(self, xpos, ypos, direction, speed, filename, side):
  57.         sprite.Sprite.__init__(self)
  58.         self.image = IMAGES[filename]
  59.         self.rect = self.image.get_rect(topleft=(xpos, ypos))
  60.         self.speed = speed
  61.         self.direction = direction
  62.         self.side = side
  63.         self.filename = filename
  64.  
  65.     def update(self, keys, *args):
  66.         game.screen.blit(self.image, self.rect)
  67.         self.rect.y += self.speed * self.direction
  68.         if self.rect.y < 15 or self.rect.y > 600:
  69.             self.kill()
  70.  
  71.  
  72. class Enemy(sprite.Sprite):
  73.     def __init__(self, row, column):
  74.         sprite.Sprite.__init__(self)
  75.         self.row = row
  76.         self.column = column
  77.         self.images = []
  78.         self.load_images()
  79.         self.index = 0
  80.         self.image = self.images[self.index]
  81.         self.rect = self.image.get_rect()
  82.  
  83.     def toggle_image(self):
  84.         self.index += 1
  85.         if self.index >= len(self.images):
  86.             self.index = 0
  87.         self.image = self.images[self.index]
  88.  
  89.     def update(self, *args):
  90.         game.screen.blit(self.image, self.rect)
  91.  
  92.     def load_images(self):
  93.         images = {0: ['1_2', '1_1'],
  94.                   1: ['2_2', '2_1'],
  95.                   2: ['2_2', '2_1'],
  96.                   3: ['3_1', '3_2'],
  97.                   4: ['3_1', '3_2'],
  98.                   }
  99.         img1, img2 = (IMAGES['enemy{}'.format(img_num)] for img_num in
  100.                       images[self.row])
  101.         self.images.append(transform.scale(img1, (40, 35)))
  102.         self.images.append(transform.scale(img2, (40, 35)))
  103.  
  104.  
  105. class EnemiesGroup(sprite.Group):
  106.     def __init__(self, columns, rows):
  107.         sprite.Group.__init__(self)
  108.         self.enemies = [[None] * columns for _ in range(rows)]
  109.         self.columns = columns
  110.         self.rows = rows
  111.         self.leftAddMove = 0
  112.         self.rightAddMove = 0
  113.         self.moveTime = 600
  114.         self.direction = 1
  115.         self.rightMoves = 30
  116.         self.leftMoves = 30
  117.         self.moveNumber = 15
  118.         self.timer = time.get_ticks()
  119.         self.bottom = game.enemyPosition + ((rows - 1) * 45) + 35
  120.         self._aliveColumns = list(range(columns))
  121.         self._leftAliveColumn = 0
  122.         self._rightAliveColumn = columns - 1
  123.  
  124.     def update(self, current_time):
  125.         if current_time - self.timer > self.moveTime:
  126.             if self.direction == 1:
  127.                 max_move = self.rightMoves + self.rightAddMove
  128.             else:
  129.                 max_move = self.leftMoves + self.leftAddMove
  130.  
  131.             if self.moveNumber >= max_move:
  132.                 self.leftMoves = 30 + self.rightAddMove
  133.                 self.rightMoves = 30 + self.leftAddMove
  134.                 self.direction *= -1
  135.                 self.moveNumber = 0
  136.                 self.bottom = 0
  137.                 for enemy in self:
  138.                     enemy.rect.y += ENEMY_MOVE_DOWN
  139.                     enemy.toggle_image()
  140.                     if self.bottom < enemy.rect.y + 35:
  141.                         self.bottom = enemy.rect.y + 35
  142.             else:
  143.                 velocity = 10 if self.direction == 1 else -10
  144.                 for enemy in self:
  145.                     enemy.rect.x += velocity
  146.                     enemy.toggle_image()
  147.                 self.moveNumber += 1
  148.  
  149.             self.timer += self.moveTime
  150.  
  151.     def add_internal(self, *sprites):
  152.         super(EnemiesGroup, self).add_internal(*sprites)
  153.         for s in sprites:
  154.             self.enemies[s.row][s.column] = s
  155.  
  156.     def remove_internal(self, *sprites):
  157.         super(EnemiesGroup, self).remove_internal(*sprites)
  158.         for s in sprites:
  159.             self.kill(s)
  160.         self.update_speed()
  161.  
  162.     def is_column_dead(self, column):
  163.         return not any(self.enemies[row][column]
  164.                        for row in range(self.rows))
  165.  
  166.     def random_bottom(self):
  167.         col = choice(self._aliveColumns)
  168.         col_enemies = (self.enemies[row - 1][col]
  169.                        for row in range(self.rows, 0, -1))
  170.         return next((en for en in col_enemies if en is not None), None)
  171.  
  172.     def update_speed(self):
  173.         if len(self) == 1:
  174.             self.moveTime = 200
  175.         elif len(self) <= 10:
  176.             self.moveTime = 400
  177.  
  178.     def kill(self, enemy):
  179.         self.enemies[enemy.row][enemy.column] = None
  180.         is_column_dead = self.is_column_dead(enemy.column)
  181.         if is_column_dead:
  182.             self._aliveColumns.remove(enemy.column)
  183.  
  184.         if enemy.column == self._rightAliveColumn:
  185.             while self._rightAliveColumn > 0 and is_column_dead:
  186.                 self._rightAliveColumn -= 1
  187.                 self.rightAddMove += 5
  188.                 is_column_dead = self.is_column_dead(self._rightAliveColumn)
  189.  
  190.         elif enemy.column == self._leftAliveColumn:
  191.             while self._leftAliveColumn < self.columns and is_column_dead:
  192.                 self._leftAliveColumn += 1
  193.                 self.leftAddMove += 5
  194.                 is_column_dead = self.is_column_dead(self._leftAliveColumn)
  195.  
  196.  
  197. class Blocker(sprite.Sprite):
  198.     def __init__(self, size, color, row, column):
  199.         sprite.Sprite.__init__(self)
  200.         self.height = size
  201.         self.width = size
  202.         self.color = color
  203.         self.image = Surface((self.width, self.height))
  204.         self.image.fill(self.color)
  205.         self.rect = self.image.get_rect()
  206.         self.row = row
  207.         self.column = column
  208.  
  209.     def update(self, keys, *args):
  210.         game.screen.blit(self.image, self.rect)
  211.  
  212.  
  213. class Mystery(sprite.Sprite):
  214.     def __init__(self):
  215.         sprite.Sprite.__init__(self)
  216.         self.image = IMAGES['mystery']
  217.         self.image = transform.scale(self.image, (75, 35))
  218.         self.rect = self.image.get_rect(topleft=(-80, 45))
  219.         self.row = 5
  220.         self.moveTime = 25000
  221.         self.direction = 1
  222.         self.timer = time.get_ticks()
  223.         self.mysteryEntered = mixer.Sound(SOUND_PATH + 'mysteryentered.wav')
  224.         self.mysteryEntered.set_volume(0.3)
  225.         self.playSound = True
  226.  
  227.     def update(self, keys, currentTime, *args):
  228.         resetTimer = False
  229.         passed = currentTime - self.timer
  230.         if passed > self.moveTime:
  231.             if (self.rect.x < 0 or self.rect.x > 800) and self.playSound:
  232.                 self.mysteryEntered.play()
  233.                 self.playSound = False
  234.             if self.rect.x < 840 and self.direction == 1:
  235.                 self.mysteryEntered.fadeout(4000)
  236.                 self.rect.x += 2
  237.                 game.screen.blit(self.image, self.rect)
  238.             if self.rect.x > -100 and self.direction == -1:
  239.                 self.mysteryEntered.fadeout(4000)
  240.                 self.rect.x -= 2
  241.                 game.screen.blit(self.image, self.rect)
  242.  
  243.         if self.rect.x > 830:
  244.             self.playSound = True
  245.             self.direction = -1
  246.             resetTimer = True
  247.         if self.rect.x < -90:
  248.             self.playSound = True
  249.             self.direction = 1
  250.             resetTimer = True
  251.         if passed > self.moveTime and resetTimer:
  252.             self.timer = currentTime
  253.  
  254.  
  255. class EnemyExplosion(sprite.Sprite):
  256.     def __init__(self, enemy, *groups):
  257.         super(EnemyExplosion, self).__init__(*groups)
  258.         self.image = transform.scale(self.get_image(enemy.row), (40, 35))
  259.         self.image2 = transform.scale(self.get_image(enemy.row), (50, 45))
  260.         self.rect = self.image.get_rect(topleft=(enemy.rect.x, enemy.rect.y))
  261.         self.timer = time.get_ticks()
  262.  
  263.     @staticmethod
  264.     def get_image(row):
  265.         img_colors = ['purple', 'blue', 'blue', 'green', 'green']
  266.         return IMAGES['explosion{}'.format(img_colors[row])]
  267.  
  268.     def update(self, current_time, *args):
  269.         passed = current_time - self.timer
  270.         if passed <= 100:
  271.             game.screen.blit(self.image, self.rect)
  272.         elif passed <= 200:
  273.             game.screen.blit(self.image2, (self.rect.x - 6, self.rect.y - 6))
  274.         elif 400 < passed:
  275.             self.kill()
  276.  
  277.  
  278. class MysteryExplosion(sprite.Sprite):
  279.     def __init__(self, mystery, score, *groups):
  280.         super(MysteryExplosion, self).__init__(*groups)
  281.         self.text = Text(FONT, 20, str(score), WHITE,
  282.                          mystery.rect.x + 20, mystery.rect.y + 6)
  283.         self.timer = time.get_ticks()
  284.  
  285.     def update(self, current_time, *args):
  286.         passed = current_time - self.timer
  287.         if passed <= 200 or 400 < passed <= 600:
  288.             self.text.draw(game.screen)
  289.         elif 600 < passed:
  290.             self.kill()
  291.  
  292.  
  293. class ShipExplosion(sprite.Sprite):
  294.     def __init__(self, ship, *groups):
  295.         super(ShipExplosion, self).__init__(*groups)
  296.         self.image = IMAGES['ship']
  297.         self.rect = self.image.get_rect(topleft=(ship.rect.x, ship.rect.y))
  298.         self.timer = time.get_ticks()
  299.  
  300.     def update(self, current_time, *args):
  301.         passed = current_time - self.timer
  302.         if 300 < passed <= 600:
  303.             game.screen.blit(self.image, self.rect)
  304.         elif 900 < passed:
  305.             self.kill()
  306.  
  307.  
  308. class Life(sprite.Sprite):
  309.     def __init__(self, xpos, ypos):
  310.         sprite.Sprite.__init__(self)
  311.         self.image = IMAGES['ship']
  312.         self.image = transform.scale(self.image, (23, 23))
  313.         self.rect = self.image.get_rect(topleft=(xpos, ypos))
  314.  
  315.     def update(self, *args):
  316.         game.screen.blit(self.image, self.rect)
  317.  
  318.  
  319. class Text(object):
  320.     def __init__(self, textFont, size, message, color, xpos, ypos):
  321.         self.font = font.Font(textFont, size)
  322.         self.surface = self.font.render(message, True, color)
  323.         self.rect = self.surface.get_rect(topleft=(xpos, ypos))
  324.  
  325.     def draw(self, surface):
  326.         surface.blit(self.surface, self.rect)
  327.  
  328.  
  329. class SpaceInvaders(object):
  330.     def __init__(self):
  331.         # It seems, in Linux buffersize=512 is not enough, use 4096 to prevent:
  332.         #   ALSA lib pcm.c:7963:(snd_pcm_recover) underrun occurred
  333.         mixer.pre_init(44100, -16, 1, 4096)
  334.         init()
  335.         self.clock = time.Clock()
  336.         self.caption = display.set_caption('Space Invaders')
  337.         self.screen = SCREEN
  338.         self.background = image.load(IMAGE_PATH + 'background.jpg').convert()
  339.         self.startGame = False
  340.         self.mainScreen = True
  341.         self.gameOver = False
  342.         # Counter for enemy starting position (increased each new round)
  343.         self.enemyPosition = ENEMY_DEFAULT_POSITION
  344.         self.titleText = Text(FONT, 50, 'Space Invaders', WHITE, 164, 155)
  345.         self.titleText2 = Text(FONT, 25, 'Press any key to continue', WHITE,
  346.                                201, 225)
  347.         self.gameOverText = Text(FONT, 50, 'Game Over', WHITE, 250, 270)
  348.         self.nextRoundText = Text(FONT, 50, 'Next Round', WHITE, 240, 270)
  349.         self.enemy1Text = Text(FONT, 25, '   =   10 pts', GREEN, 368, 270)
  350.         self.enemy2Text = Text(FONT, 25, '   =  20 pts', BLUE, 368, 320)
  351.         self.enemy3Text = Text(FONT, 25, '   =  30 pts', PURPLE, 368, 370)
  352.         self.enemy4Text = Text(FONT, 25, '   =  ?????', RED, 368, 420)
  353.         self.scoreText = Text(FONT, 20, 'Score', WHITE, 5, 5)
  354.         self.livesText = Text(FONT, 20, 'Lives ', WHITE, 640, 5)
  355.  
  356.         self.life1 = Life(715, 3)
  357.         self.life2 = Life(742, 3)
  358.         self.life3 = Life(769, 3)
  359.         self.livesGroup = sprite.Group(self.life1, self.life2, self.life3)
  360.  
  361.     def reset(self, score):
  362.         self.player = Ship()
  363.         self.playerGroup = sprite.Group(self.player)
  364.         self.explosionsGroup = sprite.Group()
  365.         self.bullets = sprite.Group()
  366.         self.mysteryShip = Mystery()
  367.         self.mysteryGroup = sprite.Group(self.mysteryShip)
  368.         self.enemyBullets = sprite.Group()
  369.         self.make_enemies()
  370.         self.allSprites = sprite.Group(self.player, self.enemies,
  371.                                        self.livesGroup, self.mysteryShip)
  372.         self.keys = key.get_pressed()
  373.  
  374.         self.timer = time.get_ticks()
  375.         self.noteTimer = time.get_ticks()
  376.         self.shipTimer = time.get_ticks()
  377.         self.score = score
  378.         self.create_audio()
  379.         self.makeNewShip = False
  380.         self.shipAlive = True
  381.  
  382.     def make_blockers(self, number):
  383.         blockerGroup = sprite.Group()
  384.         for row in range(4):
  385.             for column in range(9):
  386.                 blocker = Blocker(10, GREEN, row, column)
  387.                 blocker.rect.x = 50 + (200 * number) + (column * blocker.width)
  388.                 blocker.rect.y = BLOCKERS_POSITION + (row * blocker.height)
  389.                 blockerGroup.add(blocker)
  390.         return blockerGroup
  391.  
  392.     def create_audio(self):
  393.         self.sounds = {}
  394.         for sound_name in ['shoot', 'shoot2', 'invaderkilled', 'mysterykilled',
  395.                            'shipexplosion']:
  396.             self.sounds[sound_name] = mixer.Sound(
  397.                 SOUND_PATH + '{}.wav'.format(sound_name))
  398.             self.sounds[sound_name].set_volume(0.2)
  399.  
  400.         self.musicNotes = [mixer.Sound(SOUND_PATH + '{}.wav'.format(i)) for i
  401.                            in range(4)]
  402.         for sound in self.musicNotes:
  403.             sound.set_volume(0.5)
  404.  
  405.         self.noteIndex = 0
  406.  
  407.     def play_main_music(self, currentTime):
  408.         if currentTime - self.noteTimer > self.enemies.moveTime:
  409.             self.note = self.musicNotes[self.noteIndex]
  410.             if self.noteIndex < 3:
  411.                 self.noteIndex += 1
  412.             else:
  413.                 self.noteIndex = 0
  414.  
  415.             self.note.play()
  416.             self.noteTimer += self.enemies.moveTime
  417.  
  418.     @staticmethod
  419.     def should_exit(evt):
  420.         # type: (pygame.event.EventType) -> bool
  421.         return evt.type == QUIT or (evt.type == KEYUP and evt.key == K_ESCAPE)
  422.  
  423.     def check_input(self):
  424.         self.keys = key.get_pressed()
  425.         for e in event.get():
  426.             '''if self.should_exit(e):
  427.                sys.exit()'''
  428.             if e.type == KEYDOWN:
  429.                 if e.key == K_SPACE:
  430.                     if len(self.bullets) == 0 and self.shipAlive:
  431.                         if self.score < 1000:
  432.                             bullet = Bullet(self.player.rect.x + 23,
  433.                                             self.player.rect.y + 5, -1,
  434.                                             15, 'laser', 'center')
  435.                             self.bullets.add(bullet)
  436.                             self.allSprites.add(self.bullets)
  437.                             self.sounds['shoot'].play()
  438.                         else:
  439.                             leftbullet = Bullet(self.player.rect.x + 8,
  440.                                                 self.player.rect.y + 5, -1,
  441.                                                 15, 'laser', 'left')
  442.                             rightbullet = Bullet(self.player.rect.x + 38,
  443.                                                  self.player.rect.y + 5, -1,
  444.                                                  15, 'laser', 'right')
  445.                             self.bullets.add(leftbullet)
  446.                             self.bullets.add(rightbullet)
  447.                             self.allSprites.add(self.bullets)
  448.                             self.sounds['shoot2'].play()
  449.  
  450.     def make_enemies(self):
  451.         enemies = EnemiesGroup(10, 5)
  452.         for row in range(5):
  453.             for column in range(10):
  454.                 enemy = Enemy(row, column)
  455.                 enemy.rect.x = 157 + (column * 50)
  456.                 enemy.rect.y = self.enemyPosition + (row * 45)
  457.                 enemies.add(enemy)
  458.  
  459.         self.enemies = enemies
  460.  
  461.     def make_enemies_shoot(self):
  462.         if (time.get_ticks() - self.timer) > 700 and self.enemies:
  463.             enemy = self.enemies.random_bottom()
  464.             self.enemyBullets.add(
  465.                 Bullet(enemy.rect.x + 14, enemy.rect.y + 20, 1, 5,
  466.                        'enemylaser', 'center'))
  467.             self.allSprites.add(self.enemyBullets)
  468.             self.timer = time.get_ticks()
  469.  
  470.     def calculate_score(self, row):
  471.         scores = {0: 30,
  472.                   1: 20,
  473.                   2: 20,
  474.                   3: 10,
  475.                   4: 10,
  476.                   5: choice([50, 100, 150, 300])
  477.                   }
  478.  
  479.         score = scores[row]
  480.         self.score += score
  481.         return score
  482.  
  483.     def create_main_menu(self):
  484.         self.enemy1 = IMAGES['enemy3_1']
  485.         self.enemy1 = transform.scale(self.enemy1, (40, 40))
  486.         self.enemy2 = IMAGES['enemy2_2']
  487.         self.enemy2 = transform.scale(self.enemy2, (40, 40))
  488.         self.enemy3 = IMAGES['enemy1_2']
  489.         self.enemy3 = transform.scale(self.enemy3, (40, 40))
  490.         self.enemy4 = IMAGES['mystery']
  491.         self.enemy4 = transform.scale(self.enemy4, (80, 40))
  492.         self.screen.blit(self.enemy1, (318, 270))
  493.         self.screen.blit(self.enemy2, (318, 320))
  494.         self.screen.blit(self.enemy3, (318, 370))
  495.         self.screen.blit(self.enemy4, (299, 420))
  496.  
  497.     def check_collisions(self):
  498.         sprite.groupcollide(self.bullets, self.enemyBullets, True, True)
  499.  
  500.         for enemy in sprite.groupcollide(self.enemies, self.bullets,
  501.                                          True, True).keys():
  502.             self.sounds['invaderkilled'].play()
  503.             self.calculate_score(enemy.row)
  504.             EnemyExplosion(enemy, self.explosionsGroup)
  505.             self.gameTimer = time.get_ticks()
  506.  
  507.         for mystery in sprite.groupcollide(self.mysteryGroup, self.bullets,
  508.                                            True, True).keys():
  509.             mystery.mysteryEntered.stop()
  510.             self.sounds['mysterykilled'].play()
  511.             score = self.calculate_score(mystery.row)
  512.             MysteryExplosion(mystery, score, self.explosionsGroup)
  513.             newShip = Mystery()
  514.             self.allSprites.add(newShip)
  515.             self.mysteryGroup.add(newShip)
  516.  
  517.         for player in sprite.groupcollide(self.playerGroup, self.enemyBullets,
  518.                                           True, True).keys():
  519.             if self.life3.alive():
  520.                 self.life3.kill()
  521.             elif self.life2.alive():
  522.                 self.life2.kill()
  523.             elif self.life1.alive():
  524.                 self.life1.kill()
  525.             else:
  526.                 self.gameOver = True
  527.                 self.startGame = False
  528.             self.sounds['shipexplosion'].play()
  529.             ShipExplosion(player, self.explosionsGroup)
  530.             self.makeNewShip = True
  531.             self.shipTimer = time.get_ticks()
  532.             self.shipAlive = False
  533.  
  534.         if self.enemies.bottom >= 540:
  535.             sprite.groupcollide(self.enemies, self.playerGroup, True, True)
  536.             if not self.player.alive() or self.enemies.bottom >= 600:
  537.                 self.gameOver = True
  538.                 self.startGame = False
  539.  
  540.         sprite.groupcollide(self.bullets, self.allBlockers, True, True)
  541.         sprite.groupcollide(self.enemyBullets, self.allBlockers, True, True)
  542.         if self.enemies.bottom >= BLOCKERS_POSITION:
  543.             sprite.groupcollide(self.enemies, self.allBlockers, False, True)
  544.  
  545.     def create_new_ship(self, createShip, currentTime):
  546.         if createShip and (currentTime - self.shipTimer > 900):
  547.             self.player = Ship()
  548.             self.allSprites.add(self.player)
  549.             self.playerGroup.add(self.player)
  550.             self.makeNewShip = False
  551.             self.shipAlive = True
  552.  
  553.     def create_game_over(self, currentTime):
  554.         self.screen.blit(self.background, (0, 0))
  555.         passed = currentTime - self.timer
  556.         if passed < 750:
  557.             self.gameOverText.draw(self.screen)
  558.         elif 750 < passed < 1500:
  559.             self.screen.blit(self.background, (0, 0))
  560.         elif 1500 < passed < 2250:
  561.             self.gameOverText.draw(self.screen)
  562.         elif 2250 < passed < 2750:
  563.             self.screen.blit(self.background, (0, 0))
  564.         elif passed > 3000:
  565.             self.mainScreen = True
  566.  
  567.         for e in event.get():
  568.             if self.should_exit(e):
  569.                 sys.exit()
  570.  
  571.     def main(self):
  572.         while True:
  573.             if self.mainScreen:
  574.                 self.screen.blit(self.background, (0, 0))
  575.                 self.titleText.draw(self.screen)
  576.                 self.titleText2.draw(self.screen)
  577.                 self.enemy1Text.draw(self.screen)
  578.                 self.enemy2Text.draw(self.screen)
  579.                 self.enemy3Text.draw(self.screen)
  580.                 self.enemy4Text.draw(self.screen)
  581.                 self.create_main_menu()
  582.                 for e in event.get():
  583.                     '''if self.should_exit(e):
  584.                        sys.exit()'''
  585.                     if e.type == KEYUP:
  586.                         # Only create blockers on a new game, not a new round
  587.                         self.allBlockers = sprite.Group(self.make_blockers(0),
  588.                                                         self.make_blockers(1),
  589.                                                         self.make_blockers(2),
  590.                                                         self.make_blockers(3))
  591.                         self.livesGroup.add(self.life1, self.life2, self.life3)
  592.                         self.reset(0)
  593.                         self.startGame = True
  594.                         self.mainScreen = False
  595.  
  596.             elif self.startGame:
  597.                 if not self.enemies and not self.explosionsGroup:
  598.                     currentTime = time.get_ticks()
  599.                     if currentTime - self.gameTimer < 3000:
  600.                         self.screen.blit(self.background, (0, 0))
  601.                         self.scoreText2 = Text(FONT, 20, str(self.score),
  602.                                                GREEN, 85, 5)
  603.                         self.scoreText.draw(self.screen)
  604.                         self.scoreText2.draw(self.screen)
  605.                         self.nextRoundText.draw(self.screen)
  606.                         sys.exit()
  607.                         self.livesText.draw(self.screen)
  608.                         self.livesGroup.update()
  609.                         self.check_input()
  610.                     if currentTime - self.gameTimer > 3000:
  611.                         # Move enemies closer to bottom
  612.                         self.enemyPosition += ENEMY_MOVE_DOWN
  613.                         self.reset(self.score)
  614.                         self.gameTimer += 3000
  615.                 else:
  616.                     currentTime = time.get_ticks()
  617.                     self.play_main_music(currentTime)
  618.                     self.screen.blit(self.background, (0, 0))
  619.                     self.allBlockers.update(self.screen)
  620.                     self.scoreText2 = Text(FONT, 20, str(self.score), GREEN,
  621.                                            85, 5)
  622.                     self.scoreText.draw(self.screen)
  623.                     self.scoreText2.draw(self.screen)
  624.                     self.livesText.draw(self.screen)
  625.                     self.check_input()
  626.                     self.enemies.update(currentTime)
  627.                     self.allSprites.update(self.keys, currentTime)
  628.                     self.explosionsGroup.update(currentTime)
  629.                     self.check_collisions()
  630.                     self.create_new_ship(self.makeNewShip, currentTime)
  631.                     self.make_enemies_shoot()
  632.  
  633.             elif self.gameOver:
  634.                 currentTime = time.get_ticks()
  635.                 # Reset enemy starting position
  636.                 self.enemyPosition = ENEMY_DEFAULT_POSITION
  637.                 self.create_game_over(currentTime)
  638.  
  639.             display.update()
  640.             self.clock.tick(60)
  641.  
  642.  
  643. if __name__ == '__main__':
  644.     game = SpaceInvaders()
  645.     game.main()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!