changed super call to match pygame.sprite.Sprite

README.md

@@ -1,3 +1,3 @@
-# pygame-dvd
+# Steam Logo Screensaver
 
-It's the DVD logo bouncing around in pygame.
+It's the Steam logo bouncing around in Pygame.

steam_saver/main.py

@@ -1,14 +1,26 @@
 import pygame
+import subprocess
 import steam_saver.surfaces as surfaces
 
 # Global variables
-SCREEN_SIZE = (1920, 1080)
-FPS = 60
+FPS = 90
 VALID_SURFACES = [
     'steam_screen'
 ]
 
 
+def get_screen_resolution():
+    """
+    Gets the current resolution using xrandr
+    Returns:
+        tuple: The current resolution as a tuple.
+    """
+    command_output = subprocess.check_output(['xrandr']).decode('utf-8')
+    for line in command_output.split('\n'):
+        if '*' in line:
+            return tuple(map(int, line.split()[0].split('x')))
+
+
 def main(windowed_mode=False):
     """
     Main scene manager to display the scenes of the application
@@ -16,13 +28,16 @@ def main(windowed_mode=False):
     """
     pygame.init()
     clock = pygame.time.Clock()
+
+    screen_size = get_screen_resolution()
+
     if windowed_mode:
-        window = pygame.display.set_mode(SCREEN_SIZE)
+        window = pygame.display.set_mode(screen_size)
     else:
-        window = pygame.display.set_mode(SCREEN_SIZE, pygame.FULLSCREEN)
+        window = pygame.display.set_mode(screen_size, pygame.FULLSCREEN)
 
     # Starts the program with the surface 'steam_screen' as the default
-    surface = getattr(globals()['surfaces'], 'steam_screen').Surface(SCREEN_SIZE)
+    surface = getattr(globals()['surfaces'], 'steam_screen').Surface(screen_size)
     running = True
     while running:
         clock.tick(FPS)
@@ -37,7 +52,7 @@ def main(windowed_mode=False):
             next_surface = surface.next_surface
             if next_surface not in VALID_SURFACES:
                 raise Exception('Given surface is not a valid surface!')
-            surface = getattr(globals()['surfaces'], next_surface).Surface(SCREEN_SIZE)
+            surface = getattr(globals()['surfaces'], next_surface).Surface(screen_size)
 
         pygame.display.flip()
     pygame.quit()

steam_saver/surfaces/steam_screen.py

@@ -3,7 +3,8 @@ import os
 import random
 
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-LOGO_SCALING = .5
+SCALE_RATIO = (0.325 / 800.0)
+SPEED_RATIO = (2.5 / 800.0)
 
 
 class SteamLogo(pygame.sprite.Sprite):
@@ -16,23 +17,32 @@ class SteamLogo(pygame.sprite.Sprite):
         y_speed (int): Current speed in the Y axis.
         max_x (int): Maximum X position on the screen.
         max_y (int): Maximum Y position on the screen.
+        is_mini (bool): Bool to determine whether the logo is a mini (background) logo or not.
     """
 
-    def __init__(self, window_size: tuple):
+    def __init__(self, window_size: tuple, is_mini: bool = False, *groups):
         """
         Initialize SteamLogo sprite with given window size.
 
         Args:
             window_size (tuple): Size of the game window (width, height).
+            is_mini (bool): Determines if the logo is going to be a background logo (mini) or the foreground one.
         """
-        super().__init__()
+
+        super().__init__(*groups)
+        self.is_mini = is_mini
 
         # Load and scale original logo image
         self.base_image = pygame.image.load(SCRIPT_DIR + '/resources/steam_logo.png')
         self.base_image.convert_alpha()
+
+        logo_scaling = min(window_size) * SCALE_RATIO
+        # If the logo is mini, make it 2 to 3 times smaller
+        if is_mini:
+            logo_scaling /= random.uniform(2, 3)
         self.base_image = pygame.transform.smoothscale(self.base_image,
-                                                       (self.base_image.get_width() * LOGO_SCALING,
-                                                        self.base_image.get_height() * LOGO_SCALING))
+                                                       (self.base_image.get_width() * logo_scaling,
+                                                        self.base_image.get_height() * logo_scaling))
 
         # Copy the base image and store it in a separate instance variable; this is the image that will be drawn.
         self.image = self.base_image.copy()
@@ -42,13 +52,25 @@ class SteamLogo(pygame.sprite.Sprite):
 
         # Initialize rectangle (position, size) and speed attributes.
         self.rect = self.image.get_rect()
-        self.x_speed = 4
-        self.y_speed = 4
+        self.max_speed = min(window_size) * SPEED_RATIO
+        # Make it so that the logo travels in a random direction when created
+        self.x_speed = (self.max_speed - 1) * random.choice([-1, 1])
+        self.y_speed = (self.max_speed - 1) * random.choice([-1, 1])
 
         # Calculate maximum X and Y positions on the screen for boundary checking.
         self.max_x = window_size[0] - self.rect.width
         self.max_y = window_size[1] - self.rect.height
 
+        # The position of the logo is determined by float values that are separate from the Pygame rect position.
+        # By storing the position as a float and drawing it to the screen after, we are able to apply more precise
+        # speed values (e.g. 2.124) and it will appear as though it is moving smoothly.
+
+        # The starting location of the logo is randomized.
+        self.float_x = random.random() * self.max_x
+        self.float_y = random.random() * self.max_y
+        self.rect.x = self.float_x
+        self.rect.y = self.float_y
+
     def random_color(self):
         """
         Generate a new, random color and apply it to the sprite.
@@ -58,10 +80,15 @@ class SteamLogo(pygame.sprite.Sprite):
         color_surface = pygame.Surface(self.image.get_size(), pygame.SRCALPHA)
 
         # Generate random RGB values and fill the color surface accordingly.
-        new_color = (random.randint(32, 255),
-                     random.randint(32, 255),
-                     random.randint(32, 255))
-        color_surface.fill(new_color)
+        new_color = (random.randint(64, 255),
+                     random.randint(64, 255),
+                     random.randint(64, 255))
+
+        # If this is a mini logo, make it 80% darker
+        if self.is_mini:
+            color_surface.fill(tuple(int(x / 5) for x in new_color))
+        else:  # If not, make it the generated color.
+            color_surface.fill(new_color)
 
         # Replace the drawn image with a copy of the base image and apply the randomly generated color.
         self.image = self.base_image.copy()
@@ -76,21 +103,47 @@ class SteamLogo(pygame.sprite.Sprite):
         """
 
         # Move the logo in the X and Y axis according to its current speed in those directions.
-        self.rect.x += self.x_speed
-        self.rect.y += self.y_speed
+        self.float_x += self.x_speed
+        self.float_y += self.y_speed
 
         # Check for collisions with edges of the screen, change direction if necessary,
         # and generate a new random color when hitting an edge.
-        if self.rect.x < 0 or self.rect.x > self.max_x:
-            self.x_speed *= -1
+        if self.float_x < 0 or self.float_x > self.max_x:
+            # Mini logos have some randomness built into their bounce function to make the background look more organic.
+            if self.is_mini:
+                # Reflect off the left or right wall, clamping the speed (in case it was raised too high)
+                # The speed gets clamped if it goes above the max speed or below the starting speed (max - 1)
+                if self.x_speed > 0:
+                    self.x_speed = max(-1 * self.max_speed, min((self.x_speed * -1), (-1 * self.max_speed) + 1))
+                else:
+                    self.x_speed = max(self.max_speed - 1, min((self.x_speed * -1), self.max_speed))
+                # Add or subtract anywhere from 0 to 10% of the max speed to the vertical speed component
+                self.y_speed += random.uniform(self.max_speed * 0.1, self.max_speed * -0.1)
+
+            # If the logo isn't mini, do a simple reflection with no fancy stuff.
+            else:
+                self.x_speed *= -1
             self.random_color()
-        if self.rect.y < 0 or self.rect.y > self.max_y:
-            self.y_speed *= -1
+
+        # Do the same stuff for the top and bottom walls
+        if self.float_y < 0 or self.float_y > self.max_y:
+            if self.is_mini:
+                if self.y_speed > 0:
+                    self.y_speed = max(-1 * self.max_speed, min((self.y_speed * -1), (-1 * self.max_speed) + 1))
+                else:
+                    self.y_speed = max(self.max_speed - 1, min((self.y_speed * -1), self.max_speed))
+                self.x_speed += random.uniform(self.max_speed * 0.1, self.max_speed * -0.1)
+            else:
+                self.y_speed *= -1
             self.random_color()
 
         # Ensure the logo stays within screen boundaries by clamping its position.
-        self.rect.x = max(0, min(self.rect.x, self.max_x))
-        self.rect.y = max(0, min(self.rect.y, self.max_y))
+        self.float_x = max(0, min(self.float_x, self.max_x))
+        self.float_y = max(0, min(self.float_y, self.max_y))
+
+        # Set the Pygame rectangle's position to the stored floating point position
+        self.rect.x = self.float_x
+        self.rect.y = self.float_y
 
 
 class Surface(pygame.Surface):
@@ -122,9 +175,13 @@ class Surface(pygame.Surface):
 
         pygame.mouse.set_visible(False)
 
-        # Create a SteamLogo sprite instance and add it to the sprite group.
-        steam_logo = SteamLogo(window_size)
-        self.all_sprites = pygame.sprite.Group(steam_logo)
+        self.all_sprites = pygame.sprite.Group()
+        # Create all the mini Steam logos
+        for i in range(25):
+            self.all_sprites.add(SteamLogo(window_size, is_mini=True))
+
+        # Create the big Steam logo
+        self.all_sprites.add(SteamLogo(window_size))
 
     def update(self):
         """
@@ -142,8 +199,13 @@ class Surface(pygame.Surface):
                     # Stop the game when a user clicks anywhere on the screen.
                     self.running = False
                     self.quit = True
+                case pygame.KEYDOWN:
+                    if event.key == pygame.K_ESCAPE:
+                        # Also stop the game if the Escape key is pressed.
+                        self.running = False
+                        self.quit = True
 
-        # Update positions and speeds of all sprites (in this case, just one logo sprite).
+        # Update positions and speeds of all sprites
         self.all_sprites.update()
 
         # Draw all sprites onto this surface.