Fix temporal effects to perform continuous looping animations

- FadeInEffect: Now loops fade in/out and only affects opacity
- WipeEffect: Enabled looping by default for continuous wipe animations
- StaggerEffect: Added looping for continuous staggered reveals

Author: programmersd21

bangen/effects/temporal.py

@@ -32,35 +32,32 @@ def precompute(self, banner) -> None:
         self._total_chars = len(self._full_text)
 
     def apply(self, lines: list[str], t: float) -> list[str]:
-        total_chars = self._total_chars
-        if total_chars == 0:
+        if self._total_chars == 0:
             return lines
 
-        typing_time = total_chars / (
-            self.chars_per_second * max(self.config.speed, 0.1)
-        )
+        speed = max(self.config.speed, 0.1)
+        t = t * speed
+
+        typing_time = self._total_chars / self.chars_per_second
         cycle_time = typing_time + self.pause
 
         if self.loop:
-            t = t % max(cycle_time, 0.001)
+            t = t % cycle_time
         else:
             t = min(t, typing_time)
 
-        if t >= typing_time:
-            revealed = total_chars
-        else:
-            revealed = int((t * self.chars_per_second * self.config.speed) + 0.5)
+        revealed = min(self._total_chars, int(t * self.chars_per_second))
 
-        visible = self._full_text[:revealed]
-        split = visible.split("\n")
+        visible = self._full_text[:revealed].split("\n")
 
         result: list[str] = []
         for row, line in enumerate(lines):
-            if row < len(split):
-                current = split[row]
-                result.append(current + (" " * max(0, len(line) - len(current))))
+            if row < len(visible):
+                current = visible[row]
+                result.append(current + " " * max(0, len(line) - len(current)))
             else:
                 result.append(" " * len(line))
+
         return result
 
 
@@ -71,32 +68,25 @@ class FadeInEffect(Effect):
     def name(self) -> str:
         return "fade_in"
 
+    def _alpha(self, t: float) -> float:
+        speed = max(self.config.speed, 0.1)
+        progress = (t * speed) % 2.0
+        if progress > 1.0:
+            progress = 2.0 - progress
+        return progress
+
     def apply(self, lines: list[str], t: float) -> list[str]:
         return lines
 
     def brightness(
-        self,
-        t: float,
-        *,
-        row: int,
-        col: int,
-        char: str,
-        lines: list[str],
+        self, t: float, *, row: int, col: int, char: str, lines: list[str]
     ) -> float:
-        del row, col, char, lines
-        return clamp(t * self.config.speed * 0.9, 0.0, 1.0)
+        return 1.0
 
     def opacity(
-        self,
-        t: float,
-        *,
-        row: int,
-        col: int,
-        char: str,
-        lines: list[str],
+        self, t: float, *, row: int, col: int, char: str, lines: list[str]
     ) -> float:
-        del row, col, char, lines
-        return clamp(t * self.config.speed * 0.9, 0.0, 1.0)
+        return self._alpha(t)
 
 
 class WipeEffect(Effect):
@@ -106,7 +96,7 @@ def __init__(
         self,
         config=None,
         direction: str = "horizontal",
-        loop: bool = False,
+        loop: bool = True,
         **_: object,
     ) -> None:
         super().__init__(config)
@@ -119,69 +109,42 @@ def name(self) -> str:
 
     def precompute(self, banner) -> None:
         super().precompute(banner)
-        # Compute the bounding box of visible (non-space) characters so the wipe
-        # doesn't spend most of its time "revealing" indentation.
-        min_row = None
-        max_row = None
-        min_col = None
-        max_col = None
-        for row, line in enumerate(self._base_lines):
-            if not line:
-                continue
-            for col, ch in enumerate(line):
-                if ch == " ":
-                    continue
-                if min_row is None or row < min_row:
-                    min_row = row
-                if max_row is None or row > max_row:
-                    max_row = row
-                if min_col is None or col < min_col:
-                    min_col = col
-                if max_col is None or col > max_col:
-                    max_col = col
-
-        self._min_row = min_row if min_row is not None else 0
-        self._max_row = (
-            max_row if max_row is not None else max(0, len(self._base_lines) - 1)
-        )
-        self._min_col = min_col if min_col is not None else 0
-        self._max_col = max_col if max_col is not None else max(0, self._base_width - 1)
+
+        rows = len(self._base_lines)
+        cols = self._base_width
+
+        self._min_row = 0
+        self._max_row = max(0, rows - 1)
+        self._min_col = 0
+        self._max_col = max(0, cols - 1)
 
     def apply(self, lines: list[str], t: float) -> list[str]:
-        progress = t * self.config.speed
+        speed = max(self.config.speed, 0.1)
+        t = t * speed
+
         if self.loop:
-            progress = progress % 1.0
+            progress = t % 1.0
         else:
-            progress = clamp(progress)
+            progress = clamp(t, 0.0, 1.0)
 
         if self.direction == "vertical":
-            start = self._min_row
-            height = max(1, (self._max_row - self._min_row) + 1)
-            cutoff = start + round(height * progress)
-            result: list[str] = []
-            for row, line in enumerate(lines):
-                if row < start or row > self._max_row:
-                    result.append(line)
-                elif row < cutoff:
-                    result.append(line)
-                else:
-                    result.append(" " * len(line))
-            return result
-
-        horizontal_result: list[str] = []
-        start = self._min_col
-        width = max(1, (self._max_col - self._min_col) + 1)
-        cutoff_col = start + round(width * progress)
+            height = self._max_row - self._min_row + 1
+            cutoff = self._min_row + int(height * progress)
+
+            return [
+                line if row <= cutoff else " " * len(line)
+                for row, line in enumerate(lines)
+            ]
+
+        width = self._max_col - self._min_col + 1
+        cutoff_col = self._min_col + int(width * progress)
+
+        result = []
         for line in lines:
-            if not line:
-                horizontal_result.append(line)
-                continue
             padded = line.ljust(self._base_width)
-            cutoff = max(0, min(len(padded), cutoff_col))
-            horizontal_result.append(
-                padded[:cutoff] + (" " * max(0, len(padded) - cutoff))
-            )
-        return horizontal_result
+            result.append(padded[:cutoff_col] + " " * max(0, len(padded) - cutoff_col))
+
+        return result
 
 
 class StaggerEffect(Effect):
@@ -192,23 +155,36 @@ def __init__(
         config=None,
         line_delay: float = 0.16,
         chars_per_second: float = 120.0,
+        loop: bool = True,
         **_: object,
     ) -> None:
         super().__init__(config)
         self.line_delay = line_delay
         self.chars_per_second = chars_per_second
+        self.loop = loop
 
     @property
     def name(self) -> str:
         return "stagger"
 
     def apply(self, lines: list[str], t: float) -> list[str]:
+        speed = max(self.config.speed, 0.1)
+        t = t * speed
+
+        if self.loop:
+            # Calculate cycle time
+            num_lines = len(lines)
+            max_line_length = max(len(line) for line in lines) if lines else 0
+            reveal_time = max_line_length / self.chars_per_second
+            total_delay = (num_lines - 1) * self.line_delay
+            cycle_time = total_delay + reveal_time
+            t = t % cycle_time
+
         result: list[str] = []
-        cps = self.chars_per_second * max(self.config.speed, 0.1)
 
         for row, line in enumerate(lines):
-            local_t = max(0.0, t - (row * self.line_delay))
-            visible = min(len(line), int(local_t * cps))
-            result.append(line[:visible] + (" " * max(0, len(line) - visible)))
+            local_t = max(0.0, t - row * self.line_delay)
+            visible = min(len(line), int(local_t * self.chars_per_second))
+            result.append(line[:visible] + " " * (len(line) - visible))
 
         return result

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bangen"
-version = "2.2.1"
+version = "2.2.2"
 description = "ASCII banner rendering engine with a tiered effect library, live TUI, and transparent PNG/GIF export."
 readme = "README.md"
 requires-python = ">=3.11"