Sheep anim, corpses

src/auto_anim.rs

@@ -1,4 +1,4 @@
-use bevy::prelude::*;
+use bevy::{prelude::*, render::render_resource::Face};
 
 use crate::GameSet;
 
@@ -39,7 +39,7 @@ fn auto_anim<T : AnimSet + Send + Sync + 'static>(
 ) {
     for (entity, mut auto_anim) in auto_anim_query.iter_mut() {
         if auto_anim.timer.tick(time.delta()).just_finished() {
-            auto_anim.current_frame = (auto_anim.current_frame + 1) % (auto_anim.set.get_index_range().end - auto_anim.set.get_index_range().start);
+            auto_anim.current_frame = (auto_anim.current_frame + 1) % (auto_anim.set.get_index_range().end + 1 - auto_anim.set.get_index_range().start);
             commands.entity(entity).insert(materials.materials[
                 auto_anim.set.get_index_range().start + auto_anim.current_frame
             ].clone());
@@ -58,6 +58,8 @@ fn init_storage<T : AnimSet + Send + Sync + 'static>(
             base_color_texture: Some(asset_server.load(T::get_tile_path(i))),
             alpha_mode: AlphaMode::Blend,
             reflectance: 0.1,
+            double_sided: true,
+            cull_mode: None,
             ..default()
         }));
     }

src/corpse.rs

@@ -0,0 +1,82 @@
+use bevy::prelude::*;
+use rand::Rng;
+
+use crate::{GameSet, GameStuff};
+
+pub struct CorpsePlugin;
+
+impl Plugin for CorpsePlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Update, (corpse_system, spawn_corpse_system).in_set(GameSet::Playing))
+            .add_event::<SpawnCorpse>()
+            .add_systems(Startup, setup_corpse_storage);
+    }
+}
+
+#[derive(Component)]
+pub struct Corpse {
+    pub time : f32
+}
+
+fn corpse_system(
+    mut commands : Commands,
+    time : Res<Time>,
+    mut query : Query<(Entity, &mut Corpse)>
+) {
+    for (entity, mut corpse) in query.iter_mut() {
+        corpse.time -= time.delta_seconds();
+        if corpse.time <= 0.0 {
+            commands.entity(entity).despawn_recursive();
+        }
+    }
+}
+
+#[derive(Resource)]
+pub struct CorpseStoage {
+    pub material: Handle<StandardMaterial>,
+    pub mesh: Handle<Mesh>,
+}
+
+fn setup_corpse_storage(
+    mut commands: Commands,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    asset_server: Res<AssetServer>,
+    mut meshs : ResMut<Assets<Mesh>>
+) {
+    commands.insert_resource(CorpseStoage {
+        material: materials.add(StandardMaterial {
+            base_color_texture: Some(asset_server.load("sheep/tile001.png")),
+            alpha_mode: AlphaMode::Blend,
+            reflectance: 0.1,
+            ..default()
+        }),
+        mesh: meshs.add(shape::Plane::default().into())
+    });
+}
+
+#[derive(Event)]
+pub struct SpawnCorpse {
+    pub position : Vec3
+}
+
+fn spawn_corpse_system(
+    mut commands : Commands,
+    mut event : EventReader<SpawnCorpse>,
+    storage : Res<CorpseStoage>
+) {
+    for event in event.iter() {
+        commands.spawn((
+            PbrBundle {
+                mesh: storage.mesh.clone(),
+                material: storage.material.clone(),
+                transform: Transform::from_translation(event.position + Vec3::Y * rand::thread_rng().gen_range(0.01..=0.02)).with_scale(Vec3::new(2.0, 2.0, 2.0)),
+                ..default()
+            },
+            Corpse {
+                time: 20.0
+            },
+            GameStuff
+        ));
+    }
+    event.clear();
+}

src/global_task/change_safe_area_size.rs

@@ -45,7 +45,7 @@ fn start_change_safe_area(
         let target_pos = Vec2::new(start_pos.x + pos, start_pos.y + pos);
 
         let mut change = ChangeSafeArea {
-            target_scale: 0.5,
+            target_scale: 0.7,
             start_scale: 1.0,
 
             target_pos: target_pos,

src/lib.rs

@@ -19,6 +19,7 @@ pub mod torch;
 pub mod wolf;
 pub mod ambient;
 pub mod auto_anim;
+pub mod corpse;
 
 use std::f32::consts::PI;
 
@@ -104,9 +105,10 @@ impl Plugin for GamePlugin {
             global_task::GlobalTaskPlugin,
         ));
 
-        app.add_plugins(
-            ambient::AmbientPlugin
-        );
+        app.add_plugins((
+            ambient::AmbientPlugin,
+            corpse::CorpsePlugin
+        ));
 
         //For long term updates
         app.insert_resource(Time::<Fixed>::from_seconds(1.0));

src/player.rs

@@ -1,3 +1,5 @@
+use std::f32::consts::PI;
+
 use bevy::{
     input::mouse::MouseWheel,
     pbr::{CascadeShadowConfig, CascadeShadowConfigBuilder},
@@ -9,7 +11,7 @@ use crate::{
     get_sprite_rotation,
     physics::Velocity,
     sprite_material::{create_plane_mesh, SpriteExtension, SpriteMaterial},
-    GameStuff, GameSet,
+    GameStuff, GameSet, auto_anim::{AnimSet, AnimRange, AutoAnimPlugin, AutoAnim},
 };
 
 const DOG_PATH: &str = "test/dog.png";
@@ -48,7 +50,9 @@ impl Plugin for PlayerPlugin {
                 player_movemnt_by_mouse.run_if(in_state(MovementStyle::Mouse)),
             )
             .add_systems(Update, (change_movement_style, bark).in_set(GameSet::Playing))
-            .add_systems(Update, (set_cam_distance, camera_movement, stamina_increse).in_set(GameSet::Playing));
+            .add_systems(Update, (set_cam_distance, camera_movement, stamina_increse).in_set(GameSet::Playing))
+            .add_plugins(AutoAnimPlugin::<PlayerAnim>::default())
+            .add_systems(Update, set_anim_state.in_set(GameSet::Playing));
     }
 }
 
@@ -85,6 +89,36 @@ fn stamina_increse(
     }
 }
 
+#[derive(Default)]
+pub enum PlayerAnim {
+    BigBark,
+    Bark,
+    WalkAndBark,
+    Walk,
+    #[default]
+    Idle
+}
+
+impl AnimSet for PlayerAnim {
+    fn get_folder_path() -> String {
+        "dog".to_string()
+    }
+
+    fn get_index_range(&self) -> crate::auto_anim::AnimRange {
+        match self {
+            PlayerAnim::BigBark => AnimRange::new(0, 2),
+            PlayerAnim::Bark => AnimRange::new(3, 5),
+            PlayerAnim::WalkAndBark => AnimRange::new(6,7),
+            PlayerAnim::Walk => AnimRange::new(9, 11),
+            PlayerAnim::Idle => AnimRange::new(12, 15),
+        }
+    }
+
+    fn get_tile_count() -> usize {
+        16
+    }
+}
+
 #[derive(Component)]
 pub struct Player;
 
@@ -122,31 +156,26 @@ fn spawn_player_by_event(
     mut event_reader: EventReader<SpawnPlayer>,
     asset_server: Res<AssetServer>,
     mut meshes: ResMut<Assets<Mesh>>,
-    _materials: ResMut<Assets<StandardMaterial>>,
-    mut sprite_material: ResMut<Assets<SpriteMaterial>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
     for event in event_reader.read() {
         let plane = meshes.add(create_plane_mesh());
-        let material = sprite_material.add(SpriteMaterial {
-            base: StandardMaterial {
+        let material = materials.add(
+            StandardMaterial {
                 base_color_texture: Some(asset_server.load(DOG_PATH)),
                 alpha_mode: AlphaMode::Opaque,
                 ..default()
-            },
-            extension: SpriteExtension {
-                base_teture: Some(asset_server.load(DOG_PATH)),
-            },
-        });
+            });
 
         info!("Spawn player at {:?}", event.position);
 
         commands.spawn((
-            MaterialMeshBundle {
+            PbrBundle {
                 mesh: plane.clone(),
                 material: material.clone(),
                 transform: Transform::from_translation(event.position)
                     .with_rotation(get_sprite_rotation())
-                    .with_scale(Vec3::new(12.0 / 8.0, 1.0, 1.0)),
+                    .with_scale(Vec3::new(1.0, 1.0, 1.0) * 2.0),
                 ..default()
             },
             Player,
@@ -157,6 +186,11 @@ fn spawn_player_by_event(
                 value: 1.0,
                 blocked: false
             },
+            AutoAnim {
+                set: PlayerAnim::Idle,
+                timer: Timer::from_seconds(0.1, TimerMode::Repeating),
+                current_frame: 0,
+            }
         )).with_children(|parent| {
             parent.spawn((
                 DogBarkSource,
@@ -456,3 +490,37 @@ fn set_cam_distance(
 
     commands.entity(e).insert(CameraDistance(dist));
 }
+
+fn set_anim_state(
+    mut player : Query<(&mut AutoAnim<PlayerAnim>, &Velocity, &mut Transform)>,
+    input: Res<Input<KeyCode>>
+) {
+    let Ok((mut player, vel, mut t)) = player.get_single_mut() else {
+        return;
+    };
+
+    let moving = input.any_pressed([KeyCode::W, KeyCode::S, KeyCode::A, KeyCode::D]);
+    let barking = input.pressed(KeyCode::Space);
+    let big_bark = input.pressed(KeyCode::ControlLeft);
+
+    if big_bark {
+        player.set = PlayerAnim::BigBark;
+    } else {
+        if barking && moving {
+            player.set = PlayerAnim::WalkAndBark;
+        } else if barking {
+            player.set = PlayerAnim::Bark;
+        } else if moving {
+            player.set = PlayerAnim::Walk;
+        } else {
+            player.set = PlayerAnim::Idle;
+        }
+    }
+
+    if vel.0.x > 0.1 {
+        t.rotation = get_sprite_rotation();
+        t.rotate_local_z(PI);
+    } else if vel.0.x < -0.1 {
+        t.rotation = get_sprite_rotation();
+    }
+}

src/sheep.rs

@@ -77,7 +77,9 @@ impl Plugin for SheepPlugin {
                 .with_spatial_ds(SpatialStructure::KDTree3),
         )
         .add_systems(Update, collect_field)
-        .add_plugins(AutoAnimPlugin::<SheepAnim>::default());
+        .add_plugins(AutoAnimPlugin::<SheepAnim>::default())
+
+        .add_systems(Update, set_anim_state.in_set(GameSet::Playing));
     }
 }
 
@@ -478,7 +480,7 @@ pub fn setup(
                 material: sheep_material.clone(),
                 transform: Transform::from_xyz(pos.x, pos.y, pos.z)
                     .with_rotation(get_sprite_rotation())
-                    .with_scale(Vec3::new(1.0, 1.0, 1.0) * 1.7),
+                    .with_scale(Vec3::new(1.0, 1.0, 1.0) * 2.0),
                 ..default()
             },
             Sheep::default(),
@@ -595,3 +597,19 @@ fn collect_field(
         }
     }
 }
+
+fn set_anim_state(
+    mut sheep : Query<(&mut AutoAnim<SheepAnim>, Option<&GoTo>, Option<&IdleFeeding>, Option<&IsScared>), With<Sheep>>
+) {
+    for (mut anim, go_to, idle, scared) in sheep.iter_mut() {
+        if go_to.is_some() {
+            anim.set = SheepAnim::Walk;
+        } else if idle.is_some() {
+            anim.set = SheepAnim::Feed;
+        } else if scared.is_some() {
+            anim.set = SheepAnim::Walk;
+        } else {
+            anim.set = SheepAnim::Idle;
+        }
+    }
+}

src/wolf.rs

@@ -9,7 +9,7 @@ use crate::{
     player::{Bark, DOG_SPEED},
     safe_area::{OutOfSafeArea, SafeArea},
     test_level::LevelSize,
-    GameStuff, auto_anim::{AnimSet, AnimRange, AutoAnimPlugin, AutoAnim},
+    GameStuff, auto_anim::{AnimSet, AnimRange, AutoAnimPlugin, AutoAnim}, corpse::SpawnCorpse,
 };
 
 const WOLF_SPEED: f32 = DOG_SPEED * 1.3;
@@ -121,7 +121,7 @@ fn wolf_spawner(
                     sheep_transform.translation.normalize() * level_size.0 * 2.0,
                 )
                 .with_rotation(get_sprite_rotation())
-                .with_scale(Vec3::new(1.0, 1.0, 1.0) * 2.0),
+                .with_scale(Vec3::new(1.0, 1.0, 1.0) * 3.0),
                 ..default()
             },
             TryToCatchSheep {
@@ -146,11 +146,14 @@ fn wolf_spawner(
     }
 }
 
+
+
 fn catch_system(
     mut commands: Commands,
     sheep: Query<&Transform>,
     mut wolfs: Query<(Entity, &Transform, &mut WalkController, &TryToCatchSheep)>,
     asset_server : Res<AssetServer>,
+    mut spawn_corpse : EventWriter<SpawnCorpse>
 ) {
     for (wolf, wolf_transform, mut walk_controller, try_to_catch_sheep) in wolfs.iter_mut() {
         let wolf_translation = wolf_transform.translation;
@@ -170,6 +173,8 @@ fn catch_system(
                     .entity(try_to_catch_sheep.target)
                     .despawn_recursive();
 
+                spawn_corpse.send(SpawnCorpse { position: sheep.translation });
+
                 commands.spawn(AudioBundle {
                     source: asset_server.load("audio/kill_sound.ogg"),
                     settings: PlaybackSettings {