Merge pull request #6 from beeankha/level_up_and_scoring

Add level, score, high score, and lives remaining

Author: beeankha

cat.py

@@ -1,10 +1,12 @@
 import pygame
+from pygame.sprite import Sprite
 
-class Cat:
+class Cat(Sprite):
     """A class to manage the feline savior."""
 
     def __init__(self, ai_game):
         """Initialize the cat and set its starting position."""
+        super().__init__()
         self.screen = ai_game.screen
         self.settings = ai_game.settings
         self.screen_rect = ai_game.screen.get_rect()
@@ -48,3 +50,16 @@ def center_cat(self):
         """Center the cat on the screen."""
         self.rect.midbottom = self.screen_rect.midbottom
         self.x = float(self.rect.x)
+
+
+class CatFace(Sprite):
+    """A class to manage the feline savior's 'lives remaining' images."""
+
+    def __init__(self, ai_game):
+        """Initialize the cat face."""
+        super().__init__()
+        self.screen = ai_game.screen
+        self.settings = ai_game.settings
+        self.screen_rect = ai_game.screen.get_rect()
+        self.image = pygame.image.load('images/catface.png')
+        self.rect = self.image.get_rect()

cat_save_us.py

@@ -9,6 +9,7 @@
 from button import Button
 from cat import Cat
 from game_stats import GameStats
+from scoreboard import Scoreboard
 from settings import Settings
 from stars import Stars
 
@@ -26,11 +27,14 @@ def __init__(self):
         # (the pygame method get_rect() returns a Rect object from an image)
         pygame.display.set_caption("Cat Save Us!")
 
-        # Create an instance to store game stats.
+        # Create an instance to store game stats and create a scoreboard.
         self.stats = GameStats(self)
+        self.sb = Scoreboard(self)
 
         self.cat = Cat(self)
         # ^^ The self argument here refers to the current instance of CatSaveUs.
+        self.cat_face = Cat(self)
+        # ^^ The self argument here refers to the current instance of CatSaveUs.
 
         self.bullets = pygame.sprite.Group()
         self.aliens = pygame.sprite.Group()
@@ -108,16 +112,28 @@ def _check_bullet_alien_collisions(self):
         # ^^ The sprite.groupcollide() function compares the rects of each element
         # in one group with the rects of each element in another group.
 
+        # NOTE
         # To make a high-powered bullet that can travel to the top of the screen,
         # destroying every alien in its path, you could set the first Boolean
         # argument to False and keep the second Boolean argument set to True.
         # The aliens hit would disappear, but all bullets would stay active until
         # they disappeared off the top of the screen.
 
+        if collisions:
+            for aliens in collisions.values():
+                self.stats.score += self.settings.alien_points * len(aliens)
+            self.sb.prep_score()
+            self.sb.check_high_score()
+
         if not self.aliens:
             # Destroy existing bullets and create a new fleet.
             self.bullets.empty()
             self._create_fleet()
+            self.settings.increase_speed()
+
+            # Increase level.
+            self.stats.level += 1
+            self.sb.prep_level()
 
     def _update_aliens(self):
         """
@@ -137,8 +153,9 @@ def _update_aliens(self):
     def _cat_hit(self):
         """Respond to the cat being hit by an alien ship."""
         if self.stats.cats_left > 0:
-            # Decrement cats_left.
+            # Decrement cats_left, and update scoreboard.
             self.stats.cats_left -= 1
+            self.sb.prep_cats()
 
             # Get rid of any remaining aliens and bullets.
             self.aliens.empty()
@@ -179,9 +196,14 @@ def _check_play_button(self, mouse_pos):
         """Start a new game when the player clicks Play."""
         button_clicked = self.play_button.rect.collidepoint(mouse_pos)
         if button_clicked and not self.stats.game_active:
+            # Reset the game settings.
+            self.settings.initialize_dynamic_settings()
             # Reset the game statistics.
             self.stats.reset_stats()
             self.stats.game_active = True
+            self.sb.prep_score()
+            self.sb.prep_level()
+            self.sb.prep_cats()
 
             # Hide the mouse cursor.
             pygame.mouse.set_visible(False)
@@ -285,6 +307,9 @@ def _update_screen(self):
             bullet.draw_bullet()
         self.aliens.draw(self.screen)
 
+        # Draw the score information.
+        self.sb.show_score()
+
         # Draw the play button if the game is inactive.
         if not self.stats.game_active:
             self.play_button.draw_button()

game_stats.py

@@ -12,6 +12,11 @@ def __init__(self, ai_game):
         # Start Cat Save Us! in an inactive state.
         self.game_active = False
 
+        # High score should never be reset.
+        self.high_score = 0
+
     def reset_stats(self):
         """Initialize statistics that can change during the game."""
         self.cats_left = self.settings.cat_limit
+        self.score = 0
+        self.level = 1

images/.DS_Store

@@ -0,0 +1,89 @@
+import pygame.font
+from pygame.sprite import Group
+from cat import CatFace
+
+
+class Scoreboard:
+    """A class to report scoring information."""
+
+    def __init__(self, ai_game):
+        """Initialize scorekeeping attributes."""
+        self.ai_game = ai_game
+        self.screen = ai_game.screen
+        self.screen_rect = self.screen.get_rect()
+        self.settings = ai_game.settings
+        self.stats = ai_game.stats
+
+        # We give __init__() the ai_game parameter here so that it can access
+        # the settings, screen, and stats objects, which it will need to report
+        # the values we’re tracking
+
+        # Font settings for scoring information.
+        self.text_color = (0, 200, 100)
+        self.font = pygame.font.SysFont(None, 48)
+
+        # Prepare the initial score images.
+        self.prep_score()
+        self.prep_high_score()
+        self.prep_level()
+        self.prep_cats()
+
+    def prep_score(self):
+        """Turn the score into a rendered image."""
+        rounded_score = round(self.stats.score, -1)
+        # ^^ The above rounds the score to multiples of 10
+        score_str = "{:,}".format(rounded_score)
+        self.score_image = self.font.render(score_str, True, self.text_color, self.settings.bg_color)
+
+        # Display the score at the top right of the screen.
+        self.score_rect = self.score_image.get_rect()
+        self.score_rect.right = self.screen_rect.right - 20
+        self.score_rect.top = 20
+        # ^^ To make sure the score always lines up with the right side of the screen,
+        # there is a rect called score_rect and its right edge is set 20 pixels from
+        # the right edge of the screen. We then place the top edge 20 pixels down
+        # from the top of the screen.
+
+    def prep_high_score(self):
+        """Turn the high score into a rendered image."""
+        high_score = round(self.stats.high_score, -1)
+        high_score_str = "High Score: {:,}".format(high_score)
+        self.high_score_image = self.font.render(high_score_str, True, self.text_color, self.settings.bg_color)
+
+        # Center the high score at the top of the screen.
+        self.high_score_rect = self.high_score_image.get_rect()
+        self.high_score_rect.centerx = self.screen_rect.centerx
+        self.high_score_rect.top = self.score_rect.top
+
+    def show_score(self):
+        """Draw scores, level, and cats to the screen."""
+        self.screen.blit(self.score_image, self.score_rect)
+        self.screen.blit(self.high_score_image, self.high_score_rect)
+        self.screen.blit(self.level_image, self.level_rect)
+        self.cats.draw(self.screen)
+
+    def check_high_score(self):
+        """Check ot see if there's a new high score."""
+        if self.stats.score > self.stats.high_score:
+            self.stats.high_score = self.stats.score
+            self.prep_high_score()
+
+    def prep_level(self):
+        """Turn the level into a rendered image."""
+        level_str = str(self.stats.level)
+        current_level = "Level: {}".format(level_str)
+        self.level_image = self.font.render(current_level, True, self.text_color, self.settings.bg_color)
+
+        # Position the level below the score.
+        self.level_rect = self.level_image.get_rect()
+        self.level_rect.right = self.score_rect.right
+        self.level_rect.top = self.score_rect.bottom + 10
+
+    def prep_cats(self):
+        """Show how many cat lives are left."""
+        self.cats = Group()
+        for cat_number in range(self.stats.cats_left):
+            cat = CatFace(self.ai_game)
+            cat.rect.x = 10 + cat_number * cat.rect.width
+            cat.rect.y = 10
+            self.cats.add(cat)

images/catface.png

@@ -4,7 +4,7 @@ class Settings:
     """A class to store all settings for "Cat Save Us!" game."""
 
     def __init__(self):
-        """Initialize the game's settings."""
+        """Initialize the game's static settings."""
         # Screen settings
         self.screen_width = 1350
         self.screen_height = 800
@@ -15,19 +15,42 @@ def __init__(self):
         # self.bg_color = (104, 130, 158) (greyish blue, aka "Daytime Mode")
 
         # Cat settings
-        self.cat_speed = 5
-        # (the higher the number, the faster the cat)
         self.cat_limit = 3
 
         # Bullet settings
-        self.bullet_speed = 5.0
         self.bullet_width = 8
         self.bullet_height = 12
         self.bullet_color = (200, 0, 200)
         self.bullets_allowed = 20
 
         # Alien settings
-        self.alien_speed = 2
         self.fleet_drop_speed = 10
+
+        # How quickly the game speeds up
+        self.speedup_scale = 1.3
+
+        # How quickly the alien point values increase
+        self.score_scale = 1.5
+
+        self.initialize_dynamic_settings()
+
+    def initialize_dynamic_settings(self):
+        """Initialize settings that change throughout the game."""
+        self.cat_speed = 5
+        # (the higher the number, the faster the cat)
+        self.bullet_speed = 5.0
+        self.alien_speed = 2
+
         # fleet_direction of 1 represents right; -1 represents left.
         self.fleet_direction = 1
+
+        # Scoring
+        self.alien_points = 50
+
+    def increase_speed(self):
+        """Increase speed settings and alien point values."""
+        self.cat_speed *= self.speedup_scale
+        self.bullet_speed *= self.speedup_scale
+        self.alien_speed *= self.speedup_scale
+
+        self.alien_points = int(self.alien_points * self.score_scale)