So I have this binary spaced partition leaf:
#[derive(Clone)]
pub struct Leaf {
container: Rect,
left: Option<Box<Leaf>>,
right: Option<Box<Leaf>>,
room: Option<Rect>,
split_vertical: Option<bool>,
}
impl Leaf {
fn new(container: Rect) -> Leaf {
Leaf {
container,
left: None,
right: None,
room: None,
split_vertical: None,
}
}
fn split(
&mut self,
grid: Vec<Vec<i32>>,
mut random_generator: StdRng,
min_container_size: i32,
debug_game: bool,
) -> bool {
if self.left.is_some() && self.right.is_some() {
return false;
}
let mut split_vertical: bool = random_generator.gen::<bool>();
if (self.container.width > self.container.height)
&& ((self.container.width.unwrap() / self.container.height.unwrap()) as f64 >= 1.25)
{
split_vertical = true;
} else if (self.container.height > self.container.width)
&& ((self.container.height.unwrap() / self.container.width.unwrap()) as f64 >= 1.25)
{
split_vertical = false;
}
let max_size: i32 = if split_vertical {
self.container.width.unwrap() - min_container_size
} else {
self.container.height.unwrap() - min_container_size
};
if max_size <= min_container_size {
return false;
}
let mut pos: i32 = random_generator.gen_range(min_container_size..max_size);
if split_vertical {
pos += self.container.top_left.x;
if debug_game {
println!("split vertical debug");
}
self.left = Option::from(Box::new(Leaf {
container: Rect {
top_left: Point {
x: self.container.top_left.x,
y: self.container.top_left.y,
},
bottom_right: Point {
x: pos - 1,
y: self.container.bottom_right.y,
},
center: None,
width: None,
height: None,
},
left: None,
right: None,
room: None,
split_vertical: None,
}));
self.right = Option::from(Box::new(Leaf {
container: Rect {
top_left: Point {
x: pos + 1,
y: self.container.top_left.y,
},
bottom_right: Point {
x: self.container.bottom_right.x,
y: self.container.bottom_right.y,
},
center: None,
width: None,
height: None,
},
left: None,
right: None,
room: None,
split_vertical: None,
}))
} else {
pos += self.container.top_left.y;
if debug_game {
println!("split horizontal debug");
}
self.left = Option::from(Box::new(Leaf {
container: Rect {
top_left: Point {
x: self.container.top_left.x,
y: self.container.top_left.y,
},
bottom_right: Point {
x: self.container.bottom_right.x,
y: pos - 1,
},
center: None,
width: None,
height: None,
},
left: None,
right: None,
room: None,
split_vertical: None,
}));
self.right = Option::from(Box::new(Leaf {
container: Rect {
top_left: Point {
x: self.container.top_left.x,
y: pos - 1,
},
bottom_right: Point {
x: self.container.bottom_right.x,
y: self.container.bottom_right.y,
},
center: None,
width: None,
height: None,
},
left: None,
right: None,
room: None,
split_vertical: None,
}))
}
self.split_vertical = Option::from(split_vertical);
return true;
}
fn create_room(
&mut self,
grid: Vec<Vec<i32>>,
mut random_generator: StdRng,
min_room_size: i32,
room_ratio: f32,
) -> bool {
if self.left.is_some() && self.right.is_some() {
return false;
}
let width: i32 = random_generator.gen_range(min_room_size..self.container.width.unwrap());
let height: i32 = random_generator.gen_range(min_room_size..self.container.height.unwrap());
let x_pos: i32 = random_generator
.gen_range(self.container.top_left.x..self.container.bottom_right.x - width);
let y_pos: i32 = random_generator
.gen_range(self.container.top_left.y..self.container.bottom_right.y - height);
let rect: Rect = Rect {
top_left: Point { x: x_pos, y: y_pos },
bottom_right: Point {
x: x_pos + width - 1,
y: y_pos + height - 1,
},
center: None,
width: None,
height: None,
};
if ((min(rect.width.unwrap(), rect.height.unwrap()) as f32)
/ (max(rect.width.unwrap(), rect.height.unwrap()) as f32))
< room_ratio
{
return false;
}
rect.place_rect(grid);
self.room = Option::from(rect);
return true;
}
}
And the Point and Rect structs:
#[derive(PartialEq, Eq, Hash, Clone, Copy)]
pub struct Point {
pub x: i32,
pub y: i32,
}
impl Point {
fn new(x: i32, y: i32) -> Point {
Point { x, y }
}
pub fn sum(&self, other: &Point) -> (i32, i32) {
(self.x + other.x, self.y + other.y)
}
pub fn abs_diff(&self, other: &Point) -> (i32, i32) {
((self.x - other.x).abs(), (self.y - other.y).abs())
}
}
#[derive(Clone)]
pub struct Rect {
pub top_left: Point,
pub bottom_right: Point,
pub center: Option<Point>,
pub width: Option<i32>,
pub height: Option<i32>,
}
impl Rect {
fn new(top_left: Point, bottom_right: Point) -> Rect {
let sum: (i32, i32) = top_left.sum(&bottom_right);
let diff: (i32, i32) = bottom_right.abs_diff(&top_left);
Rect {
top_left,
bottom_right,
center: Option::from(Point {
x: ((sum.0 as f32) / 2.0).round() as i32,
y: ((sum.1 as f32) / 2.0).round() as i32,
}),
width: Option::from(diff.0),
height: Option::from(diff.1),
}
}
pub fn get_distance_to(&self, other: &Rect) -> i32 {
return max(
(self.center.unwrap().x - other.center.unwrap().x).abs(),
(self.center.unwrap().y - other.center.unwrap().y).abs(),
);
}
pub fn place_rect(&self, grid: Vec<Vec<i32>>) {}
}
However, I'm fairly new to Rust and am not sure how to optimise this further than I already have. I know there's some repetition (especially with creating the child leafs) and wanted to know if there was a way to simplify it, speed it up, and make it more idiomatic?