bevy_2dviewangle 0.12.3

Bevy plugin for easier to switch texture base on view angles
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142


use bevy::asset::Assets;
use bevy::prelude::{
    Commands,
    Entity,
    MessageReader,
    MessageWriter,
    Query,
    Res,
    Sprite,
    TextureAtlasLayout,
    Time,
};

use crate::component::*;

/// Check on `ViewChanged` event and change to corresponding spritesheet.
/// If spritesheet for an angle does not exist, it will try to flip the spritesheet of the opposite angle.
/// If the opposite is not available, spritesheet will not change.
pub(crate) fn view_changed_event(
    mut events: MessageReader<ViewChanged>,
    mut sprites: Query<(&mut View2dActor, &mut Sprite)>,
    animation2d: Res<ActorSpriteSheets>,
) {
    for event in events.read() {
        if let Ok((mut view, mut sprite)) = sprites.get_mut(event.entity) {
            let mut action = view.action;
            let mut actor = view.actor;
            let any = get_act_id("any");

            let mut viewsprite = None;
            for _actor in [&view.actor, &any] {
                if let Some(actor_val) = animation2d.get(_actor) {
                    for _action in [&view.action, &any] {
                        if let Some(action_val) = actor_val.get(_action) {
                            viewsprite = action_val.get(&view.angle);
                            actor = *_actor;
                            action = *_action;
                            break;
                        }
                    }
                }
            }

            if view.flipped {
                sprite.flip_x = false;
                view.flipped = false;
            }

            // TODO: Clean code
            if viewsprite.is_none() {
                viewsprite = get_opposite_view(&animation2d[&actor][&action], view.angle);
                if viewsprite.is_some() {
                    sprite.flip_x = true;
                    view.flipped = true;
                }
            }
            if viewsprite.is_none() {
                viewsprite = animation2d[&actor][&action].get(&Angle::Any);
                if viewsprite.is_none() {
                    viewsprite = get_opposite_view(&animation2d[&actor][&action], Angle::Any);
                    if viewsprite.is_some() {
                        sprite.flip_x = true;
                        view.flipped = true;
                    } else {
                        return;
                    }
                }
            }

            let viewsprite = viewsprite.unwrap();

            if viewsprite.image.is_some() {
                sprite.image = viewsprite.image.as_ref().unwrap().clone();
                if let Some(atlas) = &mut sprite.texture_atlas {
                    if let Some(view_atlas) = &viewsprite.layout {
                        atlas.layout = view_atlas.clone();
                    }
                }
            }
        }
    }
}

fn get_opposite_view(texture: &AngleSpriteSheets, direction: Angle) -> Option<&SpriteSheet> {
    match direction {
        Angle::Left => texture.get(&Angle::Right),
        Angle::Right => texture.get(&Angle::Left),
        Angle::FrontLeft => texture.get(&Angle::FrontRight),
        Angle::FrontRight => texture.get(&Angle::FrontLeft),
        Angle::BackLeft => texture.get(&Angle::BackRight),
        Angle::BackRight => texture.get(&Angle::BackLeft),
        _ => None,
    }
}

pub(crate) fn animated_timer(
    time: Res<Time>,
    mut query: Query<(&mut View2dActor, Entity)>,
    mut event: MessageWriter<NextFrame>,
) {
    for (mut actor, entity) in &mut query {
        if let Some(ref mut animation_timer) = actor.animation_timer {
            animation_timer.tick(time.delta());
            if animation_timer.just_finished() {
                event.write(NextFrame { entity });
            }
        }
    }
}

pub(crate) fn animating(
    mut commands: Commands,
    atlases: Res<Assets<TextureAtlasLayout>>,
    mut query: Query<(&mut View2dActor, &mut Sprite, Entity)>,
    mut event: MessageWriter<ViewChanged>,
) {
    for (mut actor, mut sprite, entity) in &mut query {
        if let Some(atlas) = &mut sprite.texture_atlas {
            if let Some(layout) = atlases.get(&atlas.layout) {
                for notify in &actor.notify {
                    match *notify {
                        Notification::LastFrame => {
                            if atlas.index == layout.textures.len() - 1 {
                                commands.trigger(LastFrame { entity });
                            }
                        }
                    }
                }

                if atlas.index == layout.textures.len() - 1 {
                    if let Some(next_action) = actor.next_action.first() {
                        actor.action = *next_action;
                        event.write(ViewChanged { entity });
                        actor.next_action.remove(0);
                    }
                }
                atlas.index = (atlas.index + 1) % layout.textures.len();
            }
        }
    }
}