Modularize

1 files changed, 179 insertions, 0 deletions

diff --git a/src/grid.rs b/src/grid.rs
new file mode 100644
index 0000000..db7b985
--- /dev/null
+++ b/src/grid.rs
@@ -0,0 +1,179 @@
+use crate::card::card::*;
+use crate::card::player::*;
+
+#[allow(dead_code)]
+pub struct Grid<const SIZE: usize> {
+    pub field: [[Option<Card>; SIZE]; SIZE],
+}
+
+const NO_CARD: Option<Card> = None;
+impl<const SIZE: usize> Default for Grid<SIZE> {
+    fn default() -> Self {
+        Self {
+            field: [[NO_CARD; SIZE]; SIZE],
+        }
+    }
+}
+
+impl<const SIZE: usize> Grid<SIZE> {
+    pub fn randomize(&mut self) {
+        for y in 0..SIZE {
+            for x in 0..SIZE {
+                let mut card = Card::default();
+                card.randomize();
+                self.field[y][x] = Some(card);
+            }
+        }
+    }
+}
+
+fn get_owner(some_card: Option<Card>) -> &'static str {
+    match some_card {
+        Some(card) => {
+            match card.owner {
+                PlayerId::NONE => "( )",
+                PlayerId::PLAYER_1 => "(1)",
+                PlayerId::PLAYER_2 => "(2)",
+            }
+        }
+        None => {
+            "( )"
+        }
+    }
+}
+
+fn get_values(some_card: Option<Card>) -> [u8; 4] {
+    match some_card {
+        Some(card) => {
+            [card.n, card.e, card.s, card.w]
+        },
+        None => {
+            [0; 4]
+        }
+    }
+}
+
+fn get_value_u8(dir: usize, some_card: Option<Card>) -> u8 {
+    let values = get_values(some_card);
+    match dir {
+        // P1N
+        0 => {
+            match some_card {
+                Some(card) => {
+                    match card.owner {
+                        PlayerId::PLAYER_2 => values[2],
+                        _ => values[0],
+                    }
+                }
+                None => {0},
+            }
+        },
+        // P1E
+        1 => {
+            match some_card {
+                Some(card) => {
+                    match card.owner {
+                        PlayerId::PLAYER_2 => values[3],
+                        _ => values[1],
+                    }
+                }
+                None => {0},
+            }
+        },
+        // P1S
+        2 => {
+            match some_card {
+                Some(card) => {
+                    match card.owner {
+                        PlayerId::PLAYER_2 => values[0],
+                        _ => values[2],
+                    }
+                }
+                None => {0},
+            }
+        },
+        // P1W
+        3 => {
+            match some_card {
+                Some(card) => {
+                    match card.owner {
+                        PlayerId::PLAYER_2 => values[1],
+                        _ => values[3],
+                    }
+                }
+                None => {0},
+            }
+        },
+        _ => {0},
+    }
+}
+
+fn get_value(dir: usize, some_card: Option<Card>) -> String {
+    let value = get_value_u8(dir, some_card);
+    if value == 0 {
+        return "   ".to_string();
+    }
+    return format!("{:<3?}", value);
+}
+
+impl<const SIZE: usize> core::fmt::Debug for Grid<SIZE> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        if let Err(error) = write!(f, ".") {
+            return Err(error);
+        }
+        for _x in 0..SIZE {
+            if let Err(error) = write!(f, "============") {
+                return Err(error);
+            }
+        }
+        if let Err(error) = write!(f, ".\n") {
+            return Err(error);
+        }
+        for y in (0..SIZE).rev() {
+            for s in 0..3 {
+                if let Err(error) = write!(f, "|") {
+                    return Err(error);
+                }
+                for x in 0..SIZE {
+                    match s {
+                        0 => {
+                            if let Err(error) = write!(f, "    {}     ", get_value(0, self.field[y][x])) {
+                                return Err(error);
+                            }
+                        },
+                        1 => {
+                            if let Err(error) = write!(f, "{} {} {} ", get_value(3, self.field[y][x]), get_owner(self.field[y][x]), get_value(1, self.field[y][x])) {
+                                return Err(error);
+                            }
+                        },
+                        2 => {
+                            if let Err(error) = write!(f, "    {}     ", get_value(2, self.field[y][x])) {
+                                return Err(error);
+                            }
+                        },
+                        _ => {},
+                    };
+                    //buf = match self.field[y][x] {
+                    //    None => {write!(f, "{:?} ", PlayerId::NONE)},
+                    //    Some(card) => {write!(f, "{:?} ", card.owner)},
+                    //};
+                }
+                if let Err(error) = write!(f, "|\n") {
+                    return Err(error);
+                }
+            }
+        }
+        if let Err(error) = write!(f, "'") {
+            return Err(error);
+        }
+        for _x in 0..SIZE {
+            if let Err(error) = write!(f, "============") {
+                return Err(error);
+            }
+        }
+        if let Err(error) = write!(f, "'\n") {
+            return Err(error);
+        }
+        return Ok(())
+    }
+}