Merge branch 'master' of https://github.com/Allexit/GladiatorBrawler

.gitignore

@@ -53,6 +53,7 @@ dist/
 nbdist/
 nbactions.xml
 nb-configuration.xml
+.nb-gradle/
 
 ## Gradle
 
@@ -62,3 +63,4 @@ build/
 
 ## OS Specific
 .DS_Store
+/.nb-gradle/private/

core/src/com/saltosion/gladiator/GladiatorBrawler.java

@@ -3,7 +3,6 @@ package com.saltosion.gladiator;
 import com.badlogic.ashley.core.Engine;
 import com.badlogic.ashley.core.Entity;
 import com.badlogic.ashley.core.EntityListener;
-import com.badlogic.ashley.core.Family;
 import com.badlogic.gdx.ApplicationAdapter;
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.graphics.g2d.Sprite;
@@ -11,85 +10,132 @@ import com.badlogic.gdx.math.Vector2;
 import com.saltosion.gladiator.components.CPhysics;
 import com.saltosion.gladiator.components.CRenderedObject;
 import com.saltosion.gladiator.input.InputHandler;
+import com.saltosion.gladiator.systems.PhysicsSystem;
 import com.saltosion.gladiator.systems.RenderingSystem;
 import com.saltosion.gladiator.util.AppUtil;
+import com.saltosion.gladiator.util.Global;
 import com.saltosion.gladiator.util.Name;
 import com.saltosion.gladiator.util.SpriteLoader;
 import com.saltosion.gladiator.util.SpriteSequence;
 
 public class GladiatorBrawler extends ApplicationAdapter {
 
-	private Engine engine;
+    private Engine engine;
-	private InputHandler inputHandler;
+    private InputHandler inputHandler;
 
-	private float physics_accumulator = 0f;
+    private Entity player;
 
-	private Entity player;
+    @Override
+    public void create() {
 
-	@Override
+        // Initialize the Engine
-	public void create () {
+        engine = new Engine();
 
-		// Initialize the Engine
+        engine.addSystem(new PhysicsSystem());
+        engine.addEntityListener(new EntityListener() {
+            @Override
+            public void entityAdded(Entity entity) {
+                PhysicsSystem ps = engine.getSystem(PhysicsSystem.class);
+                ps.updateEntities(engine);
+            }
 
-		engine = new Engine();
+            @Override
+            public void entityRemoved(Entity entity) {
+                PhysicsSystem ps = engine.getSystem(PhysicsSystem.class);
+                ps.updateEntities(engine);
+            }
+        });
 
-		engine.addSystem(new RenderingSystem());
+        engine.addSystem(new RenderingSystem());
+        engine.addEntityListener(new EntityListener() {
+            @Override
+            public void entityRemoved(Entity entity) {
+                RenderingSystem rs = engine.getSystem(RenderingSystem.class);
+                rs.updateEntities(engine);
+            }
 
-		engine.addEntityListener(Family.getFor(), 
+            @Override
-				new EntityListener() {
+            public void entityAdded(Entity entity) {
-					@Override
+                RenderingSystem rs = engine.getSystem(RenderingSystem.class);
-					public void entityRemoved(Entity entity) {
+                rs.updateEntities(engine);
-						RenderingSystem rs = engine.getSystem(RenderingSystem.class);
+            }
-						rs.updateEntities(engine);
+        });
-					}
 
-					@Override
+        // Initialize stuff in the world
-					public void entityAdded(Entity entity) {
+        initializePlayer();
-						RenderingSystem rs = engine.getSystem(RenderingSystem.class);
+        initializeLevel();
-						rs.updateEntities(engine);
 
-					}
+        // Initialize input
-				});
+        inputHandler = new InputHandler();
+        Gdx.input.setInputProcessor(inputHandler);
+    }
 
+    @Override
+    public void render() {
+        engine.update(Gdx.graphics.getDeltaTime());
+    }
 
-		// Initialize stuff in the world
+    public void initializePlayer() {
 
-		initializePlayer();
+        player = new Entity();
 
-		// Initialize input
+        CRenderedObject renderedObject = new CRenderedObject();
+        Sprite player1 = SpriteLoader.loadSprite(Name.PLAYERIMG, 0, 0, 64, 64);
+        Sprite player2 = SpriteLoader.loadSprite(Name.PLAYERIMG, 1, 0, 64, 64);
+        SpriteSequence sequence = new SpriteSequence(1).addSprite(player1).addSprite(player2);
+        renderedObject.addSequence("Idle", sequence);
+        renderedObject.playAnimation("Idle");
+        player.add(renderedObject);
+        player.add(new CPhysics().setSize(player1.getRegionWidth() * Global.SPRITE_SCALE,
+                player1.getRegionHeight() * Global.SPRITE_SCALE).setPosition(0, 5));
 
-		inputHandler = new InputHandler();
+        engine.addEntity(player);
-		Gdx.input.setInputProcessor(inputHandler);
-	}
 
-	@Override
+        AppUtil.player = player;
-	public void render () {
+    }
-		engine.update(Gdx.graphics.getDeltaTime());
-	}
 
-	public void initializePlayer() {
+    public void initializeLevel() {
+        Entity ground = new Entity();
 
-		player = new Entity();
+        Sprite groundSprite = SpriteLoader.loadSprite(Name.GROUNDIMG, 0, 0, 256, 64);
+        CRenderedObject renderedObject = new CRenderedObject(groundSprite);
+        ground.add(renderedObject);
+        CPhysics physics = new CPhysics().setMovable(false).setGravityApplied(false).setDynamic(false)
+                .setSize(groundSprite.getRegionWidth() * Global.SPRITE_SCALE,
+                        groundSprite.getRegionHeight() * Global.SPRITE_SCALE);
+        physics.position.set(new Vector2(0, -4));
+        ground.add(physics);
 
-		CRenderedObject renderedObject = new CRenderedObject();
+        Sprite wallSprite = SpriteLoader.loadSprite(Name.WALLIMG, 0, 0, 64, 64);
-		Sprite player1 = SpriteLoader.loadSprite(Name.PLAYERIMG, 0, 0, 64, 64);
-		Sprite player2 = SpriteLoader.loadSprite(Name.PLAYERIMG, 1, 0, 64, 64);
-		SpriteSequence sequence = new SpriteSequence(1).addSprite(player1).addSprite(player2);
-		renderedObject.addSequence("Idle", sequence);
-		renderedObject.playAnimation("Idle");
-		player.add(renderedObject);
-		player.add(new CPhysics());
 
-		engine.addEntity(player);
+        Entity wall0 = new Entity();
+        CRenderedObject wall0RenderedObject = new CRenderedObject(wallSprite);
+        CPhysics wall0Physics = new CPhysics().setMovable(false).setGravityApplied(false).setDynamic(false)
+                .setSize(wallSprite.getRegionWidth() * Global.SPRITE_SCALE,
+                        wallSprite.getRegionHeight() * Global.SPRITE_SCALE);
+        wall0Physics.position.set(new Vector2(6, 0));
+        wall0.add(wall0RenderedObject);
+        wall0.add(wall0Physics);
 
-		AppUtil.player = player;
+        Entity wall1 = new Entity();
-	}
+        CRenderedObject wall1RenderedObject = new CRenderedObject(wallSprite);
+        CPhysics wall1Physics = new CPhysics().setMovable(false).setGravityApplied(false).setDynamic(false)
+                .setSize(wallSprite.getRegionWidth() * Global.SPRITE_SCALE,
+                        wallSprite.getRegionHeight() * Global.SPRITE_SCALE);
+        wall1Physics.position.set(new Vector2(-6, 0));
+        wall1.add(wall1RenderedObject);
+        wall1.add(wall1Physics);
 
-	@Override
+        engine.addEntity(ground);
-	public void resize(int width, int height) {
+        engine.addEntity(wall0);
-		super.resize(width, height);
+        engine.addEntity(wall1);
-		RenderingSystem rs = engine.getSystem(RenderingSystem.class);
+    }
-		float aspectratio = ((float)width)/((float)height);
+
-		rs.setViewport((int)(AppUtil.VPHEIGHT_CONST*aspectratio), AppUtil.VPHEIGHT_CONST);
+    @Override
-	}
+    public void resize(int width, int height) {
+        super.resize(width, height);
+        RenderingSystem rs = engine.getSystem(RenderingSystem.class);
+        float aspectratio = ((float) width) / ((float) height);
+        rs.setViewport((int) (AppUtil.VPHEIGHT_CONST * aspectratio), AppUtil.VPHEIGHT_CONST);
+    }
 }

core/src/com/saltosion/gladiator/components/CPhysics.java

@@ -2,13 +2,57 @@ package com.saltosion.gladiator.components;
 
 import com.badlogic.ashley.core.Component;
 import com.badlogic.gdx.math.Vector2;
+import com.saltosion.gladiator.physics.CollisionListener;
 
 public class CPhysics extends Component {
 
-	public Vector2 position = new Vector2(0, 0);
+    public Vector2 position = new Vector2();
-	public Vector2 velocity = new Vector2(0, 0);
+    public Vector2 velocity = new Vector2();
-	public boolean movingLeft = false;
+    public Vector2 size = new Vector2();
-	public boolean movingRight = false;
+    public float movespeed = 5f, jumpForce = 0.3f, gravity = 1f;
-	public boolean jumping = false;
+    public boolean grounded = true;
-	public boolean grounded = true;
+    public CollisionListener collisionListener = null;
+
+    // Movable toggles if the entity can move by itself
+    public boolean movable = true;
+    // GravityApplied toggles if the entity is affected by gravity
+    public boolean gravityApplied = true;
+    // Dynamic toggles if the entity processes collisions
+    public boolean dynamic = true;
+
+    // Movement (/input) vars
+    public boolean movingLeft = false;
+    public boolean movingRight = false;
+    public boolean jumping = false;
+
+    public CPhysics setMovable(boolean movable) {
+        this.movable = movable;
+        return this;
+    }
+
+    public CPhysics setGravityApplied(boolean gravityApplied) {
+        this.gravityApplied = gravityApplied;
+        return this;
+    }
+
+    public CPhysics setDynamic(boolean dynamic) {
+        this.dynamic = dynamic;
+        return this;
+    }
+
+    public CPhysics setSize(float w, float h) {
+        this.size.set(w, h);
+        return this;
+    }
+
+    public CPhysics setPosition(float x, float y) {
+        this.position.set(x, y);
+        return this;
+    }
+
+    public CPhysics setCollisionListener(CollisionListener collisionListener) {
+        this.collisionListener = collisionListener;
+        return this;
+    }
+
 }

core/src/com/saltosion/gladiator/input/IRJump.java

@@ -5,19 +5,18 @@ import com.saltosion.gladiator.util.AppUtil;
 
 public class IRJump implements InputReceiver {
 
-	@Override
+    @Override
-	public boolean pressed() {
+    public boolean pressed() {
-		CPhysics physics = AppUtil.player.getComponent(CPhysics.class);
+        CPhysics physics = AppUtil.player.getComponent(CPhysics.class);
-		physics.jumping = true;
+        physics.jumping = true;
-		return true;
+        return true;
-	}
+    }
 
-	@Override
+    @Override
-	public boolean released() {
+    public boolean released() {
-		CPhysics physics = AppUtil.player.getComponent(CPhysics.class);
+        CPhysics physics = AppUtil.player.getComponent(CPhysics.class);
-		physics.jumping = false;
+        physics.jumping = false;
-		physics.grounded = true;
+        return true;
-		return true;
+    }
-	}
 
 }

core/src/com/saltosion/gladiator/physics/CollisionListener.java

@@ -0,0 +1,22 @@
+package com.saltosion.gladiator.physics;
+
+import com.badlogic.ashley.core.Entity;
+
+/**
+ *
+ * @author Jens "Jeasonfire" Pitkänen <jeasonfire@gmail.com>
+ */
+public interface CollisionListener {
+
+    /**
+     * This method will be called when host collides with other
+     *
+     * @param side The side which host is colliding other with. Eg. if host is
+     * falling towards other, this argument will be CollisionSide.BOTTOM when
+     * the collision happens.
+     * @param host
+     * @param other
+     */
+    public void collision(CollisionSide side, Entity host, Entity other);
+
+}

core/src/com/saltosion/gladiator/physics/CollisionSide.java

@@ -0,0 +1,11 @@
+package com.saltosion.gladiator.physics;
+
+/**
+ *
+ * @author Jens "Jeasonfire" Pitkänen <jeasonfire@gmail.com>
+ */
+public enum CollisionSide {
+
+    TOP, BOTTOM, LEFT, RIGHT
+
+}

core/src/com/saltosion/gladiator/systems/PhysicsSystem.java

@@ -0,0 +1,137 @@
+package com.saltosion.gladiator.systems;
+
+import com.badlogic.ashley.core.ComponentMapper;
+import com.badlogic.ashley.core.Engine;
+import com.badlogic.ashley.core.Entity;
+import com.badlogic.ashley.core.EntitySystem;
+import com.badlogic.ashley.core.Family;
+import com.badlogic.ashley.utils.ImmutableArray;
+import com.saltosion.gladiator.components.CPhysics;
+import com.saltosion.gladiator.physics.CollisionSide;
+
+/**
+ *
+ * @author Jens "Jeasonfire" Pitkänen <jeasonfire@gmail.com>
+ */
+public class PhysicsSystem extends EntitySystem {
+
+    private ComponentMapper<CPhysics> pm = ComponentMapper.getFor(CPhysics.class);
+    private ImmutableArray<Entity> entities;
+
+    @Override
+    public void addedToEngine(Engine engine) {
+        updateEntities(engine);
+    }
+
+    @Override
+    public void update(float deltaTime) {
+        for (int i = 0; i < entities.size(); i++) {
+            CPhysics obj = pm.get(entities.get(i));
+
+            // Movement
+            if (obj.movable) {
+                float move = 0;
+                if (obj.movingLeft) {
+                    move--;
+                }
+                if (obj.movingRight) {
+                    move++;
+                }
+                obj.velocity.x = move * obj.movespeed * deltaTime;
+                if (obj.jumping && obj.grounded) {
+                    obj.grounded = false;
+                    obj.velocity.y = obj.jumpForce;
+                }
+            }
+
+            // Gravity
+            if (obj.gravityApplied) {
+                obj.velocity.y -= obj.gravity * deltaTime;
+            }
+
+            // Collisions
+            if (obj.dynamic) {
+                for (int j = 0; j < entities.size(); j++) {
+                    if (i == j) {
+                        continue;
+                    }
+                    collision(entities.get(i), entities.get(j));
+                }
+            }
+
+            // Apply movement
+            obj.position.add(obj.velocity);
+        }
+    }
+
+    public void collision(Entity entity0, Entity entity1) {
+        CPhysics cp0 = pm.get(entity0);
+        CPhysics cp1 = pm.get(entity1);
+
+        float x00 = cp0.position.x - cp0.size.x / 2;
+        float x01 = cp0.position.x + cp0.size.x / 2;
+        float x10 = cp1.position.x - cp1.size.x / 2;
+        float x11 = cp1.position.x + cp1.size.x / 2;
+        float y00 = cp0.position.y - cp0.size.y / 2;
+        float y01 = cp0.position.y + cp0.size.y / 2;
+        float y10 = cp1.position.y - cp1.size.y / 2;
+        float y11 = cp1.position.y + cp1.size.y / 2;
+
+        boolean colliding = (x00 < x11) && (x01 > x10) && (y00 < y11) && (y01 > y10);
+
+        if (!colliding) {
+            return;
+        }
+
+        if (x00 <= x11 && Math.abs(x00 - x11) < (cp0.size.x + cp1.size.x) / 16) {
+            // cp0's left side is colliding with cp1's right side
+            if (cp0.velocity.x < 0) {
+                // cp0 is going left, stop
+                cp0.velocity.x = 0;
+            }
+
+            if (cp0.collisionListener != null) {
+                cp0.collisionListener.collision(CollisionSide.LEFT, entity0, entity1);
+            }
+        }
+        if (x01 > x10 && Math.abs(x01 - x10) < (cp0.size.x + cp1.size.x) / 16) {
+            // cp0's right side is colliding with cp1's left side
+            if (cp0.velocity.x > 0) {
+                // cp0 is going right, stop
+                cp0.velocity.x = 0;
+            }
+
+            if (cp0.collisionListener != null) {
+                cp0.collisionListener.collision(CollisionSide.RIGHT, entity0, entity1);
+            }
+        }
+        if (y00 <= y11 && Math.abs(y00 - y11) < (cp0.size.y + cp1.size.y) / 16) {
+            // cp0's bottom side is colliding with cp1's top side
+            if (cp0.velocity.y < 0) {
+                // cp0 is going down, stop
+                cp0.velocity.y = 0;
+            }
+            cp0.grounded = true;
+
+            if (cp0.collisionListener != null) {
+                cp0.collisionListener.collision(CollisionSide.BOTTOM, entity0, entity1);
+            }
+        }
+        if (y01 > y10 && Math.abs(y01 - y10) < (cp0.size.y + cp1.size.y) / 16) {
+            // cp0's top side is colliding with cp1's bottom side
+            if (cp0.velocity.y > 0) {
+                // cp0 is going up, stop
+                cp0.velocity.y = 0;
+            }
+
+            if (cp0.collisionListener != null) {
+                cp0.collisionListener.collision(CollisionSide.TOP, entity0, entity1);
+            }
+        }
+    }
+
+    public void updateEntities(Engine engine) {
+        entities = engine.getEntitiesFor(Family.getFor(CPhysics.class));
+    }
+
+}

core/src/com/saltosion/gladiator/util/AppUtil.java

@@ -1,13 +1,13 @@
-	package com.saltosion.gladiator.util;
+package com.saltosion.gladiator.util;
 
 import com.badlogic.ashley.core.Entity;
 import com.badlogic.gdx.math.Vector2;
 
 public class AppUtil {
 
-	public static Entity player;
+    public static Entity player;
 
-	public static final int VPHEIGHT_CONST = 14;
+    public static final int VPHEIGHT_CONST = 24;
 
-	public static final Vector2 JUMP_FORCE = new Vector2(0, 12000);
+    public static final Vector2 JUMP_FORCE = new Vector2(0, 12000);
 }

core/src/com/saltosion/gladiator/util/Global.java

@@ -1,13 +1,13 @@
-	package com.saltosion.gladiator.util;
+package com.saltosion.gladiator.util;
 
 public class Global {
 
-	public static final String STATICPLAYER = "STATICPLAYER";
+    public static final String STATICPLAYER = "STATICPLAYER";
-	public static final String PLAYERIMG = "PLAYERIMG";
+    public static final String PLAYERIMG = "PLAYERIMG";
 
-	public static final String GAME_NAME = "Gladiator Brawl";
+    public static final String GAME_NAME = "Gladiator Brawl";
 
-	public static final int VPHEIGHT_CONST = 14;
+    public static final int VPHEIGHT_CONST = 14;
-	public static final float PHYSICS_TIMESTEP = 1/45f;
+    public static final float SPRITE_SCALE = 1 / 16f;
 
 }

core/src/com/saltosion/gladiator/util/Name.java

@@ -2,13 +2,15 @@ package com.saltosion.gladiator.util;
 
 public class Name {
 
-	public static final String GAME_NAME = "Gladiator Brawl";
+    public static final String GAME_NAME = "Gladiator Brawl";
 
-	public static final String STATICPLAYER = "STATICPLAYER";
+    public static final String STATICPLAYER = "STATICPLAYER";
-	public static final String PLAYERIMG = "PLAYERIMG";
+    public static final String PLAYERIMG = "PLAYERIMG";
+    public static final String GROUNDIMG = "GROUNDIMG";
+    public static final String WALLIMG = "WALLIMG";
 
-	public static final String MOVE_LEFT = "MOVE_LEFT";
+    public static final String MOVE_LEFT = "MOVE_LEFT";
-	public static final String MOVE_RIGHT = "MOVE_RIGHT";
+    public static final String MOVE_RIGHT = "MOVE_RIGHT";
-	public static final String JUMP = "JUMP";
+    public static final String JUMP = "JUMP";
 
 }

core/src/com/saltosion/gladiator/util/SpriteLoader.java

@@ -9,55 +9,60 @@ import com.badlogic.gdx.graphics.g2d.TextureRegion;
 
 public class SpriteLoader {
 
-	public static HashMap<String, Texture> textures = new HashMap<String, Texture>();
+    public static HashMap<String, Texture> textures = new HashMap<String, Texture>();
 
-	static {
+    static {
-		loadTexture(Name.STATICPLAYER, "sprites/staticplayer.png");
+        loadTexture(Name.STATICPLAYER, "sprites/staticplayer.png");
-		loadTexture(Name.PLAYERIMG, "sprites/player/player.png");
+        loadTexture(Name.PLAYERIMG, "sprites/player/player.png");
-	}
+        loadTexture(Name.GROUNDIMG, "sprites/ground.png");
+        loadTexture(Name.WALLIMG, "sprites/wall.png");
+    }
 
-	/**
+    /**
-	 * Returns a sprite, which is a piece from texture.
+     * Returns a sprite, which is a piece from texture.
-	 * @param texKey
+     *
-	 * @param x
+     * @param texKey
-	 * @param y
+     * @param x
-	 * @param width
+     * @param y
-	 * @param height
+     * @param width
-	 * @return
+     * @param height
-	 */
+     * @return
-	public static Sprite loadSprite(String texKey, int x, int y, int width, int height) {
+     */
-		TextureRegion tr = new TextureRegion(textures.get(texKey), x*width, y*height, width, height);
+    public static Sprite loadSprite(String texKey, int x, int y, int width, int height) {
-		Sprite s = new Sprite(tr);
+        TextureRegion tr = new TextureRegion(textures.get(texKey), x * width, y * height, width, height);
-		s.setScale(1/16f);
+        Sprite s = new Sprite(tr);
-		return s;
+        s.setScale(Global.SPRITE_SCALE);
-	}
+        return s;
+    }
 
-	/**
+    /**
-	 * Returns a sprite, which is originally a texture.
+     * Returns a sprite, which is originally a texture.
-	 * @param texKey
+     *
-	 * @return
+     * @param texKey
-	 */
+     * @return
-	public static Sprite loadSprite(String texKey) {
+     */
-		return loadSprite(texKey, 0, 0, textures.get(texKey).getWidth(), textures.get(texKey).getHeight());
+    public static Sprite loadSprite(String texKey) {
-	}
+        return loadSprite(texKey, 0, 0, textures.get(texKey).getWidth(), textures.get(texKey).getHeight());
+    }
 
-	/**
+    /**
-	 * Load texture from path.
+     * Load texture from path.
-	 * @param filePath 
+     *
-	 */
+     * @param filePath
-	public static Texture loadTexture(String key, String filePath) {
+     */
-		Texture t = new Texture(Gdx.files.internal(filePath));
+    public static Texture loadTexture(String key, String filePath) {
-		textures.put(key, t);
+        Texture t = new Texture(Gdx.files.internal(filePath));
-		return t;
+        textures.put(key, t);
-	}
+        return t;
+    }
 
-	/**
+    /**
-	 * Disposes all the textures loaded so far.
+     * Disposes all the textures loaded so far.
-	 */
+     */
-	public static void dispose () {
+    public static void dispose() {
-		for (Texture tex : textures.values()) {
+        for (Texture tex : textures.values()) {
-			tex.dispose();
+            tex.dispose();
-		}
+        }
-	}
+    }
 
 }

core/src/com/saltosion/gladiator/util/SpriteSequence.java

@@ -6,39 +6,37 @@ import com.badlogic.gdx.graphics.g2d.Sprite;
 
 public class SpriteSequence {
 
-	private ArrayList<Sprite> sprites = new ArrayList<Sprite>();
+    private final ArrayList<Sprite> sprites = new ArrayList<Sprite>();
-	private float defaultPlayspeed = 1;
+    private float defaultPlayspeed = 1;
 
-	/**
+    /**
-	 * A static single image.
+     * A static single image.
-	 * @param sprite
+     *
-	 */
+     * @param sprite
-	public SpriteSequence(Sprite sprite) {
+     */
-		sprites.add(sprite);
+    public SpriteSequence(Sprite sprite) {
-		defaultPlayspeed = 0;
+        sprites.add(sprite);
-	}
+        defaultPlayspeed = 0;
+    }
 
-	public SpriteSequence(float playspeed) {
+    public SpriteSequence(float playspeed) {
-		this.defaultPlayspeed = playspeed;
+        this.defaultPlayspeed = playspeed;
-		if (sprites != null) {
+    }
-			this.sprites = sprites;
-		}
-	}
 
-	public SpriteSequence addSprite(Sprite s) {
+    public SpriteSequence addSprite(Sprite s) {
-		sprites.add(s);
+        sprites.add(s);
-		return this;
+        return this;
-	}
+    }
 
-	public Sprite getSprite(int index) {
+    public Sprite getSprite(int index) {
-		return sprites.get(index);
+        return sprites.get(index);
-	}
+    }
 
-	public float getPlayspeed() {
+    public float getPlayspeed() {
-		return defaultPlayspeed;
+        return defaultPlayspeed;
-	}
+    }
 
-	public int frameCount() {
+    public int frameCount() {
-		return sprites.size();
+        return sprites.size();
-	}
+    }
 }