From 5f3e5f473c6d7a45297c4d301eb2a2d61078586b Mon Sep 17 00:00:00 2001
From: Christian Cunningham <cc@localhost>
Date: Wed, 7 Feb 2024 19:15:07 -0800
Subject: Modularize

---
 src/card/card.rs   |  62 ++++++++++++
 src/card/effect.rs |  14 +++
 src/card/mod.rs    |   6 ++
 src/card/player.rs |  30 ++++++
 src/grid.rs        | 179 +++++++++++++++++++++++++++++++++
 src/main.rs        | 290 ++---------------------------------------------------
 6 files changed, 298 insertions(+), 283 deletions(-)
 create mode 100644 src/card/card.rs
 create mode 100644 src/card/effect.rs
 create mode 100644 src/card/mod.rs
 create mode 100644 src/card/player.rs
 create mode 100644 src/grid.rs

diff --git a/src/card/card.rs b/src/card/card.rs
new file mode 100644
index 0000000..72b992a
--- /dev/null
+++ b/src/card/card.rs
@@ -0,0 +1,62 @@
+use crate::card::effect::*;
+use crate::card::player::*;
+use crate::rand_u8;
+
+#[allow(dead_code)]
+#[derive(Copy,Clone)]
+pub struct Card {
+    pub n: u8,
+    pub e: u8,
+    pub s: u8,
+    pub w: u8,
+    pub owner: PlayerId,
+    pub effect: Option<CardEffect>,
+}
+
+#[allow(dead_code)]
+impl Default for Card {
+    fn default() -> Self {
+        Card {
+            n: 0,
+            e: 0,
+            s: 0,
+            w: 0,
+            owner: PlayerId::default(),
+            effect: None,
+        }
+    }
+}
+
+impl core::fmt::Debug for Card {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        if let Err(error) = write!(f, "Card {{\n\towner: {:?}\n\tn: {:?},\n\te: {:?},\n\ts: {:?},\n\tw: {:?}", self.owner, self.n, self.e, self.s, self.w) {
+            return Err(error);
+        }
+        if let Some(effect) = self.effect {
+            if let Err(error) = write!(f, "\n\teffect: {:?}", effect) {
+                return Err(error);
+            }
+        }
+        write!(f, "\n}}")
+    }
+}
+
+impl Card {
+    pub fn new(owner: PlayerId) -> Self {
+        Self {
+            n: 0,
+            e: 0,
+            s: 0,
+            w: 0,
+            owner: owner,
+            effect: None,
+        }
+    }
+
+    pub fn randomize(&mut self) {
+        self.n = rand_u8();
+        self.e = rand_u8();
+        self.s = rand_u8();
+        self.w = rand_u8();
+    }
+}
diff --git a/src/card/effect.rs b/src/card/effect.rs
new file mode 100644
index 0000000..a5f909e
--- /dev/null
+++ b/src/card/effect.rs
@@ -0,0 +1,14 @@
+#[allow(dead_code)]
+#[derive(Copy,Clone)]
+pub struct CardEffect {
+    pub name: &'static str,
+    pub when: usize, // TODO: Change this
+    pub fun: &'static dyn Fn(),
+}
+
+impl core::fmt::Debug for CardEffect {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{}", self.name)
+    }
+}
+
diff --git a/src/card/mod.rs b/src/card/mod.rs
new file mode 100644
index 0000000..64eb9b5
--- /dev/null
+++ b/src/card/mod.rs
@@ -0,0 +1,6 @@
+pub mod card;
+pub mod effect;
+pub mod player;
+//pub use card::*;
+//pub use effect::*;
+//pub use player::*;
diff --git a/src/card/player.rs b/src/card/player.rs
new file mode 100644
index 0000000..1439258
--- /dev/null
+++ b/src/card/player.rs
@@ -0,0 +1,30 @@
+#[allow(non_camel_case_types)]
+#[allow(dead_code)]
+#[derive(Copy,Clone)]
+pub enum PlayerId {
+    NONE,
+    PLAYER_1,
+    PLAYER_2,
+}
+
+impl Default for PlayerId {
+    fn default() -> Self {
+        PlayerId::NONE
+    }
+}
+
+impl core::fmt::Debug for PlayerId {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match *self {
+            PlayerId::NONE => {
+                write!(f, "PlayerId::NONE    ")
+            },
+            PlayerId::PLAYER_1 => {
+                write!(f, "PlayerId::PLAYER_1")
+            },
+            PlayerId::PLAYER_2 => {
+                write!(f, "PlayerId::PLAYER_2")
+            },
+        }
+    }
+}
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(())
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 14e53b9..2b8efc3 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,3 +1,8 @@
+mod card;
+mod grid;
+use crate::card::*;
+use crate::card::card::Card;
+use crate::grid::*;
 use rand::Rng;
 
 fn rand_u8() -> u8 {
@@ -5,301 +10,20 @@ fn rand_u8() -> u8 {
     rng.gen()
 }
 
-#[allow(dead_code)]
-#[derive(Copy,Clone)]
-struct CardEffect {
-    name: &'static str,
-    when: usize, // TODO: Change this
-    fun: &'static dyn Fn(),
-}
-
-impl core::fmt::Debug for CardEffect {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.name)
-    }
-}
-
-#[allow(dead_code)]
-#[derive(Copy,Clone)]
-struct Card {
-    n: u8,
-    e: u8,
-    s: u8,
-    w: u8,
-    owner: PlayerId,
-    effect: Option<CardEffect>,
-}
-
-#[allow(non_camel_case_types)]
-#[allow(dead_code)]
-#[derive(Copy,Clone)]
-enum PlayerId {
-    NONE,
-    PLAYER_1,
-    PLAYER_2,
-}
-
-impl Default for PlayerId {
-    fn default() -> Self {
-        PlayerId::NONE
-    }
-}
-
-impl core::fmt::Debug for PlayerId {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        match *self {
-            PlayerId::NONE => {
-                write!(f, "PlayerId::NONE    ")
-            },
-            PlayerId::PLAYER_1 => {
-                write!(f, "PlayerId::PLAYER_1")
-            },
-            PlayerId::PLAYER_2 => {
-                write!(f, "PlayerId::PLAYER_2")
-            },
-        }
-    }
-}
-
-#[allow(dead_code)]
-impl Default for Card {
-    fn default() -> Self {
-        Card {
-            n: 0,
-            e: 0,
-            s: 0,
-            w: 0,
-            owner: PlayerId::default(),
-            effect: None,
-        }
-    }
-}
-
-impl core::fmt::Debug for Card {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        if let Err(error) = write!(f, "Card {{\n\towner: {:?}\n\tn: {:?},\n\te: {:?},\n\ts: {:?},\n\tw: {:?}", self.owner, self.n, self.e, self.s, self.w) {
-            return Err(error);
-        }
-        if let Some(effect) = self.effect {
-            if let Err(error) = write!(f, "\n\teffect: {:?}", effect) {
-                return Err(error);
-            }
-        }
-        write!(f, "\n}}")
-    }
-}
-
-impl Card {
-    fn new(owner: PlayerId) -> Self {
-        Self {
-            n: 0,
-            e: 0,
-            s: 0,
-            w: 0,
-            owner: owner,
-            effect: None,
-        }
-    }
-
-    fn randomize(&mut self) {
-        self.n = rand_u8();
-        self.e = rand_u8();
-        self.s = rand_u8();
-        self.w = rand_u8();
-    }
-}
-
-#[allow(dead_code)]
-struct Grid<const SIZE: usize> {
-    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> {
-    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(())
-    }
-}
-
 fn special_000() {
     println!("Hello, world!");
 }
 
 #[allow(unused_variables)]
 fn main() {
-    let mut card = Card::new(PlayerId::PLAYER_1);
+    let mut card = Card::new(player::PlayerId::PLAYER_1);
     println!("{:?}", card);
     card.n ^= 5;
     println!("{:?}", card);
     card.n ^= 3;
     println!("{:?}", card);
     card.n = 254;
-    card.effect = Some(CardEffect {
+    card.effect = Some(effect::CardEffect {
         name: "Say Hello",
         when: 0,
         fun: &special_000,
-- 
cgit v1.2.1