fish movement

Cargo.toml

@@ -17,3 +17,4 @@ parry2d = "0.4.0"
 log = "0.4.14"
 env_logger = "0.8.3"
 nalgebra = "0.26.1"
+rand = "0.8.3"

assets/worlds/mainworld.json

@@ -5,8 +5,12 @@
     },
     "fish": [
         {
-            "x": 100.0,
+            "x": 500.0,
-            "y": 100.0
+            "y": 500.0
+        },
+        {
+            "x": 800.0,
+            "y": 500.0
         }
     ]
 }

src/entities/fish.rs

@@ -1,17 +1,20 @@
+use rand::{Rng, prelude::ThreadRng};
 use raylib::prelude::*;
 
 use crate::{gamecore::GameCore, lib::utils::triangles::rotate_vector, player::Player};
 
 const FISH_FOLLOW_PLAYER_DISTANCE: f32 = 80.0;
 const FISH_FOLLOW_PLAYER_SPEED: f32 = 2.0;
-const FISH_FOLLOW_PLAYER_SPEED_FAST: f32 = 6.0;
+const FISH_FOLLOW_PLAYER_SPEED_FAST: f32 = FISH_FOLLOW_PLAYER_SPEED * 3.0;
+const FISH_ATTACH_RADIUS: f32 = 20.0;
 
 #[derive(Debug, Clone)]
 pub struct FishEntity {
     position: Vector2,
     direction: Vector2,
     following_player: bool,
-    size: Vector2
+    size: Vector2,
+    rng: ThreadRng
 }
 
 impl FishEntity {
@@ -20,10 +23,8 @@ impl FishEntity {
             position: position,
             direction: Vector2::zero(),
             following_player: true,
-            size: Vector2 {
+            size: Vector2 { x: 5.0, y: 8.0 },
-                x: 5.0,
+            rng: rand::thread_rng()
-                y: 8.0
-            }
         }
     }
 
@@ -35,7 +36,7 @@ impl FishEntity {
         return output;
     }
 
-    pub fn handle_follow_player(&mut self, player: &Player) {
+    pub fn handle_follow_player(&mut self, player: &Player, dt: f64) {
         // Distance and direction to player
         let dist_to_player = player.position - self.position;
         let dist_to_player_lin = self.position.distance_to(player.position);
@@ -45,13 +46,16 @@ impl FishEntity {
         // Fish movement
         let movement;
 
+        // Random variance
+        let variance = self.rng.gen_range(500.0..1000.0) / 1000.0;
+
         // If the fish is double its follow distance from the player
         if dist_to_player_lin.abs() > (FISH_FOLLOW_PLAYER_DISTANCE * 2.0) {
-            movement = direction_to_player * FISH_FOLLOW_PLAYER_SPEED_FAST;
+            movement = direction_to_player * FISH_FOLLOW_PLAYER_SPEED_FAST * variance;
         } else {
             // Move slowly in the direction of the player unless too close
             if dist_to_player_lin.abs() > FISH_FOLLOW_PLAYER_DISTANCE {
-                movement = direction_to_player * FISH_FOLLOW_PLAYER_SPEED;
+                movement = direction_to_player * FISH_FOLLOW_PLAYER_SPEED * variance;
             } else {
                 movement = Vector2::zero();
             }
@@ -62,37 +66,54 @@ impl FishEntity {
         self.position += movement;
     }
 
-    pub fn handle_free_movement(&mut self) {}
+    pub fn handle_free_movement(&mut self, player: &Player, dt: f64) {
+        if player.position.distance_to(self.position).abs() <= player.size.y * 2.0 {
+            self.following_player = true;
+        }
+    }
 
     pub fn update_position(&mut self, player: &Player, dt: f64) {
         if self.following_player {
-            self.handle_follow_player(player);
+            self.handle_follow_player(player, dt);
         } else {
-            self.handle_free_movement();
+            self.handle_free_movement(player, dt);
         }
     }
 
     pub fn render(&self, context_2d: &mut RaylibMode2D<RaylibDrawHandle>) {
-
         // Direction
-        let direction = Vector2::zero().angle_to(self.direction.normalized()) + (90.0 as f32).to_radians();
+        let direction =
+            Vector2::zero().angle_to(self.direction.normalized()) + (90.0 as f32).to_radians();
 
         // Get the corners of the fish
-        let fish_front = rotate_vector(Vector2 {
+        let fish_front = rotate_vector(
-            x: 0.0,
+            Vector2 {
-            y: (self.size.y / 2.0) * -1.0,
+                x: 0.0,
-        }, direction);
+                y: (self.size.y / 2.0) * -1.0,
-        let fish_bl = rotate_vector(Vector2 {
+            },
-            x: (self.size.x / 2.0) * -1.0,
+            direction,
-            y: (self.size.y / 2.0),
+        );
-        }, direction);
+        let fish_bl = rotate_vector(
-        let fish_br = rotate_vector(Vector2 {
+            Vector2 {
-            x: (self.size.x / 2.0),
+                x: (self.size.x / 2.0) * -1.0,
-            y: (self.size.y / 2.0),
+                y: (self.size.y / 2.0),
-        }, direction);
+            },
+            direction,
+        );
+        let fish_br = rotate_vector(
+            Vector2 {
+                x: (self.size.x / 2.0),
+                y: (self.size.y / 2.0),
+            },
+            direction,
+        );
 
         // Draw the fish as a triangle with rotation
-        context_2d.draw_triangle(self.position + fish_front, self.position + fish_bl, self.position + fish_br, Color::BLACK);
+        context_2d.draw_triangle(
-
+            self.position + fish_front,
+            self.position + fish_bl,
+            self.position + fish_br,
+            Color::BLACK,
+        );
     }
 }