Simplify drain animation code

Author: johnnyshields

lib/minigun/hud/flow_diagram.rb

@@ -379,17 +379,18 @@ def get_drain_distance(stage_data)
         ticks_since_finished
       end
 
+      # Check if connection has flowing animation (vs idle/drained state)
+      def connection_flowing?(stage_data)
+        stage_data[:status] == :running
+      end
+
       # Draw a fan-out connection (one source to multiple targets)
       def render_fanout_connection(terminal, from_pos, target_positions, stage_data, x_offset, y_offset)
         from_x = from_pos[:x] + from_pos[:width] / 2
         from_y = from_pos[:y] + from_pos[:height]
 
-        # Get drain distance (non-nil when stage finished)
         drain_distance = get_drain_distance(stage_data)
-
-        # Connection is active if flowing OR draining
-        # When draining, keep animation visible until fully drained
-        active = (stage_data[:throughput] && stage_data[:throughput] > 0) || !drain_distance.nil?
+        active = connection_flowing?(stage_data)
 
         # Calculate split point (horizontal spine where fan-out occurs)
         split_y = from_y + 1
@@ -457,11 +458,8 @@ def render_fanin_connection(terminal, source_positions, to_pos, stage_data, x_of
         to_x = to_pos[:x] + to_pos[:width] / 2
         to_y = to_pos[:y]
 
-        # Get drain distance (non-nil when stage finished)
         drain_distance = get_drain_distance(stage_data)
-
-        # Connection is active if flowing OR draining
-        active = (stage_data[:throughput] && stage_data[:throughput] > 0) || !drain_distance.nil?
+        active = connection_flowing?(stage_data)
 
         # Calculate merge point (where horizontal lines converge)
         # Place it 1 line above the target
@@ -546,11 +544,8 @@ def render_connection_line(terminal, from_pos, to_pos, stage_data, x_offset, y_o
         to_x = to_pos[:x] + to_pos[:width] / 2
         to_y = to_pos[:y]
 
-        # Get drain distance (non-nil when stage finished)
         drain_distance = get_drain_distance(stage_data)
-
-        # Connection is active if flowing OR draining
-        active = (stage_data[:throughput] && stage_data[:throughput] > 0) || !drain_distance.nil?
+        active = connection_flowing?(stage_data)
 
         # Distance counter starts at 0 from source
         distance = 0

lib/minigun/hud/theme.rb

@@ -97,15 +97,11 @@ def self.flow_medium
         Terminal::COLORS[:cyan]
       end
 
-      # Draining animation colors (darker, showing flow winding down)
+      # Draining animation color (darker, showing flow winding down)
       def self.drain_dim
         Terminal::COLORS[:gray]
       end
 
-      def self.drain_medium
-        Terminal::COLORS[:gray]
-      end
-
       # Subtle flowing animation for each box drawing character type
       # Each frame has: [character, color_method_symbol]
       FLOW_ANIMATION = {
@@ -265,17 +261,24 @@ def self.drain_medium
       # @param drain_distance [Integer, nil] How far the drain has progressed from source (nil if not draining)
       # @return [Array<String, String>] [character, color_code]
       def self.animated_flow_char(char_type, distance, animation_frame, active, drain_distance: nil)
-        # Show animation if active OR draining (drain_distance is non-nil)
-        return [static_char_for_type(char_type), muted] unless active || !drain_distance.nil?
-
-        # Check if this cell has been reached by the drain wave
-        # drain_distance is the number of ticks since finishing
-        # Cells are drained when distance <= drain_distance (inclusive)
-        draining = !drain_distance.nil? && distance <= drain_distance
+        # Check if this cell has been drained (wave reached it)
+        drained = !drain_distance.nil? && distance <= drain_distance
+
+        # Check if drain is in progress but wave hasn't reached this cell yet
+        draining = !drain_distance.nil? && distance > drain_distance
+
+        # Determine which animation to use:
+        # - If drained: gray static (drained)
+        # - If active OR draining: cyan animated (flowing/draining)
+        # - Otherwise: gray static (idle/not started)
+        frames = if drained
+                   DRAIN_ANIMATION[char_type]
+                 elsif active || draining
+                   FLOW_ANIMATION[char_type]
+                 else
+                   DRAIN_ANIMATION[char_type] # Gray for idle state
+                 end
 
-        # Use draining animation if this cell has been reached by the drain wave
-        # Otherwise use normal flow animation
-        frames = draining ? DRAIN_ANIMATION[char_type] : FLOW_ANIMATION[char_type]
         return [static_char_for_type(char_type), muted] unless frames
 
         # Calculate phase based on distance from source and global animation frame