static ROOMLENGTH: u32 = 3800;

//static ROOMLENGTH: u32 = 3800;
static ROOMLENGTH: u32 = 1000;

    new: bool,

impl Default for Plank {
    /// Create a new, default plank
    fn default() -> Self {
        Self {
            length: PLANKMAX,
            endpiece: false,
            new: true,
        }
    }
}
impl Plank {
    /// Is this row considered complete?
    fn is_new(&self) -> bool {
        self.new
    }
    /// Get the number of plank rows for this floor
    fn is_endpiece(&self) -> bool {
        self.endpiece
    }
    fn cut_to_length(mut self, measure: u32) -> (Plank, Plank) {
        let leftover_plank = Plank {
            length: self.length - measure,
            endpiece: false,
            new: false,
        };
        // Trim self to the new length
        self.length = measure;
        // In case the plank was new, mark it as cut
        if self.new {
            self.new = false;
        }
        // Return the original plank and the leftover
        (self, leftover_plank)
    }
}

    coverage: u32,

impl Default for Row {
    /// Create a new, empty row
    fn default() -> Self {
        Self {
            planks: vec![],
            coverage: 0,
            full: false,
        }
    }
}

    coverage: u32,

        coverage: 0,

        coverage: 0,

    floor.add(build_row());

    while floor.coverage <= ROOMDEPTH {
        floor.add(build_row());
    }

    Row {
        planks: vec![],
        full: false,

    // New empty row
    let mut row: Row = Default::default();
    // Create an initial plank
    let mut plank: Plank = Default::default();
    //let mut leftover: Plank = Default::default();
    while row.coverage <= ROOMLENGTH {
        if plank.length > ROOMLENGTH {
            // Planks are longer than the room, need to cut them
            //let leftover;
            let (plankpart, leftover) = plank.cut_to_length(ROOMLENGTH);
            // Add the remainder of plank to the row (move)
            row.add(plankpart);
            // Set the leftover as the new plank
            plank = leftover;
        }

    row

fn calc_new_length(prev: u32, next: u32) -> u32 {
    prev - next
}