[2D][SpriteSheet] Change sprite sheets

[The-DevBlog]

I have separate spritesheets I want to play when the player moves up, down, left & right. I figured I could 'load' all the assets on setup, then just switch which one im actively using in my movement system. The problem is, I cant seem to figure out a good way to modify the current Image Handle.

Here is some sample code of the logic I am currently using.

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
enum GameState {
    Setup,
    Finished,
}

#[derive(Default)]
struct RpgSpriteHandles {
    handles: Vec<HandleUntyped>,
}

#[derive(Component)]
struct Player;

fn load_textures(mut rpg_sprite_handles: ResMut<RpgSpriteHandles>, asset_server: Res<AssetServer>) {
    rpg_sprite_handles.handles = asset_server.load_folder("hero").unwrap();
}

fn check_textures(
    mut state: ResMut<State<GameState>>,
    rpg_sprite_handles: ResMut<RpgSpriteHandles>,
    asset_server: Res<AssetServer>,
) {
    if let LoadState::Loaded =
        asset_server.get_group_load_state(rpg_sprite_handles.handles.iter().map(|handle| handle.id))
    {
        state.set(GameState::Finished).unwrap();
    }
}

This is the movement system. When I press 'A', I want the left facing spritesheet to be used, and similarly with the 'W', 'D', & 'S' keys. This is currently the only way I can seem to get it to work. The issue with this is that I am always creating a new 'Handle' instead of modifying the existing one. I've tried to modify the existing one by passing in '&Handle' in the query, but that does not work.

fn movement(
    rpg_sprite_handles: Res<RpgSpriteHandles>,
    asset_server: Res<AssetServer>,
    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
    mut textures: ResMut<Assets<Image>>,
    keys: Res<Input<KeyCode>>,
    mut query: Query<(&mut Handle<TextureAtlas>, &mut TextureAtlasSprite), With<Player>>,
) {
    for (mut t_atlas, mut sprite) in query.iter_mut() {
        let mut texture_atlas_builder = TextureAtlasBuilder::default();
        for handle in &rpg_sprite_handles.handles {
            let texture = textures.get(handle).unwrap();
            texture_atlas_builder.add_texture(handle.clone_weak().typed::<Image>(), texture);
        }

        let texture_atlas = texture_atlas_builder.finish(&mut textures).unwrap();
        let mut vendor_handle = asset_server.get_handle("hero/idle_L.png");

        if keys.pressed(KeyCode::A) {
            vendor_handle = asset_server.get_handle("hero/idle_L.png");
        } else if keys.pressed(KeyCode::D) {
            vendor_handle = asset_server.get_handle("hero/idle_R.png");
        } else if keys.pressed(KeyCode::W) {
            vendor_handle = asset_server.get_handle("hero/idle_U.png");
        } else if keys.pressed(KeyCode::S) {
            vendor_handle = asset_server.get_handle("hero/idle_D.png");
        }

        let vendor_index = texture_atlas.get_texture_index(&vendor_handle).unwrap();
        let atlas_handle = texture_atlases.add(texture_atlas);

        *sprite = TextureAtlasSprite::new(vendor_index);
        *t_atlas = atlas_handle.clone();
    }
}

[wilk10]

A solution would be to have a resource that stores the player handles. It may look like this, for example:

pub struct PlayerHandles {
    pub idle_left: Handle<TextureAtlas>,
    pub idle_right: Handle<TextureAtlas>,
    pub idle_up: Handle<TextureAtlas>,
    pub idle_down: Handle<TextureAtlas>,
}

When the movement system runs then you want to mutate the player's Handle<TextureAtlas>, taking the value from the PlayerHandles, based on the movement direction. You'll need to clone it.

To have the 4 different handles, you'll need to add them to the assets separately, so after the check_textures system runs you need an additional system that adds the texture atlases (like at the top of the movement system), but only once, and saves these handles into PlayerHandles.

Hope it's clear and it helps! Let us know if not.