more color helpers

effects/effect.py

@@ -35,11 +35,61 @@ def color_wheel(hue=0, increase=1) -> Generator[pg.Color, None, None]:
 def color_randomize() -> Generator[pg.Color, None, None]:
     color = copy_color(Colors.Red)
     h, s, l, a = color.hsla
-    color.hsla = random.randint(0, 359), s, l, a
+    color.hsla = random.randrange(0, 360 // 5) * 5, s, l, a
 
     while True:
         yield color
-        color.hsla = random.randint(0, 359), s, l, a
+        color.hsla = random.randrange(0, 360 // 5) * 5, s, l, a
+
+
+def color_fadeout(
+    initial_color: pg.Color, fade_speed: float
+) -> Generator[pg.Color, None, None]:
+    color = copy_color(initial_color)
+    h, s, l, a = color.hsla
+    l_float = float(l)
+
+    while True:
+        yield color
+        color.hsla = h, s, int(l_float), a
+        l_float -= fade_speed
+        if l_float < 0:
+            l_float = 0
+
+
+def color_fade(
+    initial_color: pg.Color, end_color: pg.Color, duration: int
+) -> Generator[pg.Color, None, None]:
+    color = copy_color(initial_color)
+    h, s, l, a = color.hsla
+    h2, s2, l2, a2 = end_color.hsla
+    h_inc = (h2 - h) / duration
+    s_inc = (s2 - s) / duration
+    l_inc = (l2 - l) / duration
+    a_inc = (a2 - a) / duration
+    h_f = float(h)
+    s_f = float(s)
+    l_f = float(l)
+    a_f = float(a)
+
+    while True:
+        yield color
+        color.hsla = int(h_f), int(s_f), int(l_f), int(a_f)
+        if h_f < h2:
+            h_f += h_inc
+        if s_f < s2:
+            s_f += s_inc
+        if l_f < l2:
+            l_f += l_inc
+        if a_f < a2:
+            a_f += a_inc
+
+
+def color_darken(color: pg.Color, factor: float) -> pg.Color:
+    h, s, l, a = color.hsla
+    new_color = pg.Color(0, 0, 0, 255)
+    new_color.hsla = h, s, l * factor, a
+    return new_color
 
 
 def rainbow_surface(
@@ -84,7 +134,7 @@ def transform_bounce(
         )
 
         phase += current_velocity / 180 * math.pi
-        current_velocity = random.uniform(min_velocity, max_velocity)
+        # current_velocity = random.uniform(min_velocity, max_velocity)
         size_x, size_y = yield (pos_x, pos_y)
 
 
@@ -123,6 +173,32 @@ def transform_oscillate(
         size_x, size_y = yield (int(pos_x), int(pos_y))
 
 
+def transform_falling(
+    bounds: pg.Rect,
+    acceleration: float,
+    initial_pos: Tuple[int, int],
+    initial_velocity: float = 1.0,
+) -> Generator[Tuple[int, int], Tuple[int, int], None]:
+    pos_x = float(initial_pos[0])
+    pos_y = float(initial_pos[1])
+
+    size_x, size_y = yield (bounds.left, bounds.top)
+
+    velocity = initial_velocity
+
+    while True:
+        range_y = bounds.height - size_y
+
+        pos_y += velocity
+        velocity += acceleration
+
+        if pos_y > range_y:
+            pos_y = initial_pos[1]
+            velocity = initial_velocity
+
+        size_x, size_y = yield (int(pos_x), int(pos_y))
+
+
 class Effect(pg.sprite.Sprite):
     def __init__(
         self, image: pg.Surface, rect: pg.Rect, *groups: pg.sprite.Group