Initial Commit

1 files changed, 304 insertions, 0 deletions

diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..a839b2f
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,304 @@
+use rand::Rng;
+
+fn rand_u8() -> u8 {
+    let mut rng = rand::thread_rng();
+    rng.gen()
+}
+
+#[allow(dead_code)]
+#[derive(Copy,Clone)]
+struct Card {
+    n: u8,
+    e: u8,
+    s: u8,
+    w: u8,
+    owner: PlayerId,
+    special: Option<&'static dyn Fn()>,
+}
+
+#[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(),
+            special: None,
+        }
+    }
+}
+
+impl core::fmt::Debug for Card {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "Card {{\n\tn: {:?},\n\te: {:?},\n\ts: {:?},\n\tw: {:?}\n\towner: {:?}\n}}", self.n, self.e, self.s, self.w, self.owner)
+    }
+}
+
+impl Card {
+    fn new(owner: PlayerId) -> Self {
+        Self {
+            n: 0,
+            e: 0,
+            s: 0,
+            w: 0,
+            owner: owner,
+            special: 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(())
+    }
+}
+
+#[allow(dead_code)]
+struct Entity {
+    attack: i64,
+    defense: i64,
+    special: Option<&'static dyn Fn()>
+}
+
+fn special_000() {
+    println!("Hello, world!");
+}
+
+#[allow(unused_variables)]
+fn main() {
+    let entity = Entity {
+        attack: 0,
+        defense: 0,
+        special: Some(&special_000),
+    };
+    if let Some(function) = entity.special {
+        function();
+    }
+    let mut card = Card::new(PlayerId::PLAYER_1);
+    println!("{:?}", card);
+    card.n ^= 5;
+    println!("{:?}", card);
+    card.n ^= 3;
+    println!("{:?}", card);
+    card.n = 254;
+    println!("{:?}", card);
+    card.randomize();
+    println!("{:?}", card);
+    let mut grid = Grid::<3>::default();
+    println!("{:?}", grid);
+    grid.field[0][1] = Some(card);
+    println!("{:?}", grid);
+    grid.randomize();
+    println!("{:?}", grid);
+}