created mini logos, applied scaled speeds and sizes rather than fixed, added random movement

steam_saver/surfaces/steam_screen.py

@@ -3,8 +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):
     """
@@ -18,21 +18,29 @@ class SteamLogo(pygame.sprite.Sprite):
         max_y (int): Maximum Y position on the screen.
     """
 
-    def __init__(self, window_size: tuple):
+    def __init__(self, window_size: tuple, is_mini: bool = False):
         """
         Initialize SteamLogo sprite with given window size.
 
         Args:
             window_size (tuple): Size of the game window (width, height).
+            is_mini (tuple): Determines if the logo is going to be a background logo (mini) or the foreground one.
         """
         super().__init__()
 
+        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 4 times smaller
+        if is_mini:
+            logo_scaling /= random.uniform(2, 4)
         self.base_image = pygame.transform.smoothscale(self.base_image,
-                                                       (self.base_image.get_width() * LOGO_SCALING,
+                                                       (self.base_image.get_width() * logo_scaling,
-                                                        self.base_image.get_height() * 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 +50,25 @@ class SteamLogo(pygame.sprite.Sprite):
 
         # Initialize rectangle (position, size) and speed attributes.
         self.rect = self.image.get_rect()
-        self.x_speed = 4
+        self.max_speed = min(window_size) * SPEED_RATIO
-        self.y_speed = 4
+        # 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_y
+        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 +78,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),
+        new_color = (random.randint(64, 255),
-                     random.randint(32, 255),
+                     random.randint(64, 255),
-                     random.randint(32, 255))
+                     random.randint(64, 255))
-        color_surface.fill(new_color)
+
+        # If this is a mini logo, make it 90% darker
+        if self.is_mini:
+            color_surface.fill(tuple(int(x / 10) 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 +101,40 @@ 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.float_x += self.x_speed
-        self.rect.y += self.y_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:
+        if self.float_x < 0 or self.float_x > self.max_x:
-            self.x_speed *= -1
+            # 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)
+                self.x_speed = max(-1 * self.max_speed, 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:
+                self.y_speed = max(-1 * self.max_speed, 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.float_x = max(0, min(self.float_x, self.max_x))
-        self.rect.y = max(0, min(self.rect.y, self.max_y))
+        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 +166,13 @@ class Surface(pygame.Surface):
 
         pygame.mouse.set_visible(False)
 
-        # Create a SteamLogo sprite instance and add it to the sprite group.
+        self.all_sprites = pygame.sprite.Group()
-        steam_logo = SteamLogo(window_size)
+        # Create all the mini Steam logos
-        self.all_sprites = pygame.sprite.Group(steam_logo)
+        for i in range(20):
+            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):
         """