Make camera follow ball

Also increases world size now that not everything has to fit in frame

.vscode/settings.json

@@ -9,6 +9,7 @@
     "codegen",
     "despawn",
     "Despawns",
+    "lerp",
     "recip",
     "respawns",
     "timestep",

src/main.rs

@@ -29,8 +29,9 @@ fn main() -> AppExit {
     run_app(AppSettings::parse())
 }
 
+const BALL_COUNT: u8 = 32;
 const BALL_SIZES: Range<f32> = 10.0..25.0;
-const DIMENSION_SIZES: Range<f32> = 250.0..1000.0;
+const DIMENSION_SIZES: Range<f32> = 500.0..2000.0;
 
 #[derive(Clone, Resource)]
 struct Seed(u64);
@@ -70,20 +71,29 @@ fn run_app(settings: AppSettings) -> AppExit {
         .add_systems(
             Startup,
             (
-                setup_ui,
                 setup_pseudo_random,
-                (setup_player, setup_walls, setup_balls).after(setup_pseudo_random),
+                setup_ui,
+                (setup_player, setup_balls, setup_walls).after(setup_pseudo_random),
             ),
         )
         .add_systems(
             Update,
             (move_player, quit.run_if(input_pressed(KeyCode::KeyQ))),
         )
+        .add_systems(PostUpdate, move_camera)
         .insert_resource(Gravity(Vector::ZERO))
         .insert_resource(seed)
         .run()
 }
 
+fn setup_pseudo_random(mut commands: Commands, mut rng: GlobalEntropy<WyRand>) {
+    commands.insert_resource(PlayerSize(rng.random_range(BALL_SIZES)));
+    commands.insert_resource(PlayableArea(
+        rng.random_range(DIMENSION_SIZES),
+        rng.random_range(DIMENSION_SIZES),
+    ));
+}
+
 fn setup_ui(mut commands: Commands) {
     commands.spawn((Name::new("Camera"), Camera2d, IsDefaultUiCamera));
 }
@@ -96,33 +106,6 @@ struct GameObject;
 #[require(GameObject, RigidBody = RigidBody::Dynamic)]
 struct Ball;
 
-fn setup_balls(
-    mut commands: Commands,
-    mut materials: ResMut<Assets<ColorMaterial>>,
-    mut meshes: ResMut<Assets<Mesh>>,
-    region: Res<PlayableArea>,
-) {
-    let mut random = LocalRng::new(Default::default());
-    for _ in 0..50 {
-        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::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,
-            ),
-        ));
-    }
-}
-
 #[derive(Component, Default)]
 #[require(Ball)]
 struct Player;
@@ -142,12 +125,31 @@ fn setup_player(
     ));
 }
 
-fn setup_pseudo_random(mut commands: Commands, mut rng: GlobalEntropy<WyRand>) {
+fn setup_balls(
-    commands.insert_resource(PlayerSize(rng.random_range(BALL_SIZES)));
+    mut commands: Commands,
-    commands.insert_resource(PlayableArea(
+    mut materials: ResMut<Assets<ColorMaterial>>,
-        rng.random_range(DIMENSION_SIZES),
+    mut meshes: ResMut<Assets<Mesh>>,
-        rng.random_range(DIMENSION_SIZES),
+    region: Res<PlayableArea>,
+) {
+    let mut random = LocalRng::new(Default::default());
+    for _ in 0..BALL_COUNT {
+        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::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,
+            ),
         ));
+    }
 }
 
 #[derive(Component, Default)]
@@ -188,11 +190,10 @@ fn setup_walls(
 fn move_player(
     time: Res<Time>,
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut player: Query<&mut LinearVelocity, With<Player>>,
+    mut velocity: Single<&mut LinearVelocity, With<Player>>,
 ) -> Result {
     let acceleration = 500.0;
 
-    let mut velocity = player.single_mut()?;
     let delta_time = time.delta_secs();
 
     if keyboard_input.any_pressed([KeyCode::KeyW, KeyCode::ArrowUp]) {
@@ -214,3 +215,10 @@ fn move_player(
 fn quit(mut exit: EventWriter<AppExit>) {
     exit.write(AppExit::Success);
 }
+
+fn move_camera(
+    mut camera: Single<&mut Transform, (Without<Player>, With<IsDefaultUiCamera>)>,
+    player: Single<&Transform, (With<Player>, Without<IsDefaultUiCamera>)>,
+) {
+    camera.translation = camera.translation.lerp(player.translation, 0.05);
+}