Adds colorized rendering option to widget

Adds an option to render the asciiquarium widget with colorized glyphs.

Introduces `AsciiquariumPalette` to map glyphs to colors,
and adds a toggle in the demo to enable/disable colorized rendering
along with color customization controls.

When color is disabled or no palette is provided, the widget falls
back to plain text rendering.

Author: gitcoder89431

README.md

@@ -160,3 +160,72 @@ Tests cover:
 - The original Perl Asciiquarium (Kirk Baucom) materials are archived under `archive/original/`.
 - This crate provides an `egui`-based Rust implementation with a stateless, themeable widget design.
 - ASCII art in this crate is a minimal starter set for demonstration. Expand or replace as needed per your project’s licensing requirements.
+
+## Features
+
+- Stateless egui widget: renders to a single monospace label string
+- Deterministic animation loop with fixed timestep for smooth pacing
+- Environment:
+  - Waterlines with subtle wave motion
+  - Seaweed with gentle sway
+  - Castle at bottom-right
+  - Ship at the surface; shark and whale underwater with spout animation
+  - Fish bubbles (desynced per fish)
+- Fish behavior:
+  - Bounce physics with occasional direction variance on wall bounces
+  - Schools: groups traverse and despawn off-screen
+  - Orientation correction: fish ASCII auto-mirrors so they face their travel direction
+- Despawn and respawn cycles for large entities (ship, shark, whale)
+- Minimal defaults, no required configuration
+- Tests and CI (rustfmt, clippy, build, test)
+
+## Colorized rendering (optional)
+
+By default, the widget renders a plain, single-color ASCII string. You can opt into a colorized renderer that maps certain glyphs to colors using a palette:
+
+- Enable by setting `enable_color = true` and providing a `palette`
+- Renders via an internal color `LayoutJob` while keeping the API unchanged
+- Glyph color mapping (initial pass):
+  - Water surface: `~` and `^` → `palette.water`
+  - Seaweed: `(` and `)` → `palette.seaweed`
+  - Bubbles: `.` → `palette.bubble`
+  - Original mask placeholders: `?` → `palette.water_trail` (to mimic motion trails)
+  - All other glyphs default to `theme.text_color` (castle, ship, fish body, etc.)
+
+Example (palette + colorized theme):
+
+    use asciiquarium_rust::{AsciiquariumTheme};
+    use asciiquarium_rust::widgets::asciiquarium::AsciiquariumPalette;
+
+    let palette = AsciiquariumPalette {
+        water: egui::Color32::from_rgb(120, 180, 255),
+        water_trail: egui::Color32::from_rgba_unmultiplied(120, 180, 255, 120),
+        seaweed: egui::Color32::from_rgb(60, 180, 120),
+        castle: egui::Color32::from_rgb(200, 200, 200),
+        ship: egui::Color32::from_rgb(230, 230, 230),
+        bubble: egui::Color32::from_rgb(200, 230, 255),
+        shark: egui::Color32::from_rgb(180, 200, 210),
+        whale: egui::Color32::from_rgb(160, 190, 210),
+        fish: egui::Color32::from_rgb(255, 200, 120),
+    };
+
+    let theme = AsciiquariumTheme {
+        text_color: egui::Color32::from_rgb(180, 220, 255),
+        background: Some(egui::Color32::from_rgb(8, 12, 16)),
+        wrap: false,
+        enable_color: true,
+        palette: Some(palette),
+    };
+
+Then render as usual with `AsciiquariumWidget { state, assets, theme }`.
+
+Notes:
+- Color mapping will evolve. Future iterations may introduce per-art or per-part mapping for higher fidelity while keeping defaults minimal.
+- When `enable_color = false` or `palette = None`, the widget falls back to plain text rendering.
+
+## Notes on original mask characters
+
+The classic Asciiquarium art uses special characters (like `?`) in separate color mask layers. In this crate:
+
+- With color disabled (default), mask characters are skipped in rendering for a clean monochrome output.
+- With color enabled, mask characters render using `palette.water_trail` to mimic subtle motion trails behind large entities.

examples/egui_demo.rs

@@ -47,6 +47,8 @@ impl MyApp {
             text_color: egui::Color32::from_rgb(180, 220, 255),
             background: Some(egui::Color32::from_rgb(8, 12, 16)),
             wrap: false,
+            enable_color: false,
+            palette: None,
         };
 
         Self {
@@ -111,6 +113,56 @@ impl eframe::App for MyApp {
                     self.theme.background = None;
                 }
 
+                // Colorized rendering toggle and palette controls
+                ui.checkbox(&mut self.theme.enable_color, "Color");
+                if self.theme.enable_color {
+                    if self.theme.palette.is_none() {
+                        self.theme.palette = Some(
+                            asciiquarium_rust::widgets::asciiquarium::AsciiquariumPalette {
+                                water: egui::Color32::from_rgb(120, 180, 255),
+                                water_trail: egui::Color32::from_rgba_unmultiplied(
+                                    120, 180, 255, 120,
+                                ),
+                                seaweed: egui::Color32::from_rgb(60, 180, 120),
+                                castle: egui::Color32::from_rgb(200, 200, 200),
+                                ship: egui::Color32::from_rgb(230, 230, 230),
+                                bubble: egui::Color32::from_rgb(200, 230, 255),
+                                shark: egui::Color32::from_rgb(180, 200, 210),
+                                whale: egui::Color32::from_rgb(160, 190, 210),
+                                fish: egui::Color32::from_rgb(255, 200, 120),
+                            },
+                        );
+                    }
+                    if let Some(p) = &mut self.theme.palette {
+                        ui.separator();
+                        ui.label("Palette:");
+                        ui.horizontal(|ui| {
+                            ui.label("Water");
+                            ui.color_edit_button_srgba(&mut p.water);
+                            ui.label("Trail");
+                            ui.color_edit_button_srgba(&mut p.water_trail);
+                            ui.label("Seaweed");
+                            ui.color_edit_button_srgba(&mut p.seaweed);
+                        });
+                        ui.horizontal(|ui| {
+                            ui.label("Bubble");
+                            ui.color_edit_button_srgba(&mut p.bubble);
+                            ui.label("Fish");
+                            ui.color_edit_button_srgba(&mut p.fish);
+                            ui.label("Shark");
+                            ui.color_edit_button_srgba(&mut p.shark);
+                            ui.label("Whale");
+                            ui.color_edit_button_srgba(&mut p.whale);
+                        });
+                        ui.horizontal(|ui| {
+                            ui.label("Ship");
+                            ui.color_edit_button_srgba(&mut p.ship);
+                            ui.label("Castle");
+                            ui.color_edit_button_srgba(&mut p.castle);
+                        });
+                    }
+                }
+
                 ui.separator();
 
                 if ui.button("Add fish").clicked() {

src/widgets/asciiquarium.rs

@@ -142,13 +142,30 @@ pub struct AquariumState {
 }
 
 /// Theme passed during render. No hardcoded styles in the component.
+#[derive(Clone, Debug)]
+pub struct AsciiquariumPalette {
+    pub water: egui::Color32,
+    pub water_trail: egui::Color32,
+    pub seaweed: egui::Color32,
+    pub castle: egui::Color32,
+    pub ship: egui::Color32,
+    pub bubble: egui::Color32,
+    pub shark: egui::Color32,
+    pub whale: egui::Color32,
+    pub fish: egui::Color32,
+}
+
 #[derive(Clone, Debug)]
 pub struct AsciiquariumTheme {
     pub text_color: egui::Color32,
     /// Optional background fill for the label area.
     pub background: Option<egui::Color32>,
     /// Whether to wrap lines in the ASCII label. Usually false for grids.
     pub wrap: bool,
+    /// Enable colorized rendering using a LayoutJob instead of a plain string.
+    pub enable_color: bool,
+    /// Optional palette for colorized rendering. When None, falls back to text_color.
+    pub palette: Option<AsciiquariumPalette>,
 }
 
 impl Default for AsciiquariumTheme {
@@ -157,6 +174,8 @@ impl Default for AsciiquariumTheme {
             text_color: egui::Color32::LIGHT_GRAY,
             background: None,
             wrap: false,
+            enable_color: false,
+            palette: None,
         }
     }
 }
@@ -770,7 +789,7 @@ pub fn render_aquarium_to_string(state: &AquariumState, assets: &[FishArt]) -> S
                 continue;
             }
             for (dx, ch) in line.chars().enumerate() {
-                if ch == ' ' {
+                if ch == ' ' || ch == '?' {
                     continue;
                 }
                 let x = x0 + dx as isize;
@@ -793,7 +812,7 @@ pub fn render_aquarium_to_string(state: &AquariumState, assets: &[FishArt]) -> S
                 continue;
             }
             for (dx, ch) in line.chars().enumerate() {
-                if ch == ' ' {
+                if ch == ' ' || ch == '?' {
                     continue;
                 }
                 let x = base_x + dx;
@@ -866,7 +885,7 @@ pub fn render_aquarium_to_string(state: &AquariumState, assets: &[FishArt]) -> S
                 continue;
             }
             for (dx, ch) in line.chars().enumerate() {
-                if ch == ' ' {
+                if ch == ' ' || ch == '?' {
                     continue;
                 }
                 let x = x0 + dx as isize;
@@ -888,7 +907,7 @@ pub fn render_aquarium_to_string(state: &AquariumState, assets: &[FishArt]) -> S
                 continue;
             }
             for (dx, ch) in line.chars().enumerate() {
-                if ch == ' ' {
+                if ch == ' ' || ch == '?' {
                     continue;
                 }
                 let x = spx + dx as isize;
@@ -914,7 +933,7 @@ pub fn render_aquarium_to_string(state: &AquariumState, assets: &[FishArt]) -> S
                 continue;
             }
             for (dx, ch) in line.chars().enumerate() {
-                if ch == ' ' {
+                if ch == ' ' || ch == '?' {
                     continue;
                 }
                 let x = x0 + dx as isize;
@@ -952,7 +971,7 @@ pub fn render_aquarium_to_string(state: &AquariumState, assets: &[FishArt]) -> S
             };
 
             for (dx, ch) in line_str.chars().enumerate() {
-                if ch == ' ' {
+                if ch == ' ' || ch == '?' {
                     continue;
                 }
                 let x = x0 + dx as isize;
@@ -996,20 +1015,98 @@ pub struct AsciiquariumWidget<'a> {
 
 impl<'a> egui::Widget for AsciiquariumWidget<'a> {
     fn ui(self, ui: &mut egui::Ui) -> egui::Response {
-        let rendered = render_aquarium_to_string(self.state, self.assets);
-        let text = egui::RichText::new(rendered)
-            .monospace()
-            .color(self.theme.text_color);
-        let label = egui::Label::new(text).wrap(self.theme.wrap);
-
-        if let Some(fill) = self.theme.background {
-            egui::Frame::default()
-                .fill(fill)
-                .show(ui, |ui| ui.add(label))
-                .response
+        // Always render the ASCII grid string first
+        let rendered_string = render_aquarium_to_string(self.state, self.assets);
+
+        // If color is enabled and a palette is provided, build a colorized LayoutJob.
+        let response = if self.theme.enable_color {
+            if let Some(pal) = &self.theme.palette {
+                let mut job = egui::text::LayoutJob::default();
+                // Make sure this uses a monospace font
+                let mono = egui::FontId::monospace(12.0);
+
+                for (row_idx, line) in rendered_string.lines().enumerate() {
+                    for ch in line.chars() {
+                        let color = match ch {
+                            // Water surface
+                            '~' | '^' => pal.water,
+                            // Seaweed
+                            '(' | ')' => pal.seaweed,
+                            // Castle (fallback to text color; many different chars)
+                            // We leave castle to default unless specifically themed elsewhere.
+                            // Ship (same approach as castle)
+                            // Bubbles
+                            '.' => pal.bubble,
+                            // Mask placeholders from original assets: color as subtle water trail
+                            '?' => pal.water_trail,
+                            // Default fish and all other glyphs
+                            _ => self.theme.text_color,
+                        };
+                        job.append(
+                            &ch.to_string(),
+                            0.0,
+                            egui::TextFormat {
+                                font_id: mono.clone(),
+                                color,
+                                ..Default::default()
+                            },
+                        );
+                    }
+                    if row_idx + 1 < self.state.size.1 {
+                        job.append(
+                            "\n",
+                            0.0,
+                            egui::TextFormat {
+                                font_id: mono.clone(),
+                                color: self.theme.text_color,
+                                ..Default::default()
+                            },
+                        );
+                    }
+                }
+
+                let label =
+                    egui::Label::new(egui::WidgetText::LayoutJob(job)).wrap(self.theme.wrap);
+                if let Some(fill) = self.theme.background {
+                    egui::Frame::default()
+                        .fill(fill)
+                        .show(ui, |ui| ui.add(label))
+                        .response
+                } else {
+                    ui.add(label)
+                }
+            } else {
+                // Palette missing, fall back to plain text
+                let text = egui::RichText::new(rendered_string)
+                    .monospace()
+                    .color(self.theme.text_color);
+                let label = egui::Label::new(text).wrap(self.theme.wrap);
+                if let Some(fill) = self.theme.background {
+                    egui::Frame::default()
+                        .fill(fill)
+                        .show(ui, |ui| ui.add(label))
+                        .response
+                } else {
+                    ui.add(label)
+                }
+            }
         } else {
-            ui.add(label)
-        }
+            // Plain text path (default)
+            let text = egui::RichText::new(rendered_string)
+                .monospace()
+                .color(self.theme.text_color);
+            let label = egui::Label::new(text).wrap(self.theme.wrap);
+            if let Some(fill) = self.theme.background {
+                egui::Frame::default()
+                    .fill(fill)
+                    .show(ui, |ui| ui.add(label))
+                    .response
+            } else {
+                ui.add(label)
+            }
+        };
+
+        response
     }
 }