More fixes after validation

config.yml

@@ -1,22 +1,22 @@
 Ops: 
-  # - !PatchPen
-  #   Pen: 0
+  - !ClonePen
+    From: 0
+    To: 255
+    Inclusive: True
+
+  - !PatchPen
+    Pen: 0
+    Power: 10.0
   #   Color: [127, 127, 127]
   #   Enabled: true
   #   LoopCount: 3
   #   Speed: 20.0
-  #   Power: 55.0
   #   Frequency: 10000
 
-  # - !ClonePen
-  #   From: 0
-  #   To: 5
-  #   Inclusive: True
-
-  # - !PatternPen
-  #   From: 0
-  #   To: 5
-  #   Field: !Speed 10
+  - !PatternPen
+    From: 0
+    To: 40
+    Field: !Power 2
 
   # - !ExportPen
   #   Index: 0
@@ -41,10 +41,10 @@ Ops:
 
   - !RectangleArray
     Layer: 0
-    Width: 5.0
-    Height: 4.0
+    Width: 3.0
+    Height: 2.0
     Columns: 8
     Rows: 5
     Spacing: 0.5
     Z: 0.0
-    StartingPen: 1
+    StartingPen: 0

src/config/pen.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use binrw::{BinRead, BinWriterExt};
-use ezcad::pen::Pen;
+use ezcad::{pen::Pen, types::Rgba};
 use log::debug;
 use serde::{Deserialize, Serialize};
 
@@ -32,23 +32,23 @@ impl Patch {
         let to_patch: &mut Pen = pens.get_mut(id).expect("Invalid pen index");
 
         if let Some(color) = self.color {
-            debug!("Patching color for pen #{}: {:?}", id, color);
+            debug!("Patching color for pen #{} to {:?}", id, color);
             *to_patch.color = color.into()
         }
 
         if let Some(enabled) = self.enabled {
-            debug!("Patching enablement for pen #{}: {}", id, enabled);
+            debug!("Patching enablement for pen #{} to {}", id, enabled);
             *to_patch.disabled = !enabled as u32;
         }
 
         if let Some(loop_count) = self.loop_count {
-            debug!("Patching loop count for pen #{}: {}", id, loop_count);
+            debug!("Patching loop count for pen #{} to {}", id, loop_count);
             assert!(loop_count > 0, "Pen loop count must be greater than zero");
             *to_patch.loop_count = loop_count;
         }
 
         if let Some(speed) = self.speed {
-            debug!("Patching speed for pen #{}: {}", id, speed);
+            debug!("Patching speed for pen #{} to {}", id, speed);
             assert!(
                 speed > SPEED_MIN && speed <= SPEED_MAX,
                 "Pen speed must be between {} and {}",
@@ -59,7 +59,7 @@ impl Patch {
         }
 
         if let Some(power) = self.power {
-            debug!("Patching power for pen #{}: {}", id, power);
+            debug!("Patching power for pen #{} to {}", id, power);
             assert!(
                 power > POWER_MIN && power <= POWER_MAX,
                 "Pen power must be between {} and {}",
@@ -70,7 +70,7 @@ impl Patch {
         }
 
         if let Some(frequency) = self.frequency {
-            debug!("Patching frequency for pen #{}: {}", id, frequency);
+            debug!("Patching frequency for pen #{} to {}", id, frequency);
             assert!(
                 frequency >= FREQUENCY_MIN && frequency <= FREQUENCY_MAX,
                 "Pen frequency must be between {} and {}",
@@ -132,10 +132,11 @@ impl ClonePen {
                     "Target pen(s) must be greater than source pen"
                 );
 
-                // Clone pen
+                // Clone pen (randomize color)
                 for idx in (self.from..=self.to).skip(1) {
                     let dst: &mut Pen = pens.get_mut(idx).expect("Invalid pen index");
                     *dst = src.clone();
+                    *dst.color = Rgba::random().into();
 
                     // Patch pen if needed
                     if let Some(patch) = &self.patch {
@@ -186,22 +187,22 @@ impl PatternPen {
         let mut setting: PatternField = match self.field {
             PatternField::Loops(_) => {
                 debug!(
-                    "Initial loop count from pen #{}: {}",
+                    "Initial loop count from pen #{} is {}",
                     self.from, *src.loop_count
                 );
                 PatternField::Loops((*src.loop_count).try_into().unwrap())
             }
             PatternField::Speed(_) => {
-                debug!("Initial speed from pen #{}: {}", self.from, *src.speed);
+                debug!("Initial speed from pen #{} is {}", self.from, *src.speed);
                 PatternField::Speed(*src.speed)
             }
             PatternField::Power(_) => {
-                debug!("Initial power from pen #{}: {}", self.from, *src.power);
+                debug!("Initial power from pen #{} is {}", self.from, *src.power);
                 PatternField::Power(*src.power)
             }
             PatternField::Frequency(_) => {
                 debug!(
-                    "Initial frequency from pen #{}: {}",
+                    "Initial frequency from pen #{} is {}",
                     self.from, *src.frequency
                 );
                 PatternField::Frequency((*src.frequency).try_into().unwrap())
@@ -215,13 +216,13 @@ impl PatternPen {
             setting = match (setting, &self.field) {
                 (PatternField::Loops(prev), PatternField::Loops(incr)) => {
                     let value: i32 = prev + incr;
-                    debug!("Patching loop count for pen #{}: {}", idx, value);
+                    debug!("Patching loop count for pen #{} to {}", idx, value);
                     assert!(value > 0, "Pen loop count must be greater than zero");
                     PatternField::Loops(value)
                 }
                 (PatternField::Speed(prev), PatternField::Speed(incr)) => {
                     let value: f64 = prev + incr;
-                    debug!("Patching speed for pen #{}: {}", idx, value);
+                    debug!("Patching speed for pen #{} to {}", idx, value);
                     assert!(
                         value > SPEED_MIN && value <= SPEED_MAX,
                         "Pen speed must be between {} and {}",
@@ -232,7 +233,7 @@ impl PatternPen {
                 }
                 (PatternField::Power(prev), PatternField::Power(incr)) => {
                     let value: f64 = prev + incr;
-                    debug!("Patching power for pen #{}: {}", idx, value);
+                    debug!("Patching power for pen #{} to {}", idx, value);
                     assert!(
                         value > POWER_MIN && value <= POWER_MAX,
                         "Pen power must be between {} and {}",
@@ -243,7 +244,7 @@ impl PatternPen {
                 }
                 (PatternField::Frequency(prev), PatternField::Frequency(incr)) => {
                     let value: i32 = prev + incr;
-                    debug!("Patching frequency for pen #{}: {}", idx, value);
+                    debug!("Patching frequency for pen #{} to {}", idx, value);
                     assert!(
                         value >= FREQUENCY_MIN.try_into().unwrap()
                             && value <= FREQUENCY_MAX.try_into().unwrap(),

src/ezcad/objects/rectangle.rs

@@ -5,7 +5,7 @@ use diff::Diff;
 
 use crate::{
     field_of::FieldOf,
-    types::{Field, Point, F64, ObjectType},
+    types::{Field, ObjectType, Point, F64},
 };
 
 use super::ObjectCore;
@@ -49,7 +49,6 @@ impl Default for Rectangle {
             core: ObjectCore {
                 obj_type: ObjectType::Rectangle.into(),
                 ..Default::default()
-                
             },
             corner_a: Point { x: 0.0, y: 0.0 }.into(),
             corner_b: Point { x: 0.0, y: 0.0 }.into(),

src/ezcad/types.rs

@@ -2,6 +2,7 @@ use std::fmt::{Debug, Display};
 
 use binrw::{binrw, BinRead, BinWrite};
 use diff::{Diff, VecDiff};
+use rand::{thread_rng, Rng};
 
 use crate::{array_of::ArrayOfPrimitive, field_of::FieldOf};
 
@@ -108,6 +109,17 @@ impl From<(u8, u8, u8)> for Rgba {
     }
 }
 
+impl Rgba {
+    pub fn random() -> Self {
+        Self {
+            red: thread_rng().gen_range(0..=255),
+            green: thread_rng().gen_range(0..=255),
+            blue: thread_rng().gen_range(0..=255),
+            alpha: 0,
+        }
+    }
+}
+
 #[derive(Clone, Debug, Default, Diff, PartialEq, BinRead, BinWrite)]
 #[diff(attr(
     #[derive(Debug, PartialEq)]