refined snail, added starfish

Author: cxreiff

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "lifecycler"
-version = "0.1.8"
+version = "0.1.9"
 edition = "2021"
 license = "MIT OR Apache-2.0 OR CC0-1.0"
 

Cargo.toml

@@ -5,6 +5,8 @@ use rand_chacha::ChaCha8Rng;
 
 use crate::pellets::Pellet;
 
+const BEHAVIOR_INTERVAL_SECONDS: f32 = 8.;
+
 pub(super) fn plugin(app: &mut App) {
     app.init_resource::<CreatureRng>();
 }
@@ -27,7 +29,7 @@ pub struct CreatureBehavior {
 impl Default for CreatureBehavior {
     fn default() -> Self {
         Self {
-            timer: Timer::from_seconds(5., TimerMode::Repeating),
+            timer: Timer::from_seconds(BEHAVIOR_INTERVAL_SECONDS, TimerMode::Repeating),
             variant: CreatureBehaviorVariant::Debut,
         }
     }
@@ -64,16 +66,18 @@ pub trait CreatureOperations {
         self.clamp();
     }
 
-    fn decide_behavior(&mut self, time: &Time) {
+    fn decide_behavior(&mut self, time: &Time, _rng: &mut CreatureRng) {
         self.behavior().timer.tick(time.delta());
 
         if self.behavior().timer.just_finished() {
             match self.behavior().variant {
                 CreatureBehaviorVariant::Idle => {
-                    if self.transform().rotation.y == 0. {
-                        self.start_swim_left();
-                    } else {
+                    let current_y = self.transform().rotation.y;
+                    self.face_left();
+                    if self.transform().rotation.y != current_y {
                         self.start_swim_right();
+                    } else {
+                        self.start_swim_left();
                     }
                 }
                 CreatureBehaviorVariant::SwimRight => self.start_idle(),
@@ -175,22 +179,36 @@ pub trait CreatureOperations {
 
     fn behavior_seek_pellet(
         &mut self,
-        time: &Time,
-        rng: &mut CreatureRng,
-        pellet: Result<(Entity, &Transform), QueryEntityError>,
-        commands: &mut Commands,
-    );
+        _time: &Time,
+        _rng: &mut CreatureRng,
+        _pellet: Result<(Entity, &Transform), QueryEntityError>,
+        _commands: &mut Commands,
+    ) {
+        // optional impl
+    }
 
-    fn face_right(&mut self);
-    fn face_left(&mut self);
+    fn face_right(&mut self) {
+        // optional impl
+    }
+
+    fn face_left(&mut self) {
+        // optional impl
+    }
 
     fn clamp(&mut self) {
         let (min, max) = Self::valid_area();
         self.transform().translation = self.transform().translation.clamp(min, max);
     }
 
-    fn rank_pellet(&mut self, pellet_transform: &Transform) -> f32;
-    fn check_pellet(&mut self, rank: f32) -> bool;
+    fn rank_pellet(&mut self, pellet_transform: &Transform) -> f32 {
+        self.transform()
+            .translation
+            .distance(pellet_transform.translation)
+    }
+
+    fn check_pellet(&mut self, _rank: f32) -> bool {
+        true
+    }
 
     fn behavior(&mut self) -> &mut CreatureBehavior;
     fn transform(&mut self) -> &mut Transform;
@@ -200,11 +218,14 @@ pub trait CreatureOperations {
 
     fn valid_random_point(rng: &mut CreatureRng) -> Vec3 {
         let (min, max) = Self::valid_area();
-        Cuboid::from_corners(min + Self::valid_point_buffer(), max - Self::valid_point_buffer()).sample_interior(&mut rng.0)
+        Cuboid::from_corners(
+            min + Self::valid_point_buffer(),
+            max - Self::valid_point_buffer(),
+        )
+        .sample_interior(&mut rng.0)
     }
 
     fn valid_point_buffer() -> Vec3 {
         Vec3::splat(0.0)
     }
 }
-

assets/fish.glb

@@ -129,6 +129,6 @@ impl<'a> CreatureOperations for FishOperations<'a> {
     }
 
     fn valid_point_buffer() -> Vec3 {
-        Vec3::new(0.2, 0.3, 0.)
+        Vec3::new(0.2, 0.3, 0.1)
     }
 }

assets/snail.glb

@@ -58,7 +58,7 @@ fn setup_fish_system(
 
     let fish_materials = (0..36)
         .map(|_| {
-            let base_color = Color::hsl(((rng.next_u32() % 160 + 200) % 360) as f32, 0.4, 0.3);
+            let base_color = Color::hsl(((rng.next_u32() % 180 + 165) % 360) as f32, 0.3, 0.4);
             let emissive = base_color.to_linear() * 0.3;
 
             materials.add(StandardMaterial {
@@ -138,9 +138,11 @@ fn fish_behavior_system(
 fn fish_behavior_change_system(
     time: Res<Time>,
     mut fishes: Query<(&mut Transform, &mut CreatureBehavior, &mut FishMortality), With<Fish>>,
+    mut rng: ResMut<CreatureRng>,
 ) {
     for (mut transform, mut behavior, mut mortality) in fishes.iter_mut() {
-        FishOperations::new(&mut transform, &mut behavior, &mut mortality).decide_behavior(&time);
+        FishOperations::new(&mut transform, &mut behavior, &mut mortality)
+            .decide_behavior(&time, &mut rng);
     }
 }
 

assets/starfish.glb

@@ -4,10 +4,11 @@ use bevy::prelude::*;
 use rand::RngCore;
 
 use super::{
-    behavior::CreatureRng, fish_behavior::{
-        FISH_AGING_INTERVAL_SECONDS, FISH_AVERAGE_LONGEVITY, FISH_BULK_MAX,
-        FISH_SATIATION_MAX,
-    }, fish_systems::FishSpawnEvent
+    behavior::CreatureRng,
+    fish_behavior::{
+        FISH_AGING_INTERVAL_SECONDS, FISH_AVERAGE_LONGEVITY, FISH_BULK_MAX, FISH_SATIATION_MAX,
+    },
+    fish_systems::FishSpawnEvent,
 };
 
 pub(super) fn plugin(app: &mut App) {

src/creatures/behavior.rs

@@ -6,12 +6,15 @@ mod fish_systems;
 mod lifecycle;
 mod snail_behavior;
 mod snail_systems;
+mod starfish_behavior;
+mod starfish_systems;
 
 pub(super) fn plugin(app: &mut App) {
     app.add_plugins((
         behavior::plugin,
         fish_systems::plugin,
         lifecycle::plugin,
         snail_systems::plugin,
+        starfish_systems::plugin,
     ));
 }

src/creatures/fish_behavior.rs

@@ -21,16 +21,16 @@ impl<'a> SnailOperations<'a> {
 }
 
 impl<'a> CreatureOperations for SnailOperations<'a> {
-    fn behavior_debut(&mut self, time: &Time, _rng: &mut CreatureRng) {
-        self.transform.translation.x += time.delta_seconds() * Self::base_speed();
-
-        if self.transform.translation.x > -1. {
+    fn behavior_debut(&mut self, _time: &Time, _rng: &mut CreatureRng) {
+        if self.transform.translation.x < 0. {
             self.start_swim_right();
+        } else {
+            self.start_swim_left();
         }
     }
 
     fn behavior_idle(&mut self, time: &Time) {
-        self.transform.translation.y += time.elapsed_seconds().sin() / 1000.;
+        self.transform.translation.z += time.elapsed_seconds().sin() / 10_000.;
     }
 
     fn behavior_seek_pellet(
@@ -69,15 +69,11 @@ impl<'a> CreatureOperations for SnailOperations<'a> {
     }
 
     fn face_right(&mut self) {
-        *self.transform =
-            self.transform
-                .with_rotation(Quat::from_euler(EulerRot::XYZ, 0., 3. * PI / 2., 0.));
+        *self.transform = self.transform.with_rotation(Quat::IDENTITY);
     }
 
     fn face_left(&mut self) {
-        *self.transform =
-            self.transform
-                .with_rotation(Quat::from_euler(EulerRot::XYZ, 0., PI / 2., 0.));
+        *self.transform = self.transform.with_rotation(Quat::from_rotation_y(PI));
     }
 
     fn rank_pellet(&mut self, pellet_transform: &Transform) -> f32 {

src/creatures/fish_systems.rs

@@ -1,4 +1,4 @@
-use std::{f32::consts::PI, time::Duration};
+use std::time::Duration;
 
 use bevy::{prelude::*, time::common_conditions::on_timer};
 
@@ -29,8 +29,8 @@ pub struct Snail;
 #[derive(Resource, Deref)]
 pub struct SnailScene(Handle<Scene>);
 
-#[derive(Event, Deref)]
-pub struct SnailSpawnEvent(pub Vec3);
+#[derive(Event)]
+pub struct SnailSpawnEvent(pub Vec3, pub f32);
 
 fn setup_snails_system(
     mut commands: Commands,
@@ -40,22 +40,25 @@ fn setup_snails_system(
     let snail = asset_server.load(GltfAssetLabel::Scene(0).from_asset("embedded://snail.glb"));
     commands.insert_resource(SnailScene(snail));
 
-    spawn_events.send(SnailSpawnEvent(Vec3::new(-1.4, -1.7, 0.4)));
+    spawn_events.send(SnailSpawnEvent(Vec3::new(-1.4, -1.7, 0.4), 0.1));
+    spawn_events.send(SnailSpawnEvent(Vec3::new(1.4, -1.7, -0.1), 0.07));
 }
 
 fn spawn_snails_system(
     mut commands: Commands,
     mut spawn_events: EventReader<SnailSpawnEvent>,
     fish_scene: Res<SnailScene>,
 ) {
-    for spawn_location in spawn_events.read() {
-        let transform = Transform::from_translation(**spawn_location)
-            .with_rotation(Quat::from_euler(EulerRot::XYZ, 0., 3. * PI / 2., 0.))
-            .with_scale(Vec3::new(0.09, 0.09, 0.09));
+    for SnailSpawnEvent(location, size) in spawn_events.read() {
+        let transform = Transform::from_translation(*location).with_scale(Vec3::splat(*size));
+        let mut behavior = CreatureBehavior::default();
+        behavior
+            .timer
+            .set_duration(behavior.timer.duration() - Duration::from_secs((size * 10.) as u64 % 2));
 
         commands.spawn((
             Snail,
-            CreatureBehavior::default(),
+            behavior,
             SceneBundle {
                 transform,
                 scene: fish_scene.clone(),
@@ -85,9 +88,10 @@ fn snails_behavior_system(
 fn snails_behavior_change_system(
     time: Res<Time>,
     mut snails: Query<(&mut Transform, &mut CreatureBehavior), With<Snail>>,
+    mut rng: ResMut<CreatureRng>,
 ) {
     for (mut transform, mut behavior) in snails.iter_mut() {
-        SnailOperations::new(&mut transform, &mut behavior).decide_behavior(&time);
+        SnailOperations::new(&mut transform, &mut behavior).decide_behavior(&time, &mut rng);
     }
 }
 

src/creatures/lifecycle.rs

@@ -0,0 +1,59 @@
+use bevy::prelude::*;
+
+use super::behavior::{CreatureBehavior, CreatureBehaviorVariant, CreatureOperations, CreatureRng};
+
+pub struct StarfishOperations<'a> {
+    transform: &'a mut Transform,
+    behavior: &'a mut CreatureBehavior,
+}
+
+impl<'a> StarfishOperations<'a> {
+    pub(super) fn new(transform: &'a mut Transform, behavior: &'a mut CreatureBehavior) -> Self {
+        Self {
+            transform,
+            behavior,
+        }
+    }
+}
+
+impl<'a> CreatureOperations for StarfishOperations<'a> {
+    fn decide_behavior(&mut self, time: &Time, rng: &mut CreatureRng) {
+        self.behavior().timer.tick(time.delta());
+
+        if self.behavior().timer.just_finished() {
+            match self.behavior().variant {
+                CreatureBehaviorVariant::Idle => self.start_seek_point(rng),
+                _ => self.start_idle(),
+            }
+        }
+    }
+
+    fn behavior_debut(&mut self, _time: &Time, _rng: &mut CreatureRng) {
+        self.start_idle()
+    }
+
+    fn behavior_idle(&mut self, time: &Time) {
+        self.transform()
+            .rotate_z((time.elapsed_seconds() / 10.).sin() * Self::base_speed() * -0.1);
+    }
+
+    fn base_speed() -> f32 {
+        0.01
+    }
+
+    fn valid_area() -> (Vec3, Vec3) {
+        (Vec3::new(-1.4, -1.4, -0.41), Vec3::new(1.4, 1.4, -0.41))
+    }
+
+    fn behavior(&mut self) -> &mut CreatureBehavior {
+        self.behavior
+    }
+
+    fn transform(&mut self) -> &mut Transform {
+        self.transform
+    }
+
+    fn valid_point_buffer() -> Vec3 {
+        Vec3::new(0.1, 0.1, 0.)
+    }
+}