specs_sprite

sprite component for specs

```rust extern crate specssprite; extern crate specsguidedjoin; extern crate specsbundler; extern crate specs;

use specssprite::{Sprite, SpriteGuide, SpriteBundle}; use specsguidedjoin::GuidedJoin; use specsbundler::SpecsBundler; use specs::{Builder, Join, World, DispatcherBuilder};

fn main() { let mut world = World::new();

let mut dispatcher = SpecsBundler::new(&mut world, DispatcherBuilder::new())
    .bundle(SpriteBundle::<f32, usize>::default()).unwrap()
    .build();

// just using an unsigned integer for the image
let mut s0 = Sprite::<f32, usize>::new(0);
s0.set_layer(1);
s0.set_z(1);
let _ = world.create_entity()
    .with(s0)
    .build();

let mut s1 = Sprite::<f32, usize>::new(1);
s1.set_layer(0);
s1.set_z(0);
let _ = world.create_entity()
    .with(s1)
    .build();

let mut s2 = Sprite::<f32, usize>::new(2);
s2.set_layer(1);
s2.set_z(0);
let _ = world.create_entity()
    .with(s2)
    .build();

dispatcher.dispatch(&mut world.res);

let read_sprites = world.read::<Sprite<f32, usize>>();
let read_guide = world.read_resource::<SpriteGuide<f32>>();

let sprites: Vec<&Sprite<f32, usize>> = (&read_sprites).join().collect();
let ordered_sprites: Vec<&Sprite<f32, usize>> = (&read_sprites).guided_join(read_guide.as_slice()).collect();

assert_eq!(sprites.iter().map(|s| s.image).collect::<Vec<usize>>(), [0, 1, 2].to_vec());
assert_eq!(ordered_sprites.iter().map(|s| s.image).collect::<Vec<usize>>(), [1, 2, 0].to_vec());

} ```