ZJPL7VNQEYASQ7QIUCR3X2IPWF5MAR6WX7VY6OWMRDMPJK7GYWIAC
HJBUNOG2L2OPT7ZOUMVUCBLLT5Y5JHGTWUA4PA6CE65OKKAUBFHQC
NRQSXJVRWJ66JIHK73QZJMMVDLV3WFLG3HLBCRPAJYYEX252DL2QC
5TH3AA466T4JIICGT3LTLJ554X62KF36XZUXKR5MIAXVWAGQQHWQC
2USDM5CH2K26B4DB5YEMVIT43NLY5PNQJZHW2HK2COXQZ75QTLOAC
MLUGR2LLRTENFPCXBML4VQKWNE5QURMC7RJDE3AQYZXAJWOWILDQC
3H2BGWRGDDJFRLLFN2QIMSSWXB2BYXLKLL2E25E3CGIYQ55VY2PAC
RXRHPE7STPP6GVMSGJKVYGLAGYGZTKGSQAKXEL6O2QZTS7XQBM6QC
F3GMCMWTQ533LIP63WD7Z6JGUIHINCZOBMRT6EBIDWXGQY7Y7IYQC
UPCMFGXF4BQ4XWKG7LA6A57WOXQCSA2OSAGL4J37TUKY7NRSQMNAC
ES2PMPT47CHTONTR7GAYXTU5LURMPC5W5BQ3YGOXMXT57NZHVHJQC
RQRFFUF6EN2RMBL5ITLF4HYJPGNMYXNTV4YNWH2BUCVZQE5KY2AQC
JBGHRTSWRWT7TMTPUL5RZQUPNWAETGN5NA7ZV4WPMGGLJ2EYAPDAC
// Use the same global constants
use crate::PLANKMAX;
use crate::SAWBLADE;
// Define a plank piece structure
#[derive(Debug)]
pub struct Plank {
length: u32,
endpiece: bool,
new: bool,
}
impl Default for Plank {
/// Create a new, default plank
fn default() -> Self {
Self {
length: PLANKMAX,
endpiece: false,
new: true,
}
}
}
impl Plank {
/// Create a new plank
pub fn new(&self) -> Self {
Plank::default()
}
/// Is this a new plank?
pub fn is_new(&self) -> bool {
self.new
}
/// Is this at the end of a row
pub fn get_endpiece(&self) -> bool {
self.endpiece
}
/// Make this plank an endpiece
pub fn set_endpiece(&mut self) -> () {
self.endpiece = true;
}
/// Return the length of the plank
pub fn length(&self) -> u32 {
self.length
}
/// Return the original plank with the new length along with leftover
pub fn cut_to_length(mut self, measure: u32) -> (Plank, Plank) {
if measure > PLANKMAX {
panic!("Can't cut a plank longer than it is!");
}
// Create the leftover plank, correct for material loss due to sawing
let leftover_plank = Plank {
length: self.length - (measure + SAWBLADE),
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)
}
}
// Define a row structure
#[derive(Debug)]
pub struct Row {
planks: Vec<Plank>,
coverage: u32,
full: bool,
}
impl Default for Row {
/// Create a new, empty row
fn default() -> Self {
Self {
planks: vec![],
coverage: 0,
full: false,
}
}
}
impl Row {
/// Is this row considered full?
pub fn get_full(&self) -> bool {
self.full
}
/// Mark this row as full
pub fn set_full(&mut self) -> () {
self.full = true;
}
/// Get the number of plank rows for this floor
pub fn rows_count(&self) -> usize {
self.planks.len()
}
/// Get the number of plank rows for this floor
pub fn planks(&mut self) -> &mut Vec<Plank> {
&mut self.planks
}
/// Increase how much of the row is filled
pub fn add_coverage(&mut self, coverage: u32) -> () {
self.coverage += coverage;
}
/// Get the number of plank rows for this floor
pub fn get_coverage(&self) -> u32 {
self.coverage
}
/// Add a plank to this row
pub fn add(&mut self, plank: Plank) -> () {
self.planks.push(plank);
}
}
// Define a floor structure
#[derive(Debug)]
pub struct Floor {
rows: Vec<Row>,
coverage: u32,
complete: bool,
}
impl Default for Floor {
/// Create a new, empty row
fn default() -> Self {
Self {
rows: vec![],
coverage: 0,
complete: false,
}
}
}
impl Floor {
/// Is this floor considered complete?
pub fn is_complete(&self) -> bool {
self.complete
}
/// Get the number of plank rows for this floor
pub fn rows_count(&self) -> usize {
self.rows.len()
}
pub fn add(&mut self, row: Row) -> () {
self.rows.push(row);
}
}
// Define a plank piece structure
#[derive(Debug)]
struct Plank {
length: u32,
endpiece: bool,
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 a new plank?
fn is_new(&self) -> bool {
self.new
}
/// Is this at the end of a row
fn is_endpiece(&self) -> bool {
self.endpiece
}
/// Return the length of the plank
fn length(&self) -> u32 {
self.length
}
/// Return the original plank with the new length along with leftover
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)
}
}
// Define a row structure
#[derive(Debug)]
struct Row {
planks: Vec<Plank>,
coverage: u32,
full: bool,
}
impl Default for Row {
/// Create a new, empty row
fn default() -> Self {
Self {
planks: vec![],
coverage: 0,
full: false,
}
}
}
impl Row {
/// Is this row considered complete?
fn is_full(&self) -> bool {
self.full
}
/// Get the number of plank rows for this floor
fn rows_count(&self) -> usize {
self.planks.len()
}
fn add(&mut self, plank: Plank) -> () {
self.planks.push(plank);
}
}
// Define a floor structure
#[derive(Debug)]
struct Floor {
rows: Vec<Row>,
coverage: u32,
complete: bool,
}
impl Default for Floor {
/// Create a new, empty row
fn default() -> Self {
Self {
rows: vec![],
coverage: 0,
complete: false,
}
}
}
impl Floor {
/// Is this floor considered complete?
fn is_complete(&self) -> bool {
self.complete
}
/// Get the number of plank rows for this floor
fn rows_count(&self) -> usize {
self.rows.len()
}
fn add(&mut self, row: Row) -> () {
self.rows.push(row);
}
}
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);
while row.get_coverage() <= ROOMLENGTH {
// TODO should also check if the plank is too short, then WARN or take a new
if plank.length() < 200 {
// Take a new plank and continue
let newplank: Plank = Default::default();
plank = newplank;
}
if plank.length() > ROOMLENGTH - row.get_coverage() {
// Cut the plank to length
let (plankpart, leftover) = plank.cut_to_length(ROOMLENGTH - row.get_coverage());
} else if plank.length() == ROOMLENGTH - row.get_coverage() {
// If the plank is the same length as the room, no need to cut
// Use the whole plank, add to row coverage
row.add_coverage(plank.length());
row.add(plank);
// Take a new plank and continue
let newplank: Plank = Default::default();
plank = newplank;
} else {
// Plank is shorter than the room, need multiple
// Use the whole plank, add to row coverage
row.add_coverage(plank.length());
row.add(plank);
// Take a new plank and continue
let newplank: Plank = Default::default();
plank = newplank;