Modularize

1 files changed, 7 insertions, 283 deletions

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,