Newer
Older

Louis
committed
use crate::directionality::Directionality;
use bevy_asset::{Asset, Handle};
use bevy_ecs::bundle::Bundle;
use bevy_ecs::component::Component;
use bevy_reflect::{Reflect, TypePath};
use bevy_sprite::Sprite;

Louis
committed
macro_rules! dr {
($type: ident -> $output: ty) => {
impl ::std::ops::Deref for $type {
type Target = $output;
fn deref(&self) -> &Self::Target {
&self.0
}
}

Louis
committed
impl ::std::ops::DerefMut for $type {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
};
}
#[derive(Clone, PartialOrd, PartialEq, Debug, Default, Reflect)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AnimationFrames {
pub frames: Vec<usize>,
pub frame_secs: f32,
}
impl AnimationFrames {
pub fn duration(&self) -> Duration {
Duration::from_secs_f32(self.frames.len() as f32 * self.frame_secs)

Louis
committed
#[derive(Clone, Debug, TypePath, PartialEq, Default, Asset)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(transparent)
)]
pub struct AnimationSet(pub HashMap<String, AnimationFrames>);

Louis
committed
dr!(AnimationSet -> HashMap<String, AnimationFrames>);

Louis
committed
#[derive(Clone, Debug, Component, PartialEq, Default)]
pub struct AnimationHandle(pub Handle<AnimationSet>);

Louis
committed
dr!(AnimationHandle -> Handle<AnimationSet>);
#[derive(Copy, Clone, Debug, Component, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Copy, Clone, Debug, Component, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AnimationPaused;
#[derive(Copy, Clone, Debug, Component, PartialEq, Eq, Default)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(transparent)
)]
pub struct UserData(pub u128);
#[derive(Clone, Debug, Component, PartialEq, Eq, Default)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(untagged, rename_all = "snake_case")
)]
pub enum AnimationMode {
#[default]
Loop,
Once,
#[derive(Clone, Debug, Component, PartialEq, PartialOrd)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AnimationStatus {
pub active_name: String,
pub active_step: usize,
pub frame_time: f32,
}
impl Default for AnimationStatus {
fn default() -> Self {
Self {
active_name: String::from("idle"),
active_step: 0,
frame_time: 0.0,
}
}
}
impl From<String> for AnimationStatus {
fn from(value: String) -> Self {
AnimationStatus {
active_name: value,
active_step: 0,
frame_time: 0.0,
}
}
}
pub fn new(name: impl ToString) -> Self {
AnimationStatus {
active_name: name.to_string(),
active_step: 0,
frame_time: 0.0,
}
}
pub fn start_animation(&mut self, name: impl ToString) {
self.active_name = name.to_string();
self.active_step = 0;
}
pub fn start_or_continue(&mut self, name: impl ToString) {
let name = name.to_string();
if self.active_name != name {
self.active_name = name;
self.active_step = 0;
}
}
}
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
#[derive(Component)]
#[require(AnimationHandle, AnimationStatus, AnimationMode, Sprite)]
pub struct SpriteAnimation;
pub fn create_sprite_animation(
handle: Handle<AnimationSet>,
initial_anim: impl ToString,
) -> impl Bundle {
(
SpriteAnimation,
AnimationHandle(handle),
AnimationStatus::new(initial_anim),
)
}
#[derive(Component)]
#[require(
AnimationHandle,
AnimationStatus,
AnimationMode,
Directionality,
Sprite
)]
pub struct DirectionalAnimation;
pub fn create_directional_animation(
handle: Handle<AnimationSet>,
initial_anim: impl ToString,
) -> impl Bundle {
(
DirectionalAnimation,
AnimationHandle(handle),
AnimationStatus::new(initial_anim),
)
}
#[derive(Component)]
#[require(Sprite, SyncToParent)]
pub struct ChildAnimation;
pub fn create_child_animation() -> impl Bundle {
(ChildAnimation,)

Louis
committed
#[derive(Clone, Debug, Component, PartialEq, PartialOrd, Default)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(transparent)
)]

Louis
committed
dr!(SimpleAnimation -> AnimationFrames);
impl From<AnimationFrames> for SimpleAnimation {
fn from(value: AnimationFrames) -> Self {
SimpleAnimation(value)
}
}
#[derive(Copy, Clone, Debug, Component, PartialEq, PartialOrd, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub active_step: usize,
pub frame_time: f32,
}
pub fn new(frames: Vec<usize>, frame_secs: f32) -> Self {
AnimationFrames { frames, frame_secs }.into()

Louis
committed
#[derive(Clone, Debug, Component, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct OverrideData(pub u128);

Louis
committed
dr!(OverrideData -> u128);

Louis
committed
#[derive(Clone, Debug, Component, PartialEq, Default)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(transparent)
)]
pub struct AnimationOverride(pub AnimationStatus);

Louis
committed
dr!(AnimationOverride -> AnimationStatus);
impl AnimationOverride {
AnimationOverride(name.to_string().into())
impl From<AnimationStatus> for AnimationOverride {
fn from(other: AnimationStatus) -> Self {
Self(other)
}
}
impl From<String> for AnimationOverride {
fn from(other: String) -> Self {
AnimationStatus::from(other).into()
}
}
#[derive(Bundle, Default)]
pub struct AnimationOverrideBundle {
pub anim: AnimationOverride,
pub data: OverrideData,
impl AnimationOverrideBundle {
pub fn new(anim: impl Into<AnimationOverride>) -> Self {
anim: anim.into(),
data: OverrideData(0),