use nalgebra::{Point2, Vector2};
use rand::Rng;
use rapier2d::prelude::*;
use crate::env::rapier::bipedal_walker::config::BipedalWalkerConfig;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum TerrainState {
Grass,
Stump,
Stairs,
Pit,
}
pub struct TerrainGenerator {
config: BipedalWalkerConfig,
}
impl TerrainGenerator {
pub fn new(config: BipedalWalkerConfig) -> Self {
Self { config }
}
pub fn generate<R: Rng>(
&self,
rng: &mut R,
rigid_body_set: &mut RigidBodySet,
collider_set: &mut ColliderSet,
hardcore: bool,
) -> (Vec<RigidBodyHandle>, Vec<f32>, Vec<f32>) {
let mut terrain_handles = Vec::new();
let mut terrain_x = Vec::new();
let mut terrain_y = Vec::new();
let mut state = TerrainState::Grass;
let mut velocity = 0.0;
let mut y = self.config.terrain_height;
let mut counter = self.config.terrain_startpad as i32;
let mut oneshot = false;
let mut stair_steps = 0i32;
let mut stair_width = 0i32;
let mut stair_height = 0i32;
let mut original_y = 0.0;
for i in 0..self.config.terrain_length {
let x = i as f32 * self.config.terrain_step;
terrain_x.push(x);
match state {
TerrainState::Grass if !oneshot => {
velocity = 0.8 * velocity + 0.01 * (self.config.terrain_height - y).signum();
if i > self.config.terrain_startpad {
velocity += rng.random_range(-1.0..1.0) / self.config.scale;
}
y += velocity;
}
TerrainState::Pit if oneshot => {
counter = rng.random_range(3i32..5i32);
let step = self.config.terrain_step;
let poly = vec![
Vector2::new(x, y),
Vector2::new(x + step, y),
Vector2::new(x + step, y - 4.0 * step),
Vector2::new(x, y - 4.0 * step),
];
self.create_polygon_terrain(
rigid_body_set,
collider_set,
&poly,
&mut terrain_handles,
);
let offset = step * counter as f32;
let poly = vec![
Vector2::new(x + offset, y),
Vector2::new(x + offset + step, y),
Vector2::new(x + offset + step, y - 4.0 * step),
Vector2::new(x + offset, y - 4.0 * step),
];
self.create_polygon_terrain(
rigid_body_set,
collider_set,
&poly,
&mut terrain_handles,
);
counter += 2;
original_y = y;
}
TerrainState::Pit if !oneshot => {
y = original_y;
if counter > 1 {
y -= 4.0 * self.config.terrain_step;
}
}
TerrainState::Stump if oneshot => {
counter = rng.random_range(1i32..3i32);
let step = self.config.terrain_step;
let poly = vec![
Vector2::new(x, y),
Vector2::new(x + counter as f32 * step, y),
Vector2::new(x + counter as f32 * step, y + counter as f32 * step),
Vector2::new(x, y + counter as f32 * step),
];
self.create_polygon_terrain(
rigid_body_set,
collider_set,
&poly,
&mut terrain_handles,
);
}
TerrainState::Stairs if oneshot => {
stair_height = if rng.random_bool(0.5) { 1 } else { -1 };
stair_width = rng.random_range(4i32..5i32);
stair_steps = rng.random_range(3i32..5i32);
original_y = y;
let step = self.config.terrain_step;
for s in 0..stair_steps {
let poly = vec![
Vector2::new(
x + (s * stair_width) as f32 * step,
y + (s * stair_height) as f32 * step,
),
Vector2::new(
x + ((1 + s) * stair_width) as f32 * step,
y + (s * stair_height) as f32 * step,
),
Vector2::new(
x + ((1 + s) * stair_width) as f32 * step,
y + (-1 + s * stair_height) as f32 * step,
),
Vector2::new(
x + (s * stair_width) as f32 * step,
y + (-1 + s * stair_height) as f32 * step,
),
];
self.create_polygon_terrain(
rigid_body_set,
collider_set,
&poly,
&mut terrain_handles,
);
}
counter = stair_steps * stair_width;
}
TerrainState::Stairs if !oneshot => {
let s = (stair_steps * stair_width) - counter - stair_height;
let n = s as f32 / stair_width as f32;
y = original_y + n * stair_height as f32 * self.config.terrain_step;
}
_ => {}
}
oneshot = false;
terrain_y.push(y);
counter = if counter > 0 { counter - 1 } else { 0 };
if counter == 0 {
counter = rng.random_range(
(self.config.terrain_grass / 2) as i32..self.config.terrain_grass as i32,
);
if state == TerrainState::Grass && hardcore {
state = match rng.random_range(1..4) {
1 => TerrainState::Stump,
2 => TerrainState::Stairs,
3 => TerrainState::Pit,
_ => TerrainState::Grass,
};
oneshot = true;
} else {
state = TerrainState::Grass;
oneshot = true;
}
}
}
for i in 0..(self.config.terrain_length - 1) {
let p1 = Point2::new(terrain_x[i], terrain_y[i]);
let p2 = Point2::new(terrain_x[i + 1], terrain_y[i + 1]);
let rigid_body = RigidBodyBuilder::fixed()
.translation(vector![0.0, 0.0])
.build();
let handle = rigid_body_set.insert(rigid_body);
let collider = ColliderBuilder::segment(p1, p2)
.friction(self.config.friction)
.active_events(ActiveEvents::COLLISION_EVENTS)
.collision_groups(InteractionGroups::new(Group::GROUP_1, Group::ALL))
.build();
collider_set.insert_with_parent(collider, handle, rigid_body_set);
terrain_handles.push(handle);
}
(terrain_handles, terrain_x, terrain_y)
}
fn create_polygon_terrain(
&self,
rigid_body_set: &mut RigidBodySet,
collider_set: &mut ColliderSet,
vertices: &[Vector2<f32>],
handles: &mut Vec<RigidBodyHandle>,
) {
let rigid_body = RigidBodyBuilder::fixed()
.translation(vector![0.0, 0.0])
.build();
let handle = rigid_body_set.insert(rigid_body);
let points: Vec<Point2<f32>> = vertices.iter().map(|v| Point2::new(v.x, v.y)).collect();
let collider = ColliderBuilder::convex_hull(&points)
.unwrap()
.friction(self.config.friction)
.active_events(ActiveEvents::COLLISION_EVENTS)
.build();
collider_set.insert_with_parent(collider, handle, rigid_body_set);
handles.push(handle);
}
}
#[cfg(test)]
mod tests {
use super::*;
use rand::rngs::mock::StepRng;
#[test]
fn test_terrain_generator_creation() {
let config = BipedalWalkerConfig::default();
let generator = TerrainGenerator::new(config.clone());
assert_eq!(generator.config.terrain_length, 200);
}
#[test]
fn test_generate_basic_structure() {
let config = BipedalWalkerConfig::default();
let generator = TerrainGenerator::new(config);
let mut rigid_body_set = RigidBodySet::new();
let mut collider_set = ColliderSet::new();
let mut rng = StepRng::new(0, 1);
let (handles, x_coords, y_coords) =
generator.generate(&mut rng, &mut rigid_body_set, &mut collider_set, false);
assert!(!handles.is_empty());
assert_eq!(x_coords.len(), 200);
assert_eq!(y_coords.len(), 200);
assert!(!rigid_body_set.is_empty());
assert!(!collider_set.is_empty());
assert!(handles.len() >= 199);
}
#[test]
fn test_generate_hardcore_mode() {
let config = BipedalWalkerConfig::default();
let generator = TerrainGenerator::new(config);
let mut rigid_body_set = RigidBodySet::new();
let mut collider_set = ColliderSet::new();
let mut rng = StepRng::new(42, 1);
let (handles, _, _) = generator.generate(
&mut rng,
&mut rigid_body_set,
&mut collider_set,
true, );
assert!(!handles.is_empty());
assert!(!rigid_body_set.is_empty());
}
#[test]
fn test_coordinate_monotonicity() {
let config = BipedalWalkerConfig::default();
let generator = TerrainGenerator::new(config.clone());
let mut rigid_body_set = RigidBodySet::new();
let mut collider_set = ColliderSet::new();
let mut rng = StepRng::new(0, 1);
let (_, x_coords, _) =
generator.generate(&mut rng, &mut rigid_body_set, &mut collider_set, false);
for i in 0..x_coords.len() - 1 {
assert!(x_coords[i + 1] > x_coords[i]);
let step = x_coords[i + 1] - x_coords[i];
assert!((step - config.terrain_step).abs() < 1e-5);
}
}
#[test]
fn test_create_polygon_terrain() {
let config = BipedalWalkerConfig::default();
let generator = TerrainGenerator::new(config);
let mut rigid_body_set = RigidBodySet::new();
let mut collider_set = ColliderSet::new();
let mut handles = Vec::new();
let poly = vec![
Vector2::new(0.0, 0.0),
Vector2::new(1.0, 0.0),
Vector2::new(1.0, 1.0),
Vector2::new(0.0, 1.0),
];
generator.create_polygon_terrain(
&mut rigid_body_set,
&mut collider_set,
&poly,
&mut handles,
);
assert_eq!(handles.len(), 1);
assert_eq!(rigid_body_set.len(), 1);
assert_eq!(collider_set.len(), 1);
let handle = handles[0];
let rb = rigid_body_set.get(handle).unwrap();
assert!(rb.is_fixed());
}
#[test]
fn test_startpad_flatness() {
let config = BipedalWalkerConfig::default();
let startpad_len = config.terrain_startpad;
let generator = TerrainGenerator::new(config);
let mut rigid_body_set = RigidBodySet::new();
let mut collider_set = ColliderSet::new();
let mut rng = StepRng::new(123, 1);
let (_, _, y_coords) =
generator.generate(&mut rng, &mut rigid_body_set, &mut collider_set, false);
let initial_y = y_coords[0];
for y in y_coords.iter().take(startpad_len).skip(1) {
assert!((*y - initial_y).abs() < 5.0);
}
}
}