Pre-generate seeded random values ahead of time

And use run-random values for unimportant things

src/lib.rs

@@ -1,2 +0,0 @@
-mod random;
-pub use random::Random;

src/main.rs

@@ -1,4 +1,8 @@
-use std::f32::consts::PI;
+use std::{
+    f32::consts::PI,
+    hash::{DefaultHasher, Hash, Hasher},
+    ops::Range,
+};
 
 use avian2d::{math::Vector, prelude::*};
 use bevy::{
@@ -10,11 +14,8 @@ use bevy::{
     prelude::*,
 };
 use clap::Parser;
-
-use distributed_physics_test::Random;
-
-const AREA_WIDTH: f32 = 750.;
-const PLAYER_SIZE: f32 = 30.;
+use rand::{Rng, SeedableRng, rng};
+use rand_chacha::ChaCha8Rng;
 
 #[derive(Parser)]
 #[command(version, about)]
@@ -27,26 +28,49 @@ fn main() -> AppExit {
     run_app(AppSettings::parse())
 }
 
+fn hash_string(string: &String) -> u64 {
+    let mut state = DefaultHasher::new();
+    string.hash(&mut state);
+    state.finish()
+}
+
+const BALL_SIZES: Range<f32> = 10.0..25.0;
+const DIMENSION_SIZES: Range<f32> = 250.0..1000.0;
+
+#[derive(Resource)]
+struct PlayableArea(f32, f32);
+
+#[derive(Resource)]
+struct PlayerSize(f32);
+
 fn run_app(settings: AppSettings) -> AppExit {
+    let mut rng = ChaCha8Rng::seed_from_u64(
+        settings
+            .seed
+            .parse::<u64>()
+            .unwrap_or_else(|_| hash_string(&settings.seed)),
+    );
+
     App::new()
         .add_plugins((
             DefaultPlugins,
             PhysicsPlugins::default().with_length_unit(50.0),
         ))
-        .add_systems(
-            Startup,
-            (setup_scene, setup_player, setup_balls, setup_walls),
-        )
+        .add_systems(Startup, (setup_balls, setup_ui, setup_player, setup_walls))
         .add_systems(
             Update,
             (move_player, quit.run_if(input_pressed(KeyCode::KeyQ))),
         )
         .insert_resource(Gravity(Vector::ZERO))
-        .insert_resource(Random::seed(&settings.seed))
+        .insert_resource(PlayerSize(rng.random_range(BALL_SIZES)))
+        .insert_resource(PlayableArea(
+            rng.random_range(DIMENSION_SIZES),
+            rng.random_range(DIMENSION_SIZES),
+        ))
         .run()
 }
 
-fn setup_scene(mut commands: Commands) {
+fn setup_ui(mut commands: Commands) {
     commands.spawn((Name::new("Camera"), Camera2d, IsDefaultUiCamera));
 }
 
@@ -62,22 +86,25 @@ fn setup_balls(
     mut commands: Commands,
     mut materials: ResMut<Assets<ColorMaterial>>,
     mut meshes: ResMut<Assets<Mesh>>,
-    mut rng: ResMut<Random>,
+    region: Res<PlayableArea>,
 ) {
+    let mut random = rng();
     for _ in 0..20 {
-        let circle = Circle::new(rng.range(10.0..(PLAYER_SIZE - 5.)));
-        let mut transform = Transform::from_xyz(
-            0.,
-            rng.range((PLAYER_SIZE + 5.)..(AREA_WIDTH / 2. - PLAYER_SIZE)),
-            0.,
-        );
-        transform.rotate_around(Vec3::ZERO, Quat::from_rotation_z(rng.range(0.0..(PI * 2.))));
+        let circle = Circle::new(random.random_range(BALL_SIZES));
         commands.spawn((
             Ball,
             Collider::from(circle),
             Mesh2d(meshes.add(circle)),
             MeshMaterial2d(materials.add(Color::from(RED_400))),
-            transform,
+            Transform::from_xyz(
+                random.random_range(
+                    (-region.0 / 2.0 + circle.radius)..(region.0 / 2.0 - circle.radius),
+                ),
+                random.random_range(
+                    (-region.1 / 2.0 + circle.radius)..(region.1 / 2.0 - circle.radius),
+                ),
+                0.0,
+            ),
         ));
     }
 }
@@ -90,8 +117,9 @@ fn setup_player(
     mut commands: Commands,
     mut materials: ResMut<Assets<ColorMaterial>>,
     mut meshes: ResMut<Assets<Mesh>>,
+    radius: Res<PlayerSize>,
 ) {
-    let circle = Circle::new(PLAYER_SIZE);
+    let circle = Circle::new(radius.0);
     commands.spawn((
         Player,
         Collider::from(circle),
@@ -108,17 +136,27 @@ fn setup_walls(
     mut commands: Commands,
     mut materials: ResMut<Assets<ColorMaterial>>,
     mut meshes: ResMut<Assets<Mesh>>,
+    region: Res<PlayableArea>,
 ) {
-    let thickness = 20.;
-    let width = AREA_WIDTH + thickness;
+    let thickness = 20.0;
 
     for i in 0..4 {
-        let mut transform = Transform::from_xyz(0., AREA_WIDTH / 2., 0.);
-        transform.rotate_around(Vec3::ZERO, Quat::from_rotation_z((i as f32) * PI / 2.));
+        let (offset, length) = if i % 2 == 0 {
+            (region.0, region.1 + thickness)
+        } else {
+            (region.1, region.0 + thickness)
+        };
+
+        let mut transform = Transform::from_xyz(0.0, offset / 2.0, 0.0);
+        transform.rotate_around(
+            Vec3::ZERO,
+            Quat::from_rotation_z(((i + 1) as f32) * PI / 2.0),
+        );
+
         commands.spawn((
             Wall,
-            Collider::rectangle(width, thickness),
-            Mesh2d(meshes.add(Rectangle::new(width, thickness))),
+            Collider::rectangle(length, thickness),
+            Mesh2d(meshes.add(Rectangle::new(length, thickness))),
             MeshMaterial2d(materials.add(Color::from(WHITE))),
             transform,
         ));
@@ -130,7 +168,7 @@ fn move_player(
     keyboard_input: Res<ButtonInput<KeyCode>>,
     mut player: Query<&mut LinearVelocity, With<Player>>,
 ) {
-    let acceleration = 500.;
+    let acceleration = 500.0;
 
     let mut velocity = player.single_mut();
     let delta_time = time.delta_secs();

src/random.rs

@@ -1,33 +0,0 @@
-use std::hash::{DefaultHasher, Hash, Hasher};
-
-use bevy::prelude::*;
-use rand::{
-    Rng, SeedableRng,
-    distr::uniform::{SampleRange, SampleUniform},
-};
-use rand_chacha::ChaCha8Rng;
-
-#[derive(Resource)]
-pub struct Random(ChaCha8Rng);
-
-impl Random {
-    pub fn seed(seed: &String) -> Self {
-        Random(ChaCha8Rng::seed_from_u64(
-            seed.parse::<u64>().unwrap_or_else(|_| hash_string(seed)),
-        ))
-    }
-
-    pub fn range<T, R>(&mut self, range: R) -> T
-    where
-        T: SampleUniform,
-        R: SampleRange<T>,
-    {
-        self.0.random_range(range)
-    }
-}
-
-fn hash_string(string: &String) -> u64 {
-    let mut state = DefaultHasher::new();
-    string.hash(&mut state);
-    state.finish()
-}