+291

src/animation.rs

reviewed

··· 1 1 + //! Animation system: parameter targeting, ping-pong interpolation, and frame loop. 2 2 + 3 3 + use std::fmt; 4 4 + use std::io::{self, Write}; 5 5 + use std::str::FromStr; 6 6 + use std::thread; 7 7 + use std::time::Duration; 8 8 + 9 9 + use crate::clood::{self, Clood, EyeState}; 10 10 + 11 11 + // ── Animatable parameters ─────────────────────────────────────────────────── 12 12 + 13 13 + /// Every parameter that can be targeted by `--anim`. 14 14 + #[derive(Debug, Clone, Copy, PartialEq, Eq)] 15 15 + pub enum AnimParam { 16 16 + Mood, 17 17 + LeftEye, 18 18 + RightEye, 19 19 + LeftEyeClosed, 20 20 + RightEyeClosed, 21 21 + Round, 22 22 + LeftArm, 23 23 + RightArm, 24 24 + Height, 25 25 + Width, 26 26 + ArmSize, 27 27 + LegSize, 28 28 + NumLegs, 29 29 + } 30 30 + 31 31 + impl FromStr for AnimParam { 32 32 + type Err = String; 33 33 + 34 34 + fn from_str(s: &str) -> Result<Self, Self::Err> { 35 35 + match s { 36 36 + "mood" => Ok(Self::Mood), 37 37 + "lefteye" => Ok(Self::LeftEye), 38 38 + "righteye" => Ok(Self::RightEye), 39 39 + "lefteyeclosed" => Ok(Self::LeftEyeClosed), 40 40 + "righteyeclosed" => Ok(Self::RightEyeClosed), 41 41 + "round" => Ok(Self::Round), 42 42 + "leftarm" => Ok(Self::LeftArm), 43 43 + "rightarm" => Ok(Self::RightArm), 44 44 + "height" => Ok(Self::Height), 45 45 + "width" => Ok(Self::Width), 46 46 + "armsize" => Ok(Self::ArmSize), 47 47 + "legsize" => Ok(Self::LegSize), 48 48 + "numlegs" => Ok(Self::NumLegs), 49 49 + _ => Err(format!( 50 50 + "unknown parameter '{}'. Valid: mood, lefteye, righteye, \ 51 51 + lefteyeclosed, righteyeclosed, round, leftarm, rightarm, \ 52 52 + height, width, armsize, legsize, numlegs", 53 53 + s 54 54 + )), 55 55 + } 56 56 + } 57 57 + } 58 58 + 59 59 + impl fmt::Display for AnimParam { 60 60 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 61 61 + let name = match self { 62 62 + Self::Mood => "mood", 63 63 + Self::LeftEye => "lefteye", 64 64 + Self::RightEye => "righteye", 65 65 + Self::LeftEyeClosed => "lefteyeclosed", 66 66 + Self::RightEyeClosed => "righteyeclosed", 67 67 + Self::Round => "round", 68 68 + Self::LeftArm => "leftarm", 69 69 + Self::RightArm => "rightarm", 70 70 + Self::Height => "height", 71 71 + Self::Width => "width", 72 72 + Self::ArmSize => "armsize", 73 73 + Self::LegSize => "legsize", 74 74 + Self::NumLegs => "numlegs", 75 75 + }; 76 76 + write!(f, "{}", name) 77 77 + } 78 78 + } 79 79 + 80 80 + // ── Animation spec ────────────────────────────────────────────────────────── 81 81 + 82 82 + /// A single animation: ping-pong a parameter between two values. 83 83 + #[derive(Debug, Clone)] 84 84 + pub struct Animation { 85 85 + pub param: AnimParam, 86 86 + pub min: i32, 87 87 + pub max: i32, 88 88 + } 89 89 + 90 90 + impl Animation { 91 91 + /// Parse "param:min:max" (e.g. "mood:-1:3"). 92 92 + /// The last colon separates min from max, allowing negative min values. 93 93 + pub fn parse(s: &str) -> Result<Self, String> { 94 94 + let first_colon = s 95 95 + .find(':') 96 96 + .ok_or_else(|| format!("expected param:min:max, got '{}'", s))?; 97 97 + 98 98 + let param_str = &s[..first_colon]; 99 99 + let range_str = &s[first_colon + 1..]; 100 100 + 101 101 + let last_colon = range_str 102 102 + .rfind(':') 103 103 + .ok_or_else(|| format!("expected min:max in '{}', got '{}'", s, range_str))?; 104 104 + 105 105 + let param = AnimParam::from_str(param_str)?; 106 106 + let min = range_str[..last_colon] 107 107 + .parse::<i32>() 108 108 + .map_err(|e| format!("invalid min value in '{}': {}", s, e))?; 109 109 + let max = range_str[last_colon + 1..] 110 110 + .parse::<i32>() 111 111 + .map_err(|e| format!("invalid max value in '{}': {}", s, e))?; 112 112 + 113 113 + Ok(Animation { param, min, max }) 114 114 + } 115 115 + 116 116 + /// Compute the value at a given tick, ping-ponging between min and max. 117 117 + /// Tick 0 → min, ticks increase toward max, then bounce back. 118 118 + pub fn value_at(&self, tick: usize) -> i32 { 119 119 + let range = self.min.abs_diff(self.max) as usize; 120 120 + if range == 0 { 121 121 + return self.min; 122 122 + } 123 123 + let direction = if self.max >= self.min { 1i32 } else { -1 }; 124 124 + let cycle_length = range * 2; 125 125 + let position = tick % cycle_length; 126 126 + 127 127 + if position <= range { 128 128 + self.min + (position as i32) * direction 129 129 + } else { 130 130 + self.max - ((position - range) as i32) * direction 131 131 + } 132 132 + } 133 133 + } 134 134 + 135 135 + // ── Frame state ───────────────────────────────────────────────────────────── 136 136 + 137 137 + /// Mutable snapshot of all animatable parameter values for one frame. 138 138 + /// Starts from base values, then animations override individual fields. 139 139 + struct FrameState { 140 140 + mood: i32, 141 141 + left_eye_offset: i32, 142 142 + right_eye_offset: i32, 143 143 + left_eye_closed: i32, 144 144 + right_eye_closed: i32, 145 145 + round: i32, 146 146 + left_arm_offset: i32, 147 147 + right_arm_offset: i32, 148 148 + height: usize, 149 149 + width: usize, 150 150 + arm_size: usize, 151 151 + leg_size: usize, 152 152 + num_legs: usize, 153 153 + } 154 154 + 155 155 + impl FrameState { 156 156 + /// Initialize from a base Clood configuration. 157 157 + fn from_clood(c: &Clood) -> Self { 158 158 + FrameState { 159 159 + mood: c.mood, 160 160 + left_eye_offset: c.left_eye.offset, 161 161 + right_eye_offset: c.right_eye.offset, 162 162 + left_eye_closed: if c.left_eye.closed { 1 } else { 0 }, 163 163 + right_eye_closed: if c.right_eye.closed { 1 } else { 0 }, 164 164 + round: c.round as i32, 165 165 + left_arm_offset: c.left_arm_offset, 166 166 + right_arm_offset: c.right_arm_offset, 167 167 + height: c.height, 168 168 + width: c.width, 169 169 + arm_size: c.arm_size, 170 170 + leg_size: c.leg_size, 171 171 + num_legs: c.num_legs, 172 172 + } 173 173 + } 174 174 + 175 175 + /// Apply an animation's current value to the appropriate field. 176 176 + fn apply(&mut self, param: AnimParam, value: i32) { 177 177 + match param { 178 178 + AnimParam::Mood => self.mood = value, 179 179 + AnimParam::LeftEye => self.left_eye_offset = value, 180 180 + AnimParam::RightEye => self.right_eye_offset = value, 181 181 + AnimParam::LeftEyeClosed => self.left_eye_closed = value, 182 182 + AnimParam::RightEyeClosed => self.right_eye_closed = value, 183 183 + AnimParam::Round => self.round = value, 184 184 + AnimParam::LeftArm => self.left_arm_offset = value, 185 185 + AnimParam::RightArm => self.right_arm_offset = value, 186 186 + AnimParam::Height => self.height = value.max(3) as usize, 187 187 + AnimParam::Width => self.width = value.max(4) as usize, 188 188 + AnimParam::ArmSize => self.arm_size = value.max(0) as usize, 189 189 + AnimParam::LegSize => self.leg_size = value.max(0) as usize, 190 190 + AnimParam::NumLegs => self.num_legs = value.max(0) as usize, 191 191 + } 192 192 + } 193 193 + 194 194 + /// Convert back to a Clood, preserving colors from the base. 195 195 + fn to_clood(&self, base: &Clood) -> Clood { 196 196 + Clood { 197 197 + width: self.width, 198 198 + height: self.height, 199 199 + round: self.round.max(0) as usize, 200 200 + mood: self.mood, 201 201 + left_eye: EyeState { 202 202 + offset: self.left_eye_offset, 203 203 + closed: self.left_eye_closed != 0, 204 204 + }, 205 205 + right_eye: EyeState { 206 206 + offset: self.right_eye_offset, 207 207 + closed: self.right_eye_closed != 0, 208 208 + }, 209 209 + arm_size: self.arm_size, 210 210 + left_arm_offset: self.left_arm_offset, 211 211 + right_arm_offset: self.right_arm_offset, 212 212 + num_legs: self.num_legs, 213 213 + leg_size: self.leg_size, 214 214 + body_color: base.body_color, 215 215 + eye_color: base.eye_color, 216 216 + } 217 217 + } 218 218 + } 219 219 + 220 220 + // ── Terminal helpers ───────────────────────────────────────────────────────── 221 221 + 222 222 + /// ANSI escape: hide the cursor. 223 223 + fn hide_cursor() { 224 224 + print!("\x1b[?25l"); 225 225 + let _ = io::stdout().flush(); 226 226 + } 227 227 + 228 228 + /// ANSI escape: show the cursor. 229 229 + fn show_cursor() { 230 230 + print!("\x1b[?25h"); 231 231 + let _ = io::stdout().flush(); 232 232 + } 233 233 + 234 234 + /// Write a frame to stdout, moving the cursor up to overwrite the previous frame. 235 235 + /// Handles the case where the previous frame was taller (clears leftover lines). 236 236 + fn write_frame(frame: &str, current_height: usize, prev_height: usize) { 237 237 + if prev_height > 0 { 238 238 + print!("\x1b[{}A", prev_height); 239 239 + } 240 240 + 241 241 + if prev_height > current_height { 242 242 + for line in frame.lines() { 243 243 + print!("{}\x1b[K\n", line); 244 244 + } 245 245 + for _ in 0..(prev_height - current_height) { 246 246 + print!("\x1b[K\n"); 247 247 + } 248 248 + print!("\x1b[{}A", prev_height - current_height); 249 249 + } else { 250 250 + for line in frame.lines() { 251 251 + print!("{}\x1b[K\n", line); 252 252 + } 253 253 + } 254 254 + 255 255 + let _ = io::stdout().flush(); 256 256 + } 257 257 + 258 258 + // ── Animation loop ────────────────────────────────────────────────────────── 259 259 + 260 260 + /// Run an infinite animation loop, rendering at the given FPS. 261 261 + pub fn run_loop(base: &Clood, animations: &[Animation], fps: u32) -> ! { 262 262 + let frame_delay = Duration::from_millis(1000 / fps.max(1) as u64); 263 263 + let mut tick: usize = 0; 264 264 + let mut prev_height: usize = 0; 265 265 + 266 266 + hide_cursor(); 267 267 + 268 268 + ctrlc::set_handler(move || { 269 269 + show_cursor(); 270 270 + std::process::exit(0); 271 271 + }) 272 272 + .expect("Failed to set Ctrl-C handler"); 273 273 + 274 274 + loop { 275 275 + let mut state = FrameState::from_clood(base); 276 276 + for anim in animations { 277 277 + state.apply(anim.param, anim.value_at(tick)); 278 278 + } 279 279 + let frame_clood = state.to_clood(base); 280 280 + 281 281 + let frame = clood::render(&frame_clood); 282 282 + let height = frame_clood.sanitized().rendered_height(); 283 283 + 284 284 + write_frame(&frame, height, prev_height); 285 285 + 286 286 + prev_height = height; 287 287 + tick = tick.wrapping_add(1); 288 288 + 289 289 + thread::sleep(frame_delay); 290 290 + } 291 291 + }

+256

src/clood.rs

reviewed

··· 1 1 + //! Core clood type, rendering, and leg layout. 2 2 + 3 3 + use crate::color::Color; 4 4 + 5 5 + // ── Types ─────────────────────────────────────────────────────────────────── 6 6 + 7 7 + /// Configuration for one eye: vertical offset and open/closed state. 8 8 + #[derive(Debug, Clone, Copy)] 9 9 + pub struct EyeState { 10 10 + /// Vertical offset from the mood baseline. Positive = higher. 11 11 + pub offset: i32, 12 12 + /// Whether the eye is closed (drawn as a half block). 13 13 + pub closed: bool, 14 14 + } 15 15 + 16 16 + /// All resolved parameters for rendering a single frame. 17 17 + #[derive(Debug, Clone)] 18 18 + pub struct Clood { 19 19 + /// Body width in columns (minimum 4). 20 20 + pub width: usize, 21 21 + /// Body height in rows (minimum 3). 22 22 + pub height: usize, 23 23 + /// Corner rounding: how many columns to cut from top corners (0 to width/2). 24 24 + pub round: usize, 25 25 + 26 26 + /// Eye mood baseline offset from center. Positive = eyes higher. 27 27 + pub mood: i32, 28 28 + pub left_eye: EyeState, 29 29 + pub right_eye: EyeState, 30 30 + 31 31 + /// Width of each arm in columns. 32 32 + pub arm_size: usize, 33 33 + /// Vertical offset of left arm from default position. Positive = higher. 34 34 + pub left_arm_offset: i32, 35 35 + /// Vertical offset of right arm from default position. Positive = higher. 36 36 + pub right_arm_offset: i32, 37 37 + 38 38 + /// Number of legs (0 for legless, typically even). 39 39 + pub num_legs: usize, 40 40 + /// Length of each leg in rows. 41 41 + pub leg_size: usize, 42 42 + 43 43 + pub body_color: Color, 44 44 + pub eye_color: Color, 45 45 + } 46 46 + 47 47 + impl Clood { 48 48 + /// Ensure all dimensions are within valid bounds. 49 49 + pub fn sanitized(&self) -> Clood { 50 50 + let mut c = self.clone(); 51 51 + c.width = c.width.max(4); 52 52 + c.height = c.height.max(3); 53 53 + c.round = c.round.min(c.width / 2); 54 54 + c 55 55 + } 56 56 + 57 57 + /// Total rendered height including legs (for cursor repositioning). 58 58 + pub fn rendered_height(&self) -> usize { 59 59 + let body_height = self.height.max(3); 60 60 + let leg_rows = if self.num_legs == 0 { 0 } else { self.leg_size }; 61 61 + body_height + leg_rows 62 62 + } 63 63 + } 64 64 + 65 65 + // ── Rendering ─────────────────────────────────────────────────────────────── 66 66 + 67 67 + /// Render a clood to a string of ANSI-colored unicode blocks. 68 68 + pub fn render(clood: &Clood) -> String { 69 69 + let c = clood.sanitized(); 70 70 + 71 71 + let body_block = c.body_color.full_block(); 72 72 + let eye_open = c.eye_color.full_block(); 73 73 + let eye_closed = c.eye_color.half_block(); 74 74 + let space = " "; 75 75 + 76 76 + // ── Eye positions ─────────────────────────────────────────────────── 77 77 + let eye_baseline = compute_eye_baseline(c.height, c.mood); 78 78 + let left_eye_row = clamp_to_body(eye_baseline - c.left_eye.offset, c.height); 79 79 + let right_eye_row = clamp_to_body(eye_baseline - c.right_eye.offset, c.height); 80 80 + 81 81 + // Eyes sit at ~1/3 and ~2/3 across the body width. 82 82 + let left_eye_col = c.width / 3; 83 83 + let right_eye_col = c.width - 1 - (c.width / 3); 84 84 + 85 85 + // ── Arm positions ─────────────────────────────────────────────────── 86 86 + // Arms default to one row below the lower eye. 87 87 + let arm_default_row = (left_eye_row.max(right_eye_row) + 1).min(c.height - 1); 88 88 + let left_arm_row = clamp_row(arm_default_row as i32 - c.left_arm_offset, c.height); 89 89 + let right_arm_row = clamp_row(arm_default_row as i32 - c.right_arm_offset, c.height); 90 90 + 91 91 + let arm_pad = c.arm_size; 92 92 + let total_cols = arm_pad + c.width + arm_pad; 93 93 + 94 94 + let mut output = String::new(); 95 95 + 96 96 + // ── Body rows (including arms and eyes) ───────────────────────────── 97 97 + for row in 0..c.height { 98 98 + let corner_cut = corner_rounding(row, c.round); 99 99 + 100 100 + for col in 0..total_cols { 101 101 + let region = classify_column(col, arm_pad, c.width); 102 102 + 103 103 + match region { 104 104 + ColumnRegion::LeftArm if row == left_arm_row => { 105 105 + output.push_str(&body_block); 106 106 + } 107 107 + ColumnRegion::RightArm if row == right_arm_row => { 108 108 + output.push_str(&body_block); 109 109 + } 110 110 + ColumnRegion::Body(body_col) => { 111 111 + if body_col < corner_cut || body_col >= c.width - corner_cut { 112 112 + output.push_str(space); 113 113 + } else if row == left_eye_row && body_col == left_eye_col { 114 114 + output.push_str(if c.left_eye.closed { &eye_closed } else { &eye_open }); 115 115 + } else if row == right_eye_row && body_col == right_eye_col { 116 116 + output.push_str(if c.right_eye.closed { &eye_closed } else { &eye_open }); 117 117 + } else { 118 118 + output.push_str(&body_block); 119 119 + } 120 120 + } 121 121 + _ => output.push_str(space), 122 122 + } 123 123 + } 124 124 + output.push('\n'); 125 125 + } 126 126 + 127 127 + // ── Leg rows ──────────────────────────────────────────────────────── 128 128 + let legs = LegLayout::compute(c.width, c.num_legs); 129 129 + let leg_rows = if c.num_legs == 0 { 0 } else { c.leg_size }; 130 130 + let leg_pad = (arm_pad as i32 + legs.inset).max(0) as usize; 131 131 + 132 132 + for _ in 0..leg_rows { 133 133 + for _ in 0..leg_pad { 134 134 + output.push_str(space); 135 135 + } 136 136 + for &has_leg in &legs.columns { 137 137 + output.push_str(if has_leg { &body_block } else { space }); 138 138 + } 139 139 + output.push('\n'); 140 140 + } 141 141 + 142 142 + output 143 143 + } 144 144 + 145 145 + // ── Helpers ───────────────────────────────────────────────────────────────── 146 146 + 147 147 + /// Which region of the output grid a column falls in. 148 148 + enum ColumnRegion { 149 149 + LeftArm, 150 150 + Body(usize), // column index within the body 151 151 + RightArm, 152 152 + } 153 153 + 154 154 + /// Classify a column index into a region. 155 155 + fn classify_column(col: usize, arm_pad: usize, body_width: usize) -> ColumnRegion { 156 156 + if col < arm_pad { 157 157 + ColumnRegion::LeftArm 158 158 + } else if col < arm_pad + body_width { 159 159 + ColumnRegion::Body(col - arm_pad) 160 160 + } else { 161 161 + ColumnRegion::RightArm 162 162 + } 163 163 + } 164 164 + 165 165 + /// Compute the eye baseline row from body height and mood. 166 166 + /// Returns a signed value for further offset arithmetic. 167 167 + fn compute_eye_baseline(height: usize, mood: i32) -> i32 { 168 168 + let midpoint = height as i32 / 2; 169 169 + (midpoint - mood).clamp(1, height as i32 - 2) 170 170 + } 171 171 + 172 172 + /// Clamp a row into valid body interior rows (1..height-2). 173 173 + fn clamp_to_body(row: i32, height: usize) -> usize { 174 174 + row.clamp(1, height as i32 - 2) as usize 175 175 + } 176 176 + 177 177 + /// Clamp a row value to 0..height-1. 178 178 + fn clamp_row(row: i32, height: usize) -> usize { 179 179 + row.clamp(0, height as i32 - 1) as usize 180 180 + } 181 181 + 182 182 + /// How many columns to cut from each side of a body row for corner rounding. 183 183 + /// Row 0 gets the full `round` cut; each subsequent row gets one less. 184 184 + fn corner_rounding(row: usize, round: usize) -> usize { 185 185 + round.saturating_sub(row) 186 186 + } 187 187 + 188 188 + // ── Leg layout ────────────────────────────────────────────────────────────── 189 189 + 190 190 + /// The computed layout for legs beneath the body. 191 191 + struct LegLayout { 192 192 + /// Boolean mask: true at each column where a leg is drawn. 193 193 + columns: Vec<bool>, 194 194 + /// How much the leg span is offset from the body left edge. 195 195 + /// Positive = inset (narrower), negative = outset (wider). 196 196 + inset: i32, 197 197 + } 198 198 + 199 199 + impl LegLayout { 200 200 + /// Compute the optimal leg placement for the given body width and leg count. 201 201 + /// 202 202 + /// Prefers inset by 1 (legs narrower than body) for a cleaner look. 203 203 + /// Falls back to full body width, then outset by 1 if needed. 204 204 + /// Adjacent legs always have at least 1 gap between them. 205 205 + fn compute(body_width: usize, num_legs: usize) -> Self { 206 206 + if num_legs == 0 { 207 207 + return LegLayout { 208 208 + columns: vec![false; body_width], 209 209 + inset: 0, 210 210 + }; 211 211 + } 212 212 + 213 213 + // Minimum span to guarantee gaps: N legs need 2N-1 columns. 214 214 + let min_span = if num_legs <= 1 { 1 } else { 2 * num_legs - 1 }; 215 215 + 216 216 + // Try from narrowest to widest: inset → flush → outset. 217 217 + let (span, inset) = if body_width >= 4 && body_width - 2 >= min_span { 218 218 + (body_width - 2, 1i32) 219 219 + } else if body_width >= min_span { 220 220 + (body_width, 0i32) 221 221 + } else { 222 222 + (body_width + 2, -1i32) 223 223 + }; 224 224 + 225 225 + let mut columns = vec![false; span]; 226 226 + 227 227 + if num_legs == 1 { 228 228 + columns[span / 2] = true; 229 229 + return LegLayout { columns, inset }; 230 230 + } 231 231 + 232 232 + // Distribute legs with symmetric gap widths. 233 233 + // Extra-wide gaps are centered in the middle for visual balance. 234 234 + let num_gaps = num_legs - 1; 235 235 + let base_gap = (span - 1) / num_gaps; 236 236 + let extra_gaps = (span - 1) % num_gaps; 237 237 + 238 238 + let mut gap_sizes = vec![base_gap; num_gaps]; 239 239 + let first_wide = (num_gaps - extra_gaps) / 2; 240 240 + for gap in gap_sizes.iter_mut().skip(first_wide).take(extra_gaps) { 241 241 + *gap += 1; 242 242 + } 243 243 + 244 244 + let mut col = 0usize; 245 245 + for (i, _) in (0..num_legs).enumerate() { 246 246 + if col < span { 247 247 + columns[col] = true; 248 248 + } 249 249 + if i < num_gaps { 250 250 + col += gap_sizes[i]; 251 251 + } 252 252 + } 253 253 + 254 254 + LegLayout { columns, inset } 255 255 + } 256 256 + }

+47

src/color.rs

reviewed

··· 1 1 + //! RGB color type with hex parsing, random generation, and ANSI block rendering. 2 2 + 3 3 + use rand::Rng; 4 4 + 5 5 + /// An RGB color, used for body and eye rendering. 6 6 + #[derive(Debug, Clone, Copy)] 7 7 + pub struct Color { 8 8 + pub r: u8, 9 9 + pub g: u8, 10 10 + pub b: u8, 11 11 + } 12 12 + 13 13 + impl Color { 14 14 + /// Parse a hex color string like "#88DDFF" or "88DDFF". 15 15 + /// Returns None if the string is too short or contains invalid hex. 16 16 + pub fn from_hex(hex: &str) -> Option<Color> { 17 17 + let hex = hex.trim_start_matches('#'); 18 18 + if hex.len() < 6 { 19 19 + return None; 20 20 + } 21 21 + Some(Color { 22 22 + r: u8::from_str_radix(&hex[0..2], 16).ok()?, 23 23 + g: u8::from_str_radix(&hex[2..4], 16).ok()?, 24 24 + b: u8::from_str_radix(&hex[4..6], 16).ok()?, 25 25 + }) 26 26 + } 27 27 + 28 28 + /// Generate a random color with each channel in 40..=255 29 29 + /// (avoids very dark colors that vanish on dark terminals). 30 30 + pub fn random(rng: &mut impl Rng) -> Color { 31 31 + Color { 32 32 + r: rng.gen_range(40..=255), 33 33 + g: rng.gen_range(40..=255), 34 34 + b: rng.gen_range(40..=255), 35 35 + } 36 36 + } 37 37 + 38 38 + /// Full block character `█` in this color using ANSI true color. 39 39 + pub fn full_block(&self) -> String { 40 40 + format!("\x1b[38;2;{};{};{}m\u{2588}\x1b[0m", self.r, self.g, self.b) 41 41 + } 42 42 + 43 43 + /// Lower half block `▄` in this color (used for closed eyes). 44 44 + pub fn half_block(&self) -> String { 45 45 + format!("\x1b[38;2;{};{};{}m\u{2584}\x1b[0m", self.r, self.g, self.b) 46 46 + } 47 47 + }

+26 -593

src/main.rs

reviewed

··· 1 1 - use clap::Parser; 2 2 - use rand::Rng; 3 3 - use std::fmt; 4 4 - use std::io::{self, Write}; 5 5 - use std::str::FromStr; 6 6 - use std::thread; 7 7 - use std::time::Duration; 8 8 - 9 9 - // ── Color ─────────────────────────────────────────────────────────────────── 10 10 - 11 11 - /// An RGB color, used for body and eye rendering. 12 12 - #[derive(Debug, Clone, Copy)] 13 13 - struct Color { 14 14 - r: u8, 15 15 - g: u8, 16 16 - b: u8, 17 17 - } 18 18 - 19 19 - impl Color { 20 20 - /// Parse a hex color string like "#88DDFF" or "88DDFF". 21 21 - /// Returns None if the string is too short or contains invalid hex. 22 22 - fn from_hex(hex: &str) -> Option<Color> { 23 23 - let hex = hex.trim_start_matches('#'); 24 24 - if hex.len() < 6 { 25 25 - return None; 26 26 - } 27 27 - Some(Color { 28 28 - r: u8::from_str_radix(&hex[0..2], 16).ok()?, 29 29 - g: u8::from_str_radix(&hex[2..4], 16).ok()?, 30 30 - b: u8::from_str_radix(&hex[4..6], 16).ok()?, 31 31 - }) 32 32 - } 33 33 - 34 34 - /// Generate a random color with each channel in 40..=255 35 35 - /// (avoids very dark colors that vanish on dark terminals). 36 36 - fn random(rng: &mut impl Rng) -> Color { 37 37 - Color { 38 38 - r: rng.gen_range(40..=255), 39 39 - g: rng.gen_range(40..=255), 40 40 - b: rng.gen_range(40..=255), 41 41 - } 42 42 - } 43 43 - 44 44 - /// Full block character `█` in this color using ANSI true color. 45 45 - fn full_block(&self) -> String { 46 46 - format!("\x1b[38;2;{};{};{}m\u{2588}\x1b[0m", self.r, self.g, self.b) 47 47 - } 48 48 - 49 49 - /// Lower half block `▄` in this color (used for closed eyes). 50 50 - fn half_block(&self) -> String { 51 51 - format!("\x1b[38;2;{};{};{}m\u{2584}\x1b[0m", self.r, self.g, self.b) 52 52 - } 53 53 - } 54 54 - 55 55 - // ── Animatable parameters ─────────────────────────────────────────────────── 56 56 - 57 57 - /// Every parameter that can be targeted by `--anim`. 58 58 - #[derive(Debug, Clone, Copy, PartialEq, Eq)] 59 59 - enum AnimParam { 60 60 - Mood, 61 61 - LeftEye, 62 62 - RightEye, 63 63 - LeftEyeClosed, 64 64 - RightEyeClosed, 65 65 - Round, 66 66 - LeftArm, 67 67 - RightArm, 68 68 - Height, 69 69 - Width, 70 70 - ArmSize, 71 71 - LegSize, 72 72 - NumLegs, 73 73 - } 74 74 - 75 75 - impl FromStr for AnimParam { 76 76 - type Err = String; 77 77 - 78 78 - fn from_str(s: &str) -> Result<Self, Self::Err> { 79 79 - match s { 80 80 - "mood" => Ok(Self::Mood), 81 81 - "lefteye" => Ok(Self::LeftEye), 82 82 - "righteye" => Ok(Self::RightEye), 83 83 - "lefteyeclosed" => Ok(Self::LeftEyeClosed), 84 84 - "righteyeclosed" => Ok(Self::RightEyeClosed), 85 85 - "round" => Ok(Self::Round), 86 86 - "leftarm" => Ok(Self::LeftArm), 87 87 - "rightarm" => Ok(Self::RightArm), 88 88 - "height" => Ok(Self::Height), 89 89 - "width" => Ok(Self::Width), 90 90 - "armsize" => Ok(Self::ArmSize), 91 91 - "legsize" => Ok(Self::LegSize), 92 92 - "numlegs" => Ok(Self::NumLegs), 93 93 - _ => Err(format!("unknown parameter '{}'. Valid: mood, lefteye, righteye, \ 94 94 - lefteyeclosed, righteyeclosed, round, leftarm, rightarm, \ 95 95 - height, width, armsize, legsize, numlegs", s)), 96 96 - } 97 97 - } 98 98 - } 99 99 - 100 100 - impl fmt::Display for AnimParam { 101 101 - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 102 102 - let name = match self { 103 103 - Self::Mood => "mood", 104 104 - Self::LeftEye => "lefteye", 105 105 - Self::RightEye => "righteye", 106 106 - Self::LeftEyeClosed => "lefteyeclosed", 107 107 - Self::RightEyeClosed => "righteyeclosed", 108 108 - Self::Round => "round", 109 109 - Self::LeftArm => "leftarm", 110 110 - Self::RightArm => "rightarm", 111 111 - Self::Height => "height", 112 112 - Self::Width => "width", 113 113 - Self::ArmSize => "armsize", 114 114 - Self::LegSize => "legsize", 115 115 - Self::NumLegs => "numlegs", 116 116 - }; 117 117 - write!(f, "{}", name) 118 118 - } 119 119 - } 120 120 - 121 121 - // ── Animation spec ────────────────────────────────────────────────────────── 122 122 - 123 123 - /// A single animation: ping-pong a parameter between two values. 124 124 - #[derive(Debug, Clone)] 125 125 - struct Animation { 126 126 - param: AnimParam, 127 127 - min: i32, 128 128 - max: i32, 129 129 - } 130 130 - 131 131 - impl Animation { 132 132 - /// Parse "param:min:max" (e.g. "mood:-1:3"). 133 133 - /// The last colon separates min from max, allowing negative min values. 134 134 - fn parse(s: &str) -> Result<Self, String> { 135 135 - let first_colon = s.find(':') 136 136 - .ok_or_else(|| format!("expected param:min:max, got '{}'", s))?; 137 137 - 138 138 - let param_str = &s[..first_colon]; 139 139 - let range_str = &s[first_colon + 1..]; 140 140 - 141 141 - let last_colon = range_str.rfind(':') 142 142 - .ok_or_else(|| format!("expected min:max in '{}', got '{}'", s, range_str))?; 143 143 - 144 144 - let param = AnimParam::from_str(param_str)?; 145 145 - let min = range_str[..last_colon].parse::<i32>() 146 146 - .map_err(|e| format!("invalid min value in '{}': {}", s, e))?; 147 147 - let max = range_str[last_colon + 1..].parse::<i32>() 148 148 - .map_err(|e| format!("invalid max value in '{}': {}", s, e))?; 149 149 - 150 150 - Ok(Animation { param, min, max }) 151 151 - } 152 152 - 153 153 - /// Compute the value at a given tick, ping-ponging between min and max. 154 154 - /// Tick 0 → min, ticks increase toward max, then bounce back. 155 155 - fn value_at(&self, tick: usize) -> i32 { 156 156 - let range = self.min.abs_diff(self.max) as usize; 157 157 - if range == 0 { 158 158 - return self.min; 159 159 - } 160 160 - let direction = if self.max >= self.min { 1i32 } else { -1 }; 161 161 - let cycle_length = range * 2; 162 162 - let position = tick % cycle_length; 163 163 - 164 164 - if position <= range { 165 165 - self.min + (position as i32) * direction 166 166 - } else { 167 167 - self.max - ((position - range) as i32) * direction 168 168 - } 169 169 - } 170 170 - } 171 171 - 172 172 - // ── Clood parameters ──────────────────────────────────────────────────────── 173 173 - 174 174 - /// Configuration for one eye: vertical offset and open/closed state. 175 175 - #[derive(Debug, Clone, Copy)] 176 176 - struct EyeState { 177 177 - /// Vertical offset from the mood baseline. Positive = higher. 178 178 - offset: i32, 179 179 - /// Whether the eye is closed (drawn as a half block). 180 180 - closed: bool, 181 181 - } 182 182 - 183 183 - /// All resolved parameters for rendering a single frame. 184 184 - #[derive(Debug, Clone)] 185 185 - struct Clood { 186 186 - /// Body width in columns (minimum 4). 187 187 - width: usize, 188 188 - /// Body height in rows (minimum 3). 189 189 - height: usize, 190 190 - /// Corner rounding: how many columns to cut from top corners (0 to width/2). 191 191 - round: usize, 192 192 - 193 193 - /// Eye mood baseline offset from center. Positive = eyes higher. 194 194 - mood: i32, 195 195 - left_eye: EyeState, 196 196 - right_eye: EyeState, 1 1 + //! CLI entry point: parse arguments, build a Clood, render or animate. 197 2 198 198 - /// Width of each arm in columns. 199 199 - arm_size: usize, 200 200 - /// Vertical offset of left arm from default position. Positive = higher. 201 201 - left_arm_offset: i32, 202 202 - /// Vertical offset of right arm from default position. Positive = higher. 203 203 - right_arm_offset: i32, 3 3 + mod animation; 4 4 + mod clood; 5 5 + mod color; 204 6 205 205 - /// Number of legs (0 for legless, typically even). 206 206 - num_legs: usize, 207 207 - /// Length of each leg in rows. 208 208 - leg_size: usize, 7 7 + use clap::Parser; 8 8 + use rand::Rng; 209 9 210 210 - body_color: Color, 211 211 - eye_color: Color, 212 212 - } 213 213 - 214 214 - impl Clood { 215 215 - /// Ensure all dimensions are within valid bounds. 216 216 - fn sanitized(&self) -> Clood { 217 217 - let mut c = self.clone(); 218 218 - c.width = c.width.max(4); 219 219 - c.height = c.height.max(3); 220 220 - c.round = c.round.min(c.width / 2); 221 221 - c 222 222 - } 223 223 - 224 224 - /// Total rendered height including legs (for cursor repositioning). 225 225 - fn rendered_height(&self) -> usize { 226 226 - let body_height = self.height.max(3); 227 227 - let leg_rows = if self.num_legs == 0 { 0 } else { self.leg_size }; 228 228 - body_height + leg_rows 229 229 - } 230 230 - } 231 231 - 232 232 - // ── Leg layout ────────────────────────────────────────────────────────────── 233 233 - 234 234 - /// The computed layout for legs beneath the body. 235 235 - struct LegLayout { 236 236 - /// Boolean mask: true at each column where a leg is drawn. 237 237 - columns: Vec<bool>, 238 238 - /// How much the leg span is offset from the body left edge. 239 239 - /// Positive = inset (narrower), negative = outset (wider). 240 240 - inset: i32, 241 241 - } 242 242 - 243 243 - impl LegLayout { 244 244 - /// Compute the optimal leg placement for the given body width and leg count. 245 245 - /// 246 246 - /// Prefers inset by 1 (legs narrower than body) for a cleaner look. 247 247 - /// Falls back to full body width, then outset by 1 if needed. 248 248 - /// Adjacent legs always have at least 1 gap between them. 249 249 - fn compute(body_width: usize, num_legs: usize) -> Self { 250 250 - if num_legs == 0 { 251 251 - return LegLayout { 252 252 - columns: vec![false; body_width], 253 253 - inset: 0, 254 254 - }; 255 255 - } 256 256 - 257 257 - // Minimum span to guarantee gaps: N legs need 2N-1 columns. 258 258 - let min_span = if num_legs <= 1 { 1 } else { 2 * num_legs - 1 }; 259 259 - 260 260 - // Try from narrowest to widest: inset → flush → outset. 261 261 - let (span, inset) = if body_width >= 4 && body_width - 2 >= min_span { 262 262 - (body_width - 2, 1i32) 263 263 - } else if body_width >= min_span { 264 264 - (body_width, 0i32) 265 265 - } else { 266 266 - (body_width + 2, -1i32) 267 267 - }; 268 268 - 269 269 - let mut columns = vec![false; span]; 270 270 - 271 271 - if num_legs == 1 { 272 272 - columns[span / 2] = true; 273 273 - return LegLayout { columns, inset }; 274 274 - } 275 275 - 276 276 - // Distribute legs with symmetric gap widths. 277 277 - // Extra-wide gaps are centered in the middle for visual balance. 278 278 - let num_gaps = num_legs - 1; 279 279 - let base_gap = (span - 1) / num_gaps; 280 280 - let extra_gaps = (span - 1) % num_gaps; 281 281 - 282 282 - let mut gap_sizes = vec![base_gap; num_gaps]; 283 283 - let first_wide = (num_gaps - extra_gaps) / 2; 284 284 - for gap in gap_sizes.iter_mut().skip(first_wide).take(extra_gaps) { 285 285 - *gap += 1; 286 286 - } 287 287 - 288 288 - let mut col = 0usize; 289 289 - for (i, _) in (0..num_legs).enumerate() { 290 290 - if col < span { 291 291 - columns[col] = true; 292 292 - } 293 293 - if i < num_gaps { 294 294 - col += gap_sizes[i]; 295 295 - } 296 296 - } 297 297 - 298 298 - LegLayout { columns, inset } 299 299 - } 300 300 - } 301 301 - 302 302 - // ── Rendering ─────────────────────────────────────────────────────────────── 303 303 - 304 304 - /// Render a clood to a string of ANSI-colored unicode blocks. 305 305 - fn render(clood: &Clood) -> String { 306 306 - let c = clood.sanitized(); 307 307 - 308 308 - let body_block = c.body_color.full_block(); 309 309 - let eye_open = c.eye_color.full_block(); 310 310 - let eye_closed = c.eye_color.half_block(); 311 311 - let space = " "; 312 312 - 313 313 - // ── Eye positions ─────────────────────────────────────────────────── 314 314 - let eye_baseline_row = compute_eye_baseline(c.height, c.mood); 315 315 - let left_eye_row = clamp_to_body(eye_baseline_row - c.left_eye.offset, c.height); 316 316 - let right_eye_row = clamp_to_body(eye_baseline_row - c.right_eye.offset, c.height); 317 317 - 318 318 - // Eyes sit at ~1/3 and ~2/3 across the body width. 319 319 - let left_eye_col = c.width / 3; 320 320 - let right_eye_col = c.width - 1 - (c.width / 3); 321 321 - 322 322 - // ── Arm positions ─────────────────────────────────────────────────── 323 323 - // Arms default to one row below the lower eye. 324 324 - let arm_default_row = (left_eye_row.max(right_eye_row) + 1).min(c.height - 1); 325 325 - let left_arm_row = clamp_row(arm_default_row as i32 - c.left_arm_offset, c.height); 326 326 - let right_arm_row = clamp_row(arm_default_row as i32 - c.right_arm_offset, c.height); 327 327 - 328 328 - let arm_pad = c.arm_size; 329 329 - let total_cols = arm_pad + c.width + arm_pad; 330 330 - 331 331 - let mut output = String::new(); 332 332 - 333 333 - // ── Body rows (including arms and eyes) ───────────────────────────── 334 334 - for row in 0..c.height { 335 335 - let corner_cut = corner_rounding(row, c.round); 336 336 - 337 337 - for col in 0..total_cols { 338 338 - let region = classify_column(col, arm_pad, c.width); 339 339 - 340 340 - match region { 341 341 - ColumnRegion::LeftArm if row == left_arm_row => { 342 342 - output.push_str(&body_block); 343 343 - } 344 344 - ColumnRegion::RightArm if row == right_arm_row => { 345 345 - output.push_str(&body_block); 346 346 - } 347 347 - ColumnRegion::Body(body_col) => { 348 348 - if body_col < corner_cut || body_col >= c.width - corner_cut { 349 349 - output.push_str(space); 350 350 - } else if row == left_eye_row && body_col == left_eye_col { 351 351 - output.push_str(if c.left_eye.closed { &eye_closed } else { &eye_open }); 352 352 - } else if row == right_eye_row && body_col == right_eye_col { 353 353 - output.push_str(if c.right_eye.closed { &eye_closed } else { &eye_open }); 354 354 - } else { 355 355 - output.push_str(&body_block); 356 356 - } 357 357 - } 358 358 - _ => output.push_str(space), 359 359 - } 360 360 - } 361 361 - output.push('\n'); 362 362 - } 363 363 - 364 364 - // ── Leg rows ──────────────────────────────────────────────────────── 365 365 - let legs = LegLayout::compute(c.width, c.num_legs); 366 366 - let leg_rows = if c.num_legs == 0 { 0 } else { c.leg_size }; 367 367 - let leg_pad = (arm_pad as i32 + legs.inset).max(0) as usize; 368 368 - 369 369 - for _ in 0..leg_rows { 370 370 - for _ in 0..leg_pad { 371 371 - output.push_str(space); 372 372 - } 373 373 - for &has_leg in &legs.columns { 374 374 - output.push_str(if has_leg { &body_block } else { space }); 375 375 - } 376 376 - output.push('\n'); 377 377 - } 378 378 - 379 379 - output 380 380 - } 381 381 - 382 382 - /// Which region of the output grid a column falls in. 383 383 - enum ColumnRegion { 384 384 - LeftArm, 385 385 - Body(usize), // inner value is the column index within the body 386 386 - RightArm, 387 387 - } 388 388 - 389 389 - /// Classify a column index into a region. 390 390 - fn classify_column(col: usize, arm_pad: usize, body_width: usize) -> ColumnRegion { 391 391 - if col < arm_pad { 392 392 - ColumnRegion::LeftArm 393 393 - } else if col < arm_pad + body_width { 394 394 - ColumnRegion::Body(col - arm_pad) 395 395 - } else { 396 396 - ColumnRegion::RightArm 397 397 - } 398 398 - } 399 399 - 400 400 - /// Compute the eye baseline row from body height and mood. 401 401 - /// Returns a signed value for further offset arithmetic. 402 402 - fn compute_eye_baseline(height: usize, mood: i32) -> i32 { 403 403 - let midpoint = height as i32 / 2; 404 404 - (midpoint - mood).clamp(1, height as i32 - 2) 405 405 - } 406 406 - 407 407 - /// Clamp a row into valid body interior rows (1..height-2). 408 408 - fn clamp_to_body(row: i32, height: usize) -> usize { 409 409 - row.clamp(1, height as i32 - 2) as usize 410 410 - } 411 411 - 412 412 - /// Clamp a row value to 0..height-1. 413 413 - fn clamp_row(row: i32, height: usize) -> usize { 414 414 - row.clamp(0, height as i32 - 1) as usize 415 415 - } 416 416 - 417 417 - /// How many columns to cut from each side of a body row for corner rounding. 418 418 - /// Row 0 gets the full `round` cut; each subsequent row gets one less. 419 419 - fn corner_rounding(row: usize, round: usize) -> usize { 420 420 - round.saturating_sub(row) 421 421 - } 422 422 - 423 423 - // ── Animation state ───────────────────────────────────────────────────────── 424 424 - 425 425 - /// Mutable snapshot of all animatable parameter values for one frame. 426 426 - /// Starts from base values, then animations override individual fields. 427 427 - struct AnimState { 428 428 - mood: i32, 429 429 - left_eye_offset: i32, 430 430 - right_eye_offset: i32, 431 431 - left_eye_closed: i32, 432 432 - right_eye_closed: i32, 433 433 - round: i32, 434 434 - left_arm_offset: i32, 435 435 - right_arm_offset: i32, 436 436 - height: usize, 437 437 - width: usize, 438 438 - arm_size: usize, 439 439 - leg_size: usize, 440 440 - num_legs: usize, 441 441 - } 442 442 - 443 443 - impl AnimState { 444 444 - /// Initialize from a base Clood configuration. 445 445 - fn from_clood(c: &Clood) -> Self { 446 446 - AnimState { 447 447 - mood: c.mood, 448 448 - left_eye_offset: c.left_eye.offset, 449 449 - right_eye_offset: c.right_eye.offset, 450 450 - left_eye_closed: if c.left_eye.closed { 1 } else { 0 }, 451 451 - right_eye_closed: if c.right_eye.closed { 1 } else { 0 }, 452 452 - round: c.round as i32, 453 453 - left_arm_offset: c.left_arm_offset, 454 454 - right_arm_offset: c.right_arm_offset, 455 455 - height: c.height, 456 456 - width: c.width, 457 457 - arm_size: c.arm_size, 458 458 - leg_size: c.leg_size, 459 459 - num_legs: c.num_legs, 460 460 - } 461 461 - } 462 462 - 463 463 - /// Apply an animation's current value to the appropriate field. 464 464 - fn apply(&mut self, param: AnimParam, value: i32) { 465 465 - match param { 466 466 - AnimParam::Mood => self.mood = value, 467 467 - AnimParam::LeftEye => self.left_eye_offset = value, 468 468 - AnimParam::RightEye => self.right_eye_offset = value, 469 469 - AnimParam::LeftEyeClosed => self.left_eye_closed = value, 470 470 - AnimParam::RightEyeClosed => self.right_eye_closed = value, 471 471 - AnimParam::Round => self.round = value, 472 472 - AnimParam::LeftArm => self.left_arm_offset = value, 473 473 - AnimParam::RightArm => self.right_arm_offset = value, 474 474 - AnimParam::Height => self.height = value.max(3) as usize, 475 475 - AnimParam::Width => self.width = value.max(4) as usize, 476 476 - AnimParam::ArmSize => self.arm_size = value.max(0) as usize, 477 477 - AnimParam::LegSize => self.leg_size = value.max(0) as usize, 478 478 - AnimParam::NumLegs => self.num_legs = value.max(0) as usize, 479 479 - } 480 480 - } 481 481 - 482 482 - /// Convert back to a Clood, preserving colors from the base. 483 483 - fn to_clood(&self, base: &Clood) -> Clood { 484 484 - Clood { 485 485 - width: self.width, 486 486 - height: self.height, 487 487 - round: self.round.max(0) as usize, 488 488 - mood: self.mood, 489 489 - left_eye: EyeState { 490 490 - offset: self.left_eye_offset, 491 491 - closed: self.left_eye_closed != 0, 492 492 - }, 493 493 - right_eye: EyeState { 494 494 - offset: self.right_eye_offset, 495 495 - closed: self.right_eye_closed != 0, 496 496 - }, 497 497 - arm_size: self.arm_size, 498 498 - left_arm_offset: self.left_arm_offset, 499 499 - right_arm_offset: self.right_arm_offset, 500 500 - num_legs: self.num_legs, 501 501 - leg_size: self.leg_size, 502 502 - body_color: base.body_color, 503 503 - eye_color: base.eye_color, 504 504 - } 505 505 - } 506 506 - } 507 507 - 508 508 - // ── Terminal helpers ───────────────────────────────────────────────────────── 509 509 - 510 510 - /// ANSI escape: hide the cursor. 511 511 - fn hide_cursor() { 512 512 - print!("\x1b[?25l"); 513 513 - let _ = io::stdout().flush(); 514 514 - } 515 515 - 516 516 - /// ANSI escape: show the cursor. 517 517 - fn show_cursor() { 518 518 - print!("\x1b[?25h"); 519 519 - let _ = io::stdout().flush(); 520 520 - } 521 521 - 522 522 - /// Write a frame to stdout, moving the cursor up to overwrite the previous frame. 523 523 - /// Handles the case where the previous frame was taller (clears leftover lines). 524 524 - fn write_frame(frame: &str, current_height: usize, prev_height: usize) { 525 525 - if prev_height > 0 { 526 526 - print!("\x1b[{}A", prev_height); 527 527 - } 528 528 - 529 529 - if prev_height > current_height { 530 530 - // Frame got shorter: print frame, clear leftover lines, move cursor back. 531 531 - for line in frame.lines() { 532 532 - print!("{}\x1b[K\n", line); 533 533 - } 534 534 - for _ in 0..(prev_height - current_height) { 535 535 - print!("\x1b[K\n"); 536 536 - } 537 537 - print!("\x1b[{}A", prev_height - current_height); 538 538 - } else { 539 539 - for line in frame.lines() { 540 540 - print!("{}\x1b[K\n", line); 541 541 - } 542 542 - } 543 543 - 544 544 - let _ = io::stdout().flush(); 545 545 - } 546 546 - 547 547 - // ── CLI ───────────────────────────────────────────────────────────────────── 10 10 + use animation::Animation; 11 11 + use clood::{Clood, EyeState}; 12 12 + use color::Color; 548 13 549 14 /// Generate a cute unicode block character (clood) in your terminal. 550 15 /// ··· 622 87 fps: u32, 623 88 } 624 89 625 625 - // ── Main ──────────────────────────────────────────────────────────────────── 626 626 - 627 90 fn main() { 628 91 let args = Args::parse(); 629 92 let mut rng = rand::thread_rng(); ··· 647 110 right_arm_offset: args.rightarm, 648 111 num_legs: args.numlegs.unwrap_or_else(|| rng.gen_range(0..=4) * 2), 649 112 leg_size: args.legsize.unwrap_or_else(|| rng.gen_range(2..=4)), 650 650 - body_color: args.color.as_deref() 113 113 + body_color: args 114 114 + .color 115 115 + .as_deref() 651 116 .and_then(Color::from_hex) 652 117 .unwrap_or_else(|| { 653 118 if args.color.is_some() { ··· 655 120 } 656 121 Color::random(&mut rng) 657 122 }), 658 658 - eye_color: args.eyecolor.as_deref() 123 123 + eye_color: args 124 124 + .eyecolor 125 125 + .as_deref() 659 126 .and_then(Color::from_hex) 660 127 .unwrap_or_else(|| { 661 128 if args.eyecolor.is_some() { ··· 666 133 }; 667 134 668 135 // Parse animation specs. 669 669 - let animations: Vec<Animation> = args.anims.iter() 670 670 - .filter_map(|s| { 671 671 - match Animation::parse(s) { 672 672 - Ok(anim) => Some(anim), 673 673 - Err(msg) => { 674 674 - eprintln!("Warning: {}", msg); 675 675 - None 676 676 - } 136 136 + let animations: Vec<Animation> = args 137 137 + .anims 138 138 + .iter() 139 139 + .filter_map(|s| match Animation::parse(s) { 140 140 + Ok(anim) => Some(anim), 141 141 + Err(msg) => { 142 142 + eprintln!("Warning: {}", msg); 143 143 + None 677 144 } 678 145 }) 679 146 .collect(); 680 147 681 148 if animations.is_empty() { 682 682 - print!("{}", render(&base)); 683 683 - return; 684 684 - } 685 685 - 686 686 - run_animation_loop(&base, &animations, args.fps); 687 687 - } 688 688 - 689 689 - /// Run an infinite animation loop, rendering at the given FPS. 690 690 - fn run_animation_loop(base: &Clood, animations: &[Animation], fps: u32) -> ! { 691 691 - let frame_delay = Duration::from_millis(1000 / fps.max(1) as u64); 692 692 - let mut tick: usize = 0; 693 693 - let mut prev_height: usize = 0; 694 694 - 695 695 - hide_cursor(); 696 696 - 697 697 - // Restore cursor visibility on Ctrl-C. 698 698 - ctrlc::set_handler(move || { 699 699 - show_cursor(); 700 700 - std::process::exit(0); 701 701 - }).expect("Failed to set Ctrl-C handler"); 702 702 - 703 703 - loop { 704 704 - let mut state = AnimState::from_clood(base); 705 705 - for anim in animations { 706 706 - state.apply(anim.param, anim.value_at(tick)); 707 707 - } 708 708 - let frame_clood = state.to_clood(base); 709 709 - 710 710 - let frame = render(&frame_clood); 711 711 - let height = frame_clood.sanitized().rendered_height(); 712 712 - 713 713 - write_frame(&frame, height, prev_height); 714 714 - 715 715 - prev_height = height; 716 716 - tick = tick.wrapping_add(1); 717 717 - 718 718 - thread::sleep(frame_delay); 149 149 + print!("{}", clood::render(&base)); 150 150 + } else { 151 151 + animation::run_loop(&base, &animations, args.fps); 719 152 } 720 153 }