Map generation

Cargo.toml

@@ -5,5 +5,7 @@ members = [
     "gas-burner-contracts/gas-burner",
     "gas-burner-contracts/gas-burner/meta",
     "gas-burner-contracts/owner-sc",
-    "gas-burner-contracts/owner-sc/meta"
+    "gas-burner-contracts/owner-sc/meta",
+    "map-generation",
+    "map-generation/meta",
 ]

map-generation/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "map-generation"
+version = "0.0.0"
+authors = ["you"]
+edition = "2021"
+publish = false
+
+[lib]
+path = "src/lib.rs"
+
+[dependencies.multiversx-sc]
+version = "=0.52.3"
+
+[dev-dependencies]
+num-bigint = "0.4"
+
+[dev-dependencies.multiversx-sc-scenario]
+version = "=0.52.3"

map-generation/meta/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "map-generation-meta"
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+[dependencies.map-generation]
+path = ".."
+
+[dependencies.multiversx-sc-meta-lib]
+version = "=0.52.3"
+default-features = false

map-generation/meta/src/main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    multiversx_sc_meta_lib::cli_main::<map_generation::AbiProvider>();
+}

map-generation/multiversx.json

@@ -0,0 +1,3 @@
+{
+    "language": "rust"
+}

map-generation/src/lib.rs

@@ -0,0 +1,15 @@
+#![no_std]
+
+multiversx_sc::imports!();
+
+pub mod map;
+pub mod random;
+
+#[multiversx_sc::contract]
+pub trait MapGeneration: map::MapModule {
+    #[init]
+    fn init(&self) {}
+
+    #[upgrade]
+    fn upgrade(&self) {}
+}

map-generation/src/map.rs

@@ -0,0 +1,159 @@
+use crate::random::{Random, Seed, U64_BYTES};
+
+multiversx_sc::imports!();
+
+const WIGGLE: i16 = 32;
+const TILES: u32 = 512;
+const SIZE: u32 = TILES * 2 + 1;
+const SQUARED_SIZE: usize = (SIZE * SIZE) as usize;
+
+pub struct Map {
+    rng: Random,
+    terrain: [u32; SQUARED_SIZE],
+}
+
+impl Map {
+    #[inline]
+    pub fn new(seed: Seed) -> Self {
+        Self {
+            rng: Random::new(seed),
+            terrain: [0; SQUARED_SIZE],
+        }
+    }
+
+    pub fn new_from_seed(seed: Seed) -> Self {
+        Self {
+            rng: Random::new(seed),
+            terrain: [0; SQUARED_SIZE], // TODO: Generate the terrain
+        }
+    }
+
+    pub fn get(&self, x: u32, y: u32) -> u32 {
+        self.terrain[(x * SIZE + y) as usize]
+    }
+
+    pub fn set(&mut self, x: u32, y: u32, value: u32) {
+        self.terrain[(x * SIZE + y) as usize] = value;
+    }
+
+    pub fn init<Api: ManagedTypeApi>(&mut self) {
+        let top_left = self.rng.next_u8::<Api>() as u32;
+        let bottom_left = self.rng.next_u8::<Api>() as u32;
+        let top_right = self.rng.next_u8::<Api>() as u32;
+        let bottom_right = self.rng.next_u8::<Api>() as u32;
+
+        self.set(0, 0, top_left);
+        self.set(SIZE - 1, 0, bottom_left);
+        self.set(0, SIZE - 1, top_right);
+        self.set(SIZE - 1, SIZE - 1, bottom_right);
+    }
+
+    pub fn square<Api: ManagedTypeApi>(&mut self, x: u32, y: u32, radius: u32) {
+        let top_left = self.get(x - radius, y - radius);
+        let bottom_left = self.get(x - radius, y + radius);
+        let top_right = self.get(x + radius, y - radius);
+        let bottom_right = self.get(x + radius, y + radius);
+        let average = (top_left + bottom_left + top_right + bottom_right) / 4;
+        let height = self.wiggle::<Api>(average, WIGGLE);
+
+        self.set(x, y, height);
+    }
+
+    pub fn diamond<Api: ManagedTypeApi>(&mut self, x: u32, y: u32, radius: u32) {
+        let mut spread = 0;
+        let mut t = 0;
+
+        if radius <= x {
+            spread += 1;
+            t += self.get(x - radius, y);
+        }
+
+        if x + radius < SIZE {
+            spread += 1;
+            t += self.get(x + radius, y);
+        }
+
+        if radius <= y {
+            spread += 1;
+            t += self.get(x, y - radius);
+        }
+
+        if y + radius < SIZE {
+            spread += 1;
+            t += self.get(x, y + radius);
+        }
+
+        let height = self.wiggle::<Api>(t / spread, WIGGLE);
+        self.set(x, y, height);
+    }
+
+    pub fn squares<Api: ManagedTypeApi>(&mut self, step: u32) {
+        let step2 = step * 2;
+        for x in 0..step {
+            for y in 0..step {
+                let square_x = SIZE / step2 + (x * SIZE / step);
+                let square_y = SIZE / step2 + (y * SIZE / step);
+                let radius = SIZE / step2;
+
+                self.square::<Api>(square_x, square_y, radius);
+            }
+        }
+    }
+
+    pub fn diamonds<Api: ManagedTypeApi>(&mut self, radius: u32) {
+        let radius_usize = radius as usize;
+        for x in (0..SIZE).step_by(radius_usize) {
+            let y_start: u32 = if (x / (radius)) % 2 == 0 { radius } else { 0 };
+
+            for y in (y_start..SIZE).step_by(radius_usize * 2) {
+                self.diamond::<Api>(x, y, radius);
+            }
+        }
+    }
+
+    pub fn wiggle<Api: ManagedTypeApi>(&mut self, value: u32, range: i16) -> u32 {
+        let min = if value < range as u32 {
+            value as i16
+        } else {
+            range
+        };
+
+        (value as i16 + self.rng.gen_range::<Api>(-min, range)) as u32
+    }
+}
+
+#[multiversx_sc::module]
+pub trait MapModule {
+    #[only_owner]
+    #[endpoint(generateNewMap)]
+    fn generate_new_map(&self) -> [u32; SQUARED_SIZE] {
+        let buffer = ManagedBuffer::new_random(U64_BYTES);
+        let seed_result = u64::top_decode(buffer);
+        require!(seed_result.is_ok(), "Failed decoding random seed");
+
+        let seed = unsafe { seed_result.unwrap_unchecked() };
+        let mut map = Map::new(seed);
+        let initial_seed = map.rng.seed;
+        map.init::<Self::Api>();
+
+        let steps = TILES.trailing_zeros() + 1;
+        for s in 0..steps {
+            map.squares::<Self::Api>(1 << s);
+            map.diamonds::<Self::Api>(1 << (steps - s - 1));
+        }
+
+        // for _x in 0..SIZE {
+        //     for _y in 0..SIZE {
+        //         // TODO: Do... something... ?
+        //     }
+        // }
+
+        self.current_map_seed().set(initial_seed);
+
+        map.terrain
+    }
+
+    #[view(getCurrentMapSeed)]
+    #[storage_mapper("currentMapSeed")]
+    fn current_map_seed(&self) -> SingleValueMapper<Seed>;
+}

map-generation/src/random.rs

@@ -0,0 +1,98 @@
+multiversx_sc::imports!();
+multiversx_sc::derive_imports!();
+
+const U8_BYTES: usize = 1;
+const I16_BYTES: usize = 2;
+pub const U64_BYTES: usize = 8;
+pub const HASH_LEN: usize = 32;
+static FAILED_DECODE_ERR_MSG: &[u8] = b"Failed decoding u64";
+
+pub type Seed = u64;
+
+#[derive(TypeAbi, TopEncode, TopDecode, NestedEncode, NestedDecode)]
+pub struct Random {
+    pub seed: Seed,
+    pub index: usize,
+}
+
+impl Random {
+    #[inline]
+    pub fn new(rand_seed: Seed) -> Self {
+        Self {
+            seed: rand_seed,
+            index: 0,
+        }
+    }
+
+    #[inline]
+    pub fn next_u8<Api: ManagedTypeApi>(&mut self) -> u8 {
+        let value = self.next_value::<Api>(U8_BYTES);
+
+        value as u8
+    }
+
+    #[inline]
+    pub fn next_i16<Api: ManagedTypeApi>(&mut self) -> i16 {
+        let value = self.next_value::<Api>(I16_BYTES);
+
+        value as i16
+    }
+
+    pub fn gen_range<Api: ManagedTypeApi>(&mut self, min: i16, max: i16) -> i16 {
+        let rand = self.next_i16::<Api>();
+
+        if min >= max {
+            min
+        } else {
+            min + rand % (max - min)
+        }
+    }
+
+    fn next_value<Api: ManagedTypeApi>(&mut self, size: usize) -> u64 {
+        if self.index + size > U64_BYTES {
+            self.xor_shift_seed();
+        }
+
+        let seed_bytes = self.seed.to_be_bytes();
+        let val_range = &seed_bytes[self.index..self.index + size];
+        let decode_result = u64::top_decode(val_range);
+        if decode_result.is_err() {
+            Api::error_api_impl().signal_error(FAILED_DECODE_ERR_MSG);
+        }
+
+        let rand = unsafe { decode_result.unwrap_unchecked() };
+        self.index += size;
+
+        rand
+    }
+
+    // Stolen from: https://en.wikipedia.org/wiki/Xorshift
+    fn xor_shift_seed(&mut self) {
+        let mut new_seed = self.seed;
+        new_seed ^= new_seed << 13;
+        new_seed ^= new_seed >> 7;
+        new_seed ^= new_seed << 17;
+        self.seed = new_seed;
+        self.index = 0;
+    }
+}
+
+#[cfg(test)]
+mod randomness_tests {
+    use multiversx_sc_scenario::DebugApi;
+
+    use super::*;
+
+    #[test]
+    fn gen_range_test() {
+        let mut random = Random::new(0);
+        let rand_nr = random.gen_range::<DebugApi>(-20, -10);
+        assert_eq!(rand_nr, -20);
+
+        let rand_nr = random.gen_range::<DebugApi>(10, 20);
+        assert_eq!(rand_nr, 10);
+
+        let rand_nr = random.gen_range::<DebugApi>(-20, 20);
+        assert_eq!(rand_nr, -20);
+    }
+}