Update room/platform generation

- introduce seperate platform margin
- more space in spawn and for forced platform

src/bin/ddnet_bridge.rs

@@ -166,7 +166,7 @@ fn start_bridge(args: &BridgeArgs) {
                 auth = true;
                 generate_and_change_map(
                     args,
-                    &Seed::from_u64(42),
+                    &Seed::from_u64(1337),
                     &GenerationConfig::default(),
                     &mut econ,
                 );

src/generator.rs

@@ -7,7 +7,7 @@ use crate::{
     walker::CuteWalker,
 };
 
-use dt::{dt_bool};
+use dt::dt_bool;
 use ndarray::{Array2, Ix2};
 
 pub struct Generator {
@@ -120,10 +120,10 @@ impl Generator {
     pub fn post_processing(&mut self, config: &GenerationConfig) {
         self.fix_edge_bugs().expect("fix edge bugs failed");
         self.map
-            .generate_room(&self.map.spawn.clone(), 4, Some(&BlockType::Start))
+            .generate_room(&self.map.spawn.clone(), 4, 3, Some(&BlockType::Start))
             .expect("start room generation failed");
         self.map
-            .generate_room(&self.walker.pos.clone(), 4, Some(&BlockType::Finish))
+            .generate_room(&self.walker.pos.clone(), 4, 3, Some(&BlockType::Finish))
             .expect("start finish room generation");
 
         self.fill_area(&config.max_distance);

src/map.rs

@@ -136,50 +136,52 @@ impl Map {
     pub fn generate_room(
         &mut self,
         pos: &Position,
-        margin: usize,
+        room_size: usize,
+        platform_margin: usize,
         zone_type: Option<&BlockType>,
     ) -> Result<(), &'static str> {
-        // TODO: return an error?
-        if pos.x < (margin + 1)
-            || pos.y < (margin + 1)
-            || pos.x > self.width - (margin + 1)
-            || pos.y > self.height - (margin + 1)
+        if pos.x < (room_size + 1)
+            || pos.y < (room_size + 1)
+            || pos.x > self.width - (room_size + 1)
+            || pos.y > self.height - (room_size + 1)
         {
             return Err("generate room out of bounds");
         }
 
-        let margin: i32 = margin.to_i32().unwrap();
+        // TODO: i feel like this is utterly stupid
+        let room_size: i32 = room_size.to_i32().unwrap();
+        let platform_margin: i32 = platform_margin.to_i32().unwrap();
 
         // carve room
         self.set_area(
-            &pos.shifted_by(-margin, -margin)?,
-            &pos.shifted_by(margin, margin)?,
+            &pos.shifted_by(-room_size, -room_size)?,
+            &pos.shifted_by(room_size, room_size)?,
             &BlockType::Empty,
             true,
         );
 
         // set platform
         self.set_area(
-            &pos.shifted_by(-(margin - 2), 1)?,
-            &pos.shifted_by(margin - 2, 1)?,
+            &pos.shifted_by(-(room_size - platform_margin), room_size - 2)?,
+            &pos.shifted_by(room_size - platform_margin, room_size - 2)?,
             &BlockType::Platform,
             true,
         );
 
         // set spawns
         if zone_type == Some(&BlockType::Start) {
             self.set_area(
-                &pos.shifted_by(-(margin - 2), 0)?,
-                &pos.shifted_by(margin - 2, 0)?,
+                &pos.shifted_by(-(room_size - platform_margin), room_size - 3)?,
+                &pos.shifted_by(room_size - platform_margin, room_size - 3)?,
                 &BlockType::Spawn,
                 true,
             );
         }
         // set start/finish line
         if let Some(zone_type) = zone_type {
             self.set_area_border(
-                &pos.shifted_by(-margin - 1, -margin - 1)?,
-                &pos.shifted_by(margin + 1, margin + 1)?,
+                &pos.shifted_by(-room_size - 1, -room_size - 1)?,
+                &pos.shifted_by(room_size + 1, room_size + 1)?,
                 zone_type,
                 false,
             );

src/walker.rs

@@ -82,7 +82,7 @@ impl CuteWalker {
         // Case 2: max distance has been exceeded -> force platform using a room
         if self.steps_since_platform > max_distance {
             // TODO: for now this is hardcoded so that platform is shifted down by 7 blocks.
-            map.generate_room(&walker_pos.shifted_by(0, 6)?, 4, None)?;
+            map.generate_room(&walker_pos.shifted_by(0, 6)?, 5, 3, None)?;
             self.steps_since_platform = 0;
             return Ok(());
         }